Erlang - C driver test

Author: alde103

.gitignore

@@ -1,5 +1,6 @@
 # The directory Mix will write compiled artifacts to.
 .elixir_ls/
+.vscode/
 /_build/
 
 # If you run "mix test --cover", coverage assets end up here.

Makefile

@@ -47,13 +47,15 @@ OBJ = $(SRC:.c=.o)
 
 .PHONY: all clean
 
-all: priv/snap7
+all: snap7 priv/snap7
 
-
-
-priv/snap7: $(OBJ) snap7
+priv/snap7: $(OBJ) 
+	@echo $(OBJ)
 	mkdir -p priv
-	$(CC) -O3 -v $(OBJ) -L$(SRC_PATH) -I$(SRC_PATH) -lsnap $(ERL_LDFLAGS) $(LDFLAGS) -o $@
+	#$(CC) -O3 -v $(OBJ) -L$(SRC_PATH) -I$(SRC_PATH) -lsnap $(ERL_LDFLAGS) $(LDFLAGS) -o $@
+	$(CC) -O3 src/erlcmd.o src/s7_client.o src/util.o -L$(SRC_PATH) -I$(SRC_PATH) -lsnap $(ERL_LDFLAGS) $(LDFLAGS) -o priv/s7_client
+	$(CC) -O3 src/erlcmd.o src/s7_server.o src/util.o -L$(SRC_PATH) -I$(SRC_PATH) -lsnap $(ERL_LDFLAGS) $(LDFLAGS) -o priv/s7_server
+	$(CC) -O3 src/erlcmd.o src/s7_partner.o src/util.o -L$(SRC_PATH) -I$(SRC_PATH) -lsnap $(ERL_LDFLAGS) $(LDFLAGS) -o priv/s7_partner
 
 snap7:
 	make -C $(SNAP7_PATH)$(OS_PATH) -f $(TARGET).mk install LibInstall=../../../libsnap.so

priv/s7_client

@@ -1,5 +1,5 @@
 /*
- *  Copyright 2014 Frank Hunleth
+ *  Copyright 2016 Frank Hunleth
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,12 +17,104 @@
  */
 
 #include "erlcmd.h"
+#include "util.h"
 
