]> git.zerfleddert.de Git - hmcfgusb/blobdiff - hmland.c
hotplug-dir needs to be created before copying stuff into it...
[hmcfgusb] / hmland.c
index 3366c8b5dae00023fb13ee2f60766a923ef9b55c..608c88750be81f96683eb1a8d78b73f10b6d25db 100644 (file)
--- a/hmland.c
+++ b/hmland.c
@@ -1,4 +1,4 @@
-/* HM-CFG-LAN emuldation for HM-CFG-USB
+/* HM-CFG-LAN emulation for HM-CFG-USB
  *
  * Copyright (c) 2013 Michael Gernoth <michael@gernoth.net>
  *
 #include <strings.h>
 #include <poll.h>
 #include <errno.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
 #include <libusb-1.0/libusb.h>
 
 #include "hexdump.h"
 #include "hmcfgusb.h"
 
-void hmlan_format_out(uint8_t *buf, int buf_len, void *data)
+extern char *optarg;
+
+static int impersonate_hmlanif = 0;
+static int debug = 0;
+static int verbose = 0;
+
+#define        FLAG_LENGTH_BYTE        (1<<0)
+#define        FLAG_FORMAT_HEX         (1<<1)
+#define        FLAG_COMMA_BEFORE       (1<<2)
+#define        FLAG_COMMA_AFTER        (1<<3)
+#define        FLAG_NL                 (1<<4)
+#define        FLAG_IGNORE_COMMAS      (1<<5)
+
+#define CHECK_SPACE(x)         if ((*outpos + x) > outend) { fprintf(stderr, "Not enough space!\n"); return 0; }
+#define CHECK_AVAIL(x)         if ((*inpos + x) > inend) { fprintf(stderr, "Not enough input available!\n"); return 0; }
+
+static int format_part_out(uint8_t **inpos, int inlen, uint8_t **outpos, int outlen, int len, int flags)
 {
-       int len;
+       const uint8_t nibble[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+               'A', 'B', 'C', 'D', 'E', 'F'};
+       uint8_t *buf_out = *outpos;
+       uint8_t *outend = *outpos + outlen;
+       uint8_t *inend = *inpos + inlen;
        int i;
 
+       if (flags & FLAG_COMMA_BEFORE) {
+               CHECK_SPACE(1);
+               **outpos=',';
+               *outpos += 1;
+       }
+
+       if (flags & FLAG_LENGTH_BYTE) {
+               CHECK_AVAIL(1);
+               len = **inpos;
+               *inpos += 1;
+       }
+
+       if (flags & FLAG_FORMAT_HEX) {
+               CHECK_AVAIL(len);
+               CHECK_SPACE(len*2);
+               for (i = 0; i < len; i++) {
+                       **outpos = nibble[((**inpos) & 0xf0) >> 4];
+                       *outpos += 1;
+                       **outpos = nibble[((**inpos) & 0xf)];
+                       *inpos += 1; *outpos += 1;
+               }
+       } else {
+               CHECK_AVAIL(len);
+               CHECK_SPACE(len);
+               memcpy(*outpos, *inpos, len);
+               *outpos += len;
+               *inpos += len;
+       }
+
+       if (flags & FLAG_COMMA_AFTER) {
+               CHECK_SPACE(1);
+               **outpos=',';
+               *outpos += 1;
+       }
+
+       if (flags & FLAG_NL) {
+               CHECK_SPACE(2);
+               **outpos='\r';
+               *outpos += 1;
+               **outpos='\n';
+               *outpos += 1;
+       }
+
+       return *outpos - buf_out;
+}
+
+static uint8_t ascii_to_nibble(uint8_t a)
+{
+       uint8_t c = 0x00;
+
+       if ((a >= '0') && (a <= '9')) {
+               c = a - '0';
+       } else if ((a >= 'A') && (a <= 'F')) {
+               c = (a - 'A') + 10;
+       } else if ((a >= 'a') && (a <= 'f')) {
+               c = (a - 'a') + 10;
+       }
+
+       return c;
+}
+
+static int parse_part_in(uint8_t **inpos, int inlen, uint8_t **outpos, int outlen, int flags)
+{
+       uint8_t *buf_out = *outpos;
+       uint8_t *outend = *outpos + outlen;
+       uint8_t *inend = *inpos + inlen;
+
+       if (flags & FLAG_LENGTH_BYTE) {
+               int len = 0;
+               uint8_t *ip;
+
+               ip = *inpos;
+               while(ip < inend) {
+                       if (*ip == ',') {
+                               ip++;
+                               if (!(flags & FLAG_IGNORE_COMMAS))
+                                       break;
+
+                               continue;
+                       }
+                       len++;
+                       ip++;
+               }
+               CHECK_SPACE(1);
+               **outpos = (len / 2);
+               *outpos += 1;
+       }
+
+       while(*inpos < inend) {
+               if (**inpos == ',') {
+                       *inpos += 1;
+                       if (!(flags & FLAG_IGNORE_COMMAS))
+                               break;
+
+                       continue;
+               }
+
+               CHECK_SPACE(1);
+               CHECK_AVAIL(2);
+
+               **outpos = ascii_to_nibble(**inpos) << 4;
+               *inpos += 1;
+               **outpos |= ascii_to_nibble(**inpos);
+               *inpos += 1; *outpos += 1;
+       }
+
+       return *outpos - buf_out;
+}
+
+static void hmlan_format_out(uint8_t *buf, int buf_len, void *data)
+{
+       uint8_t out[1024];
+       uint8_t *outpos;
+       uint8_t *inpos;
+       int fd = *((int*)data);
+
        if (buf_len < 1)
                return;
 
-       //FIXME: Buffer here and write to fd_out
-       printf("%c", buf[0]);
+       memset(out, 0, sizeof(out));
+       outpos = out;
+       inpos = buf;
+
+       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 1, 0);
        switch(buf[0]) {
                case 'H':
-                       buf[5]='L';
-                       buf[6]='A';
-                       buf[7]='N';
-                       len = buf[1];
-                       for (i = 2; i < len + 2; i++) {
-                               printf("%c", buf[i]);
-                       }
-                       printf(",%02X%02X,", buf[i],
-                                       buf[i+1]);
-                       i+=2;
-                       len = buf[i]+i+1;
-                       i++;
-                       for (; i < len; i++) {
-                               printf("%c", buf[i]);
-                       }
-                       printf(",");
-                       len = i+12;
-                       for (; i < len; i++) {
-                               printf("%02X", buf[i]);
-                               switch(len-i) {
-                                       case 10:
-                                       case 7:
-                                       case 3:
-                                               printf(",");
-                                               break;
-                                       default:
-                                               break;
-                               }
+                       if (impersonate_hmlanif) {
+                               buf[5] = 'L';
+                               buf[6] = 'A';
+                               buf[7] = 'N';
                        }
+                       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 0, FLAG_LENGTH_BYTE);
+                       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 2, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
+                       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 0, FLAG_COMMA_BEFORE | FLAG_LENGTH_BYTE);
+                       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 3, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
+                       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 3, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
+                       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 4, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
+                       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 2, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE | FLAG_NL);
 
                        break;
                case 'E':
-                       len = 13 + buf[13];
-                       for (i = 0; i < len; i++) {
-                               if (i != 12)
-                                       printf("%02X", buf[1+i]);
-                               switch(i) {
-                                       case 2:
-                                       case 4:
-                                       case 8:
-                                       case 9:
-                                       case 11:
-                                               printf(",");
-                                               break;
-                                       default:
-                                               break;
-                               }
-                       }
+                       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 3, FLAG_FORMAT_HEX);
+                       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 2, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
+                       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 4, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
+                       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 1, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
+                       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 2, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
+                       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 0, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE | FLAG_LENGTH_BYTE | FLAG_NL);
+
                        break;
                case 'R':
-                       len = 14 + buf[14];
-                       for (i = 0; i < len; i++) {
-                               if (i != 13)
-                                       printf("%02X", buf[1+i]);
-                               switch(i) {
-                                       case 3:
-                                       case 5:
-                                       case 9:
-                                       case 10:
-                                       case 12:
-                                               printf(",");
-                                               break;
-                                       default:
-                                               break;
-                               }
-                       }
+                       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 4, FLAG_FORMAT_HEX);
+                       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 2, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
+                       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 4, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
+                       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 1, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
+                       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 2, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
+                       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 0, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE | FLAG_LENGTH_BYTE | FLAG_NL);
+
                        break;
                case 'I':
-                       //HM> 0x0000: 49 00 00 00 00 55 53 42 2d 49 46 03 bc 0a 4a 45   I....USB-IF...JE
-                       //HM> 0x0010: 51 30 35 33 35 31 32 32 1d b1 55 68 ea 13 00 14   Q0535122..Uh....
-                       //HM> 0x0020: 9f a6 00 03 00 00 00 00 00 00 00 00 00 00 00 00   ................
-                       //HM> 0x0030: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00   ................ 
+                       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 1, FLAG_FORMAT_HEX);
+                       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 1, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
+                       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 1, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE);
+                       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), 1, FLAG_FORMAT_HEX | FLAG_COMMA_BEFORE | FLAG_NL);
+
+                       break;
                default:
-                       for (i = 1; i < buf_len; i++)
-                               printf("%02X", buf[i]);
+                       format_part_out(&inpos, (buf_len-(inpos-buf)), &outpos, (sizeof(out)-(outpos-out)), buf_len-1, FLAG_FORMAT_HEX | FLAG_NL);
                        hexdump(buf, buf_len, "Unknown> ");
                        break;
        }
-       printf("\n");
+       write(fd, out, outpos-out);
+       if (debug)
+               fprintf(stderr, "LAN < %s\n", out);
 }
 
-void hmlan_parse_in(int fd, void *data)
+static int hmlan_parse_in(int fd, void *data)
 {
        struct hmcfgusb_dev *dev = data;
-       unsigned char buf[1024];
-       unsigned char send_buf[0x40]; //FIXME!!!
-       char tmp[3];
+       uint8_t buf[1025];
+       uint8_t out[0x40]; //FIXME!!!
+       uint8_t *outpos;
+       uint8_t *inpos;
        int i;
+       int last;
        int r;
 
-       r = read(fd, buf, sizeof(buf));
+       memset(buf, 0, sizeof(buf));
+
+       r = read(fd, buf, sizeof(buf)-1);
        if (r > 0) {
-               int cnt;
+               uint8_t *inend = buf + r;
 
-               memset(send_buf, 0, sizeof(send_buf));
-               for (i = 0; i < r; i++) {
-                       if ((buf[i] == 0x0a) ||
-                                       (buf[i] == 0x0d)) {
-                               r = i;
-                               break;
+               inpos = buf;
+
+               if (debug)
+                       fprintf(stderr, "\nLAN > %s", buf);
+
+               while (inpos < inend) {
+                       uint8_t *instart = inpos;
+
+                       if ((*inpos == '\r') || (*inpos == '\n')) {
+                               inpos++;
+                               continue;
                        }
-               }
+                       
+                       outpos = out;
 
-               send_buf[0] = buf[0];
-
-               cnt = 0;
-               for (i = 1; i < r; i++) {
-                       if (buf[i] == ',') {
-                               switch (buf[0]) {
-                                       case 'S':
-                                               if (cnt == 4) {
-                                                       /* Add msg length */
-                                                       memmove(buf+i+2, buf+i+1, r-(i+1));
-                                                       snprintf(tmp, 3, "%02X", (int)((r-(i+1))/2));
-                                                       memcpy(buf+i, tmp, 2);
-                                                       r++;
-                                                       break;
-                                               }
-                                       default:
-                                               memmove(buf+i, buf+i+1, r-(i+1));
-                                               r--;
-                                               break;
+                       last = inend - inpos;
+
+                       for (i = 0; i < last; i++) {
+                               if ((inpos[i] == '\r') || (inpos[i] == '\n')) {
+                                       last = i;
+                                       break;
                                }
-                               cnt++;
                        }