-#include <err.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
+#ifdef __WIN32__
+// Assume that all windows platforms are little endian
+#define TO_BIGENDIAN16(X) _byteswap_ushort(X)
+#define FROM_BIGENDIAN16(X) _byteswap_ushort(X)
+#else
+// Other platforms have htons and ntohs without pulling in another library
+#define TO_BIGENDIAN16(X) htons(X)
+#define FROM_BIGENDIAN16(X) ntohs(X)
+#endif
+
+#ifdef __WIN32__
+/*
+ * stdin on Windows
+ *
+ * Caveat: I'm convinced that I don't understand stdin on Windows, so take
+ * with a grain of salt.
+ *
+ * Here's what I know:
+ *
+ *   1. When running from a command prompt, stdin is a console. Windows
+ *      consoles collect lines at a time. See SetConsoleMode.
+ *   2. The console is opened for synchronous use. I.e., overlapped I/O
+ *      doesn't work.
+ *   3. Opening stdin using CONIN$ works for console use, but not
+ *      redirected use. (Seems obvious, but lots of search hits on
+ *      Google do this, so it seemed worthwhile to try.)
+ *   5. When stdin is redirected to another program, it behaves like
+ *      a pipe. It may really be a pipe, but the docs that I've read
+ *      don't call it one.
+ *   6. The pipe is opened for synchronous use.
+ *   7. Calling ReOpenFile to change it to support overlapped I/O
+ *      didn't work.
+ *   8. Despite pipes not being listed as things you can wait on with
+ *      WaitForMultipleObjects, it seems to work. Hopefully just a
+ *      documentation omission...
+ *
+ * Since there seems to be no way of making stdin be overlapped I/O
+ * capable, I created a thread and a new pipe. The thread synchronously
+ * reads from stdin and writes to the new pipe. The read end of the new
+ * pipe supports overlapped I/O so I can use it in the main WFMO loop.
+ *
+ * If performance gets to be an issue, the pipe could be replaced with
+ * a shared memory/event notification setup. Until this, the pipe version
+ * is pretty simple albeit with a lot of data copies and process switches.
+ */
+
+static DWORD WINAPI pipe_copy_thread(LPVOID lpParam)
+{
+    struct erlcmd *handler = (struct erlcmd *) lpParam;
+
+    // NEED to get overlapped version of stdin reader
+    HANDLE real_stdin = GetStdHandle(STD_INPUT_HANDLE);
+
+    // Turn off ENABLE_LINE_INPUT (and everything else)
+    // This has to be done on the STD_INPUT_HANDLE rather than
+    // the one we use for events. Don't know why.
+    SetConsoleMode(real_stdin, 0);
+
+    while (handler->running) {
+        char buffer[1024];
+        DWORD bytes_read;
+        if (!ReadFile(real_stdin, buffer, sizeof(buffer), &bytes_read, NULL)) {
+            debug("ReadFile on real_stdin failed (port closed)! %d", (int) GetLastError());
+            break;
+        }
+
+        if (!WriteFile(handler->stdin_write_pipe, buffer, bytes_read, NULL, NULL)) {
+            debug("WriteFile on stdin_write_pipe failed! %d", (int) GetLastError());
+            break;
+        }
+    }
+
+    handler->running = FALSE;
+    CloseHandle(handler->stdin_write_pipe);
+    handler->stdin_write_pipe = NULL;
+
+    ExitThread(0);
+    return 0;
+}
+
+static void start_async_read(struct erlcmd *handler)
+{
+    ReadFile(handler->h,
+               handler->buffer + handler->index,
+               sizeof(handler->buffer) - handler->index,
+               NULL,
+               &handler->overlapped);
+}
+
+#endif
+
 /**
  * Initialize an Erlang command handler.
  *
@@ -31,13 +123,68 @@
  * @param cookie optional data to pass back to the handler
  */
 void erlcmd_init(struct erlcmd *handler,
-		 void (*request_handler)(const char *req, void *cookie),
-		 void *cookie)
+                 void (*request_handler)(const char *req, void *cookie),
+                 void *cookie)
 {
     memset(handler, 0, sizeof(*handler));
 
     handler->request_handler = request_handler;
     handler->cookie = cookie;
+
+#ifdef __WIN32__
+    handler->running = TRUE;
+
+    char pipe_name[64];
+    sprintf(pipe_name,
+             "\\\\.\\Pipe\\nerves-uart.%08x",
+             (unsigned int) GetCurrentProcessId());
+
+    handler->stdin_read_pipe = CreateNamedPipeA(
+                         pipe_name,
+                         PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED,
+                         PIPE_TYPE_BYTE | PIPE_WAIT,
+                         1,             // Number of pipes
+                         4096,          // Out buffer size
+                         4096,          // In buffer size
+                         120 * 1000,    // Timeout in ms
+                         NULL
+                         );
+    if (!handler->stdin_read_pipe)
+        errx(EXIT_FAILURE, "Can't create overlapped i/o stdin pipe");
+
+    handler->stdin_write_pipe = CreateFileA(
+                        pipe_name,
+                        GENERIC_WRITE,
+                        0,                         // No sharing
+                        NULL,
+                        OPEN_EXISTING,
+                        FILE_ATTRIBUTE_NORMAL,
+                        NULL                       // Template file
+                      );
+    if (!handler->stdin_write_pipe)
+        errx(EXIT_FAILURE, "Can't create write side of stdin pipe");
+
+    handler->stdin_reader_thread = CreateThread(
+               NULL,                   // default security attributes
+               0,                      // use default stack size
+               pipe_copy_thread,       // thread function name
+               handler,          // argument to thread function
+               0,                      // use default creation flags
+               NULL);
+    if (handler->stdin_reader_thread == NULL) {
+        errx(EXIT_FAILURE, "CreateThread failed: %d", (int) GetLastError());
+        return;
+    }
+    handler->h = handler->stdin_read_pipe;
+    if (handler->h == INVALID_HANDLE_VALUE)
+        errx(EXIT_FAILURE, "Can't open stdin %d", (int) GetLastError());
+
+    handler->overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+    handler->overlapped.Offset = 0;
+    handler->overlapped.OffsetHigh = 0;
+
+    start_async_read(handler);
+#endif
 }
 
 /**
@@ -47,21 +194,26 @@ void erlcmd_init(struct erlcmd *handler,
  */
 void erlcmd_send(char *response, size_t len)
 {
-    uint16_t be_len = htons(len - sizeof(uint16_t));
+    uint16_t be_len = TO_BIGENDIAN16(len - sizeof(uint16_t));
     memcpy(response, &be_len, sizeof(be_len));
 
+#ifdef __WIN32__
+    BOOL rc = WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), response, len, NULL, NULL);
+    if (!rc)
+        errx(EXIT_FAILURE, "WriteFile to stdout failed (Erlang exit?)");
+#else
     size_t wrote = 0;
-    do {
+    do {        
         ssize_t amount_written = write(STDOUT_FILENO, response + wrote, len - wrote);
         if (amount_written < 0) {
             if (errno == EINTR)
-	              continue;
-
-	    err(EXIT_FAILURE, "write");
-	}
+                continue;
 
-	wrote += amount_written;
+            err(EXIT_FAILURE, "write");
+        }
+        wrote += amount_written;
     } while (wrote < len);
+#endif
 }
 
 /**
@@ -72,55 +224,94 @@ static size_t erlcmd_try_dispatch(struct erlcmd *handler)
 {
     /* Check for length field */
     if (handler->index < sizeof(uint16_t))
-	return 0;
+        return 0;
 
     uint16_t be_len;
     memcpy(&be_len, handler->buffer, sizeof(uint16_t));
-    size_t msglen = ntohs(be_len);
+    size_t msglen = FROM_BIGENDIAN16(be_len);
     if (msglen + sizeof(uint16_t) > sizeof(handler->buffer))
-	errx(EXIT_FAILURE, "Message too long");
+        errx(EXIT_FAILURE, "Message too long: %d bytes. Max is %d bytes",
+             (int) (msglen + sizeof(uint16_t)), (int) sizeof(handler->buffer));
 
     /* Check whether we've received the entire message */
     if (msglen + sizeof(uint16_t) > handler->index)
-	return 0;
+        return 0;
 
     handler->request_handler(handler->buffer, handler->cookie);
 
     return msglen + sizeof(uint16_t);
 }
 
 /**
- * @brief call to process any new requests from Erlang
+ * @brief Call to process any new requests from Erlang
+ *
+ * @return 1 if the program should exit gracefully
  */
-void erlcmd_process(struct erlcmd *handler) {
-	ssize_t amount_read = read(STDIN_FILENO, handler->buffer + handler->index, sizeof(handler->buffer) - handler->index);
-	if (amount_read < 0) {
-		/* EINTR is ok to get, since we were interrupted by a signal. */
-		if (errno == EINTR)
-		    return;
-
-		/* Everything else is unexpected. */
-		err(EXIT_FAILURE, "read");
-  } else if (amount_read == 0) {
-	/* EOF. Erlang process was terminated. This happens after a release or if there was an error. */
-	exit(EXIT_SUCCESS);
+int erlcmd_process(struct erlcmd *handler)
+{
+#ifdef __WIN32__
+    DWORD amount_read;
+    BOOL rc = GetOverlappedResult(handler->h,
+                                  &handler->overlapped,
+                                  &amount_read, FALSE);
+
+    if (!rc) {
+        DWORD last_error = GetLastError();
+
+        // Check if this was a spurious event.
+        if (last_error == ERROR_IO_PENDING)
+            return 0;
+
+        // Error - most likely the Erlang port connected to us was closed.
+        // Tell the caller to exit gracefully.
+        return 1;
     }
 
+    ResetEvent(handler->overlapped.hEvent);
+#else
+    ssize_t amount_read = read(STDIN_FILENO, handler->buffer + handler->index, sizeof(handler->buffer) - handler->index);
+    if (amount_read < 0) {
+        /* EINTR is ok to get, since we were interrupted by a signal. */
+        if (errno == EINTR)
+            return 0;
+
+        /* Everything else is unexpected. */
+        err(EXIT_FAILURE, "read");
+    } else if (amount_read == 0) {
+        /* EOF. Erlang process was terminated. This happens after a release or if there was an error. */
+        return 1;
+    }
+#endif
     handler->index += amount_read;
+
     for (;;) {
-	size_t bytes_processed = erlcmd_try_dispatch(handler);
-
-	if (bytes_processed == 0) {
-	    /* Only have part of the command to process. */
-	    break;
-	} else if (handler->index > bytes_processed) {
-	    /* Processed the command and there's more data. */
-	    memmove(handler->buffer, &handler->buffer[bytes_processed], handler->index - bytes_processed);
-	    handler->index -= bytes_processed;
-	} else {
-	    /* Processed the whole buffer. */
-	    handler->index = 0;
-	    break;
-	}
+        size_t bytes_processed = erlcmd_try_dispatch(handler);
+
+        if (bytes_processed == 0) {
+            /* Only have part of the command to process. */
+            break;
+        } else if (handler->index > bytes_processed) {
+            /* Processed the command and there's more data. */
+            memmove(handler->buffer, &handler->buffer[bytes_processed], handler->index - bytes_processed);
+            handler->index -= bytes_processed;
+        } else {
+            /* Processed the whole buffer. */
+            handler->index = 0;
+            break;
+        }
     }
+
+#ifdef __WIN32__
+    start_async_read(handler);
+#endif
+
+    return 0;
 }
+
+#ifdef __WIN32__
+HANDLE erlcmd_wfmo_event(struct erlcmd *handler)
+{
+    return handler->overlapped.hEvent;
+}
+
+#endif