-               }
 
-               memset(tmp, 0, sizeof(tmp));
-               for (i = 1; i < r; i+=2) {
-                       memcpy(tmp, buf + i, 2);
-                       send_buf[1+(i/2)] = strtoul(tmp, NULL, 16);
+                       if (last == 0)
+                               continue;
+
+                       memset(out, 0, sizeof(out));
+                       *outpos++ = *inpos++;
+
+                       switch(buf[0]) {
+                               case 'S':
+                                       parse_part_in(&inpos, (last-(inpos-instart)), &outpos, (sizeof(out)-(outpos-out)), 0);
+                                       parse_part_in(&inpos, (last-(inpos-instart)), &outpos, (sizeof(out)-(outpos-out)), 0);
+                                       parse_part_in(&inpos, (last-(inpos-instart)), &outpos, (sizeof(out)-(outpos-out)), 0);
+                                       parse_part_in(&inpos, (last-(inpos-instart)), &outpos, (sizeof(out)-(outpos-out)), 0);
+                                       parse_part_in(&inpos, (last-(inpos-instart)), &outpos, (sizeof(out)-(outpos-out)), 0);
+                                       parse_part_in(&inpos, (last-(inpos-instart)), &outpos, (sizeof(out)-(outpos-out)), FLAG_LENGTH_BYTE);
+                                       break;
+                               default:
+                                       parse_part_in(&inpos, (last-(inpos-instart)), &outpos, (sizeof(out)-(outpos-out)), FLAG_IGNORE_COMMAS);
+                                       break;
+                       }
+
+                       hmcfgusb_send(dev, out, sizeof(out), 1);
                }
-               hmcfgusb_send(dev, send_buf, 1+(i/2), 1);
        } else if (r < 0) {
                perror("read");
+               return r;
+       } else {
+               return 0;
        }
+
+       return 1;
 }
 
-int main(int argc, char **argv)
+static int comm(int fd_in, int fd_out, int master_socket)
 {
        struct hmcfgusb_dev *dev;
        int quit = 0;
 
-       dev = hmcfgusb_init(hmlan_format_out, NULL);
+       hmcfgusb_set_debug(debug);
+
+       dev = hmcfgusb_init(hmlan_format_out, &fd_out);
        if (!dev) {
                fprintf(stderr, "Can't initialize HM-CFG-USB!\n");
-               exit(EXIT_FAILURE);
+               return 0;
+       }
+
+       if (!hmcfgusb_add_pfd(dev, fd_in, POLLIN)) {
+               fprintf(stderr, "Can't add client to pollfd!\n");
+               hmcfgusb_close(dev);
+               return 0;
        }
 
-       if (!hmcfgusb_add_pfd(dev, STDIN_FILENO, POLLIN)) {
-               fprintf(stderr, "Can't add stdin to pollfd!\n");
-               exit(EXIT_FAILURE);
+       if (master_socket >= 0) {
+               if (!hmcfgusb_add_pfd(dev, master_socket, POLLIN)) {
+                       fprintf(stderr, "Can't add master_socket to pollfd!\n");
+                       hmcfgusb_close(dev);
+                       return 0;
+               }
        }
 
        hmcfgusb_send(dev, (unsigned char*)"K", 1, 1);
@@ -207,7 +345,19 @@ int main(int argc, char **argv)
 
                fd = hmcfgusb_poll(dev, 3600);
                if (fd >= 0) {
-                       hmlan_parse_in(fd, dev);
+                       if (fd == master_socket) {
+                               int client;
+
+                               client = accept(master_socket, NULL, 0);
+                               if (client >= 0) {
+                                       shutdown(client, SHUT_RDWR);
+                                       close(client);
+                               }
+                       } else {
+                               if (hmlan_parse_in(fd, dev) <= 0) {
+                                       quit = 1;
+                               }
+                       }
                } else if (fd == -1) {
                        if (errno) {
                                perror("hmcfgusb_poll");
@@ -217,6 +367,163 @@ int main(int argc, char **argv)
        }
 
        hmcfgusb_close(dev);
+       return 1;
+}
+
+static int socket_server(int port, int daemon)
+{
+       struct sockaddr_in sin;
+       int sock;
+       int n;
+       pid_t pid;
+
+       if (daemon) {
+               pid = fork();
+               if (pid > 0) {
+                       printf("Daemon with PID %u started!\n", pid);
+                       exit(EXIT_SUCCESS);
+               } else if (pid < 0) {
+                       perror("fork");
+                       exit(EXIT_FAILURE);
+               }
+       }
+
+       impersonate_hmlanif = 1;
+
+       sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
+       if (sock == -1) {
+               perror("Can't open socket");
+               return EXIT_FAILURE;
+       }
+
+       n = 1;
+       if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &n, sizeof(n)) == -1) {
+               perror("Can't set socket options");
+               return EXIT_FAILURE;
+       }
+
+       memset(&sin, 0, sizeof(sin));
+       sin.sin_family = AF_INET;
+       sin.sin_port = htons(port);
+       sin.sin_addr.s_addr = htonl(INADDR_ANY);
+
+       if (bind(sock, (struct sockaddr*)&sin, sizeof(sin)) == -1) {
+               perror("Can't bind socket");
+               return EXIT_FAILURE;
+       }
+
+       if (listen(sock, 1) == -1) {
+               perror("Can't listen on socket");
+               return EXIT_FAILURE;
+       }
+
+       while(1) {
+               struct sockaddr_in csin;
+               socklen_t csinlen;
+               int client;
+               in_addr_t client_addr;
+
+               memset(&csin, 0, sizeof(csin));
+               csinlen = sizeof(csin);
+               client = accept(sock, (struct sockaddr*)&csin, &csinlen);
+               if (client == -1) {
+                       perror("Couldn't accept client");
+                       continue;
+               }
+
+               /* FIXME: getnameinfo... */
+               client_addr = ntohl(csin.sin_addr.s_addr);
+
+               if (verbose) {
+                       printf("Client %d.%d.%d.%d connected!\n",
+                                       (client_addr & 0xff000000) >> 24,
+                                       (client_addr & 0x00ff0000) >> 16,
+                                       (client_addr & 0x0000ff00) >> 8,
+                                       (client_addr & 0x000000ff));
+               }
+
+               comm(client, client, sock);
+
+               shutdown(client, SHUT_RDWR);
+               close(client);
+
+               if (verbose) {
+                       printf("Connection to %d.%d.%d.%d closed!\n",
+                                       (client_addr & 0xff000000) >> 24,
+                                       (client_addr & 0x00ff0000) >> 16,
+                                       (client_addr & 0x0000ff00) >> 8,
+                                       (client_addr & 0x000000ff));
+               }
+
+       }
 
        return EXIT_SUCCESS;
 }
+
+static int interactive_server(void)
+{
+       if (!comm(STDIN_FILENO, STDOUT_FILENO, -1))
+               return EXIT_FAILURE;
+
+       return EXIT_SUCCESS;
+}
+
+void hmlan_syntax(char *prog)
+{
+       fprintf(stderr, "Syntax: %s options\n\n", prog);
+       fprintf(stderr, "Possible options:\n");
+       fprintf(stderr, "\t-D\tdebug mode\n");
+       fprintf(stderr, "\t-d\tdaemon mode\n");
+       fprintf(stderr, "\t-h\tthis help\n");
+       fprintf(stderr, "\t-i\tinteractive mode (connect HM-CFG-USB to terminal)\n");
+       fprintf(stderr, "\t-p n\tlisten on port n (default 1000)\n");
+       fprintf(stderr, "\t-v\tverbose mode\n");
+
+}
+
+int main(int argc, char **argv)
+{
+       int port = 1000;
+       int interactive = 0;
+       int daemon = 0;
+       char *ep;
+       int opt;
+
+       while((opt = getopt(argc, argv, "Ddhip:v")) != -1) {
+               switch (opt) {
+                       case 'D':
+                               debug = 1;
+                               verbose = 1;
+                               break;
+                       case 'd':
+                               daemon = 1;
+                               break;
+                       case 'i':
+                               interactive = 1;
+                               break;
+                       case 'p':
+                               port = strtoul(optarg, &ep, 10);
+                               if (*ep != '\0') {
+                                       fprintf(stderr, "Can't parse port!\n");
+                                       exit(EXIT_FAILURE);
+                               }
+                               break;
+                       case 'v':
+                               verbose = 1;
+                               break;
+                       case 'h':
+                       case ':':
+                       case '?':
+                       default:
+                               hmlan_syntax(argv[0]);
+                               exit(EXIT_FAILURE);
+                               break;
+               }
+       }
+       
+       if (interactive) {
+               return interactive_server();
+       } else {
+               return socket_server(port, daemon);
+       }
+}
Impressum, Datenschutz