First commit

Author: Élie Bouttier

CMakeLists.txt

@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 2.6.0)
+
+add_executable(usbdaemon usbdaemon.c settings.c ini.c devicemanager.c device.c
+    getttyfd.c getsockfd.c notice.c)
+
+target_link_libraries(usbdaemon checktype)
+
+install(TARGETS usbdaemon RUNTIME DESTINATION bin)

device.c

@@ -0,0 +1,169 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "device.h"
+#include "settings.h"
+#include "notice.h"
+
+int getttyfd(const char *device, int speed);
+int getsockfd(const char *host, const char *port);
+int checktype(int type);
+
+char format[256];
+
+int device_new(struct device **device, const char *path)
+{
+    struct device *dev = *device;
+    if ((dev = malloc(sizeof(struct device))) == NULL) {
+        perror("malloc");
+        return -1;
+    }
+    if ((dev->fd = getttyfd(path, speed)) < 0) {
+        free(dev);
+        return -1;
+    }
+    dev->fbufsize = 0;
+    
+    dev->sock = -1;
+    sprintf(dev->sbuf, "%c%c%c", 129, 254, 128);
+    dev->sbufsize = 3;
+
+    dev->state = BEGIN;
+
+    if ((dev->path = malloc(strlen(path) + 1)) == NULL) {
+        perror("malloc");
+        close(dev->fd);
+        free(dev);
+        return -1;
+    }
+    strcpy(dev->path, path);
+
+    *device = dev;
+    return 0;
+}
+
+int device_connect(struct device *dev)
+{
+    int i, port;
+    char service[128];
+   
+    for (i = 0 ; i < dev->fbufsize ; i++) {
+        if (dev->state == WAITING_CONNECTION) {
+            break;
+        }
+        switch (dev->state) {
+            case BEGIN:
+                if (dev->fbuf[i] == 129) {
+                    dev->state = PACKET_ID;
+                }
+                break;
+            case PACKET_ID:
+                if (dev->fbuf[i] == 255) {
+                    dev->state = VAR_B;
+                } else {
+                    dev->state = TYPE;
+                }
+                break;
+            case TYPE:
+                if (dev->fbuf[i] == 128) {
+                    dev->state = BEGIN;
+                } else if (checktype(dev->fbuf[i])) {
+                    dev->state = -(dev->fbuf[i] & 0xF);
+                } else {
+                    dev->state = BEGIN;
+                }
+                break;
+            case VAR_B:
+                if (dev->fbuf[i] == 0x1) {
+                    dev->state = DEV_ID;
+                } else {
+                    dev->state = BEGIN;
+                }
+                break;
+            case DEV_ID:
+                dev->sock = dev->fbuf[i];
+                dev->state = END;
+                break;
+            case END:
+                if (dev->fbuf[i] == 128) {
+                    dev->state = WAITING_CONNECTION;
+                } else if (checktype(dev->fbuf[i])) {
+                    dev->state = -(dev->fbuf[i] & 0xF);
+                } else {
+                    dev->state = BEGIN;
+                }
+                break;
+            default:
+                dev->state += 1;
+        }
+    }
+
+    memmove(dev->fbuf, dev->fbuf + i, (dev->fbufsize - i) * sizeof(*(dev->fbuf)));
+    dev->fbufsize -= i;
+
+    if (dev->state != WAITING_CONNECTION)
+        return 0;
+
+    if (!(port = getportbyid(dev->sock))) {
+        fprintf(stderr, "getportbyid: no port associated with this id (%d)\n", dev->sock);
+        //notice_id(IDFAIL, dev->path, dev->sock);
+        return -1;
+    }
+
+    sprintf(service, "%d", port);
+    
+    if ((dev->sock = getsockfd(host, service)) < 0) {
+        notice_sock(SOCKFAIL, dev->path, host, service);
+        return -1;
+    }
+
+    dev->state = CONNECTED;
+    notice_sock(CONNECT, dev->path, host, service);
+
+    return 0;
+}
+
+
+int device_read(int fd, unsigned char *buffer, int *bufsize)
+{
+    int readed;
+    
+    if ((readed = read(fd, buffer + *bufsize, BUF_SIZE - *bufsize)) <= 0) {
+        return -1;
+    }
+    *bufsize += readed;
+
+    return 0;
+}
+
+int device_write(int fd, unsigned char *buffer, int *bufsize)
+{
+    int written;
+    
+    if ((written = write(fd, buffer, *bufsize)) <= 0) {
+        return -1;
+    }
+
+    memmove(buffer, buffer + written, (*bufsize - written) * sizeof(*buffer));
+    *bufsize -= written;
+
+    return 0;
+}
+
+void device_delete(struct device **device)
+{
+    struct device *dev = *device;
+   
+    // Fermeture des fd
+    close(dev->fd);
+    if (dev->state == CONNECTED) {
+        close(dev->sock);
+    }
+
+    // Libération des ressources alloué dans device_new
+    free(dev->path);
+    free(dev);
+
+    *device = NULL;
+}

device.h

@@ -0,0 +1,35 @@
+#ifndef _DEVICE_H_
+#define _DEVICE_H_
+
+#define BUF_SIZE 1024
+
+enum state {
+    TYPE = 0,
+    BEGIN = 1,
+    PACKET_ID = 3,
+    VAR_TYPE = 4,
+    VAR_B = 5,
+    DEV_ID = 6,
+    END = 7,
+    WAITING_CONNECTION = 8,
+    CONNECTED = 9,
+};
+
+struct device {
+    int fd;
+    unsigned char fbuf[BUF_SIZE];
+    int fbufsize;
+    int sock;
+    unsigned char sbuf[BUF_SIZE];
+    int sbufsize;
+    enum state state;
+    char *path;
+};
+
+int device_new(struct device **device, const char *path);
+int device_connect(struct device *dev);
+int device_read(int fd, unsigned char *buffer, int *bufsize);
+int device_write(int fd, unsigned char *buffer, int *bufsize);
+void device_delete(struct device **device);
+
+#endif // _DEVICE_H_

devicemanager.c

@@ -0,0 +1,219 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/time.h>
+
+#include "devicemanager.h"
+#include "device.h"
+#include "notice.h"
+
+#define MAX_DEVICES 32
+#define TIMER       500000
+
+static int *delay;
+static char **path;
+static int pathc = 0;
+static int paths = 0;
+static int next = -1;
+
+static struct device *devices[MAX_DEVICES];
+static int devc = 0;
+
+static void install_handler();
+static void set_timer(int delay);
+static void handler(int signal);
+
+static void set_timer(int delay)
+{
+    struct itimerval timer;
+    next = delay;
+    timer.it_value.tv_sec = next / 1000000;
+    timer.it_value.tv_usec = next % 1000000;
+    timer.it_interval.tv_sec = 0;
+    timer.it_interval.tv_usec = 0;
+    if (setitimer(ITIMER_REAL, &timer, NULL) < 0) {
+        perror("setitimer");
+        exit(EXIT_FAILURE); // FIXME
+    }
+}
+
+static void install_handler()
+{
+    struct sigaction sa;
+    memset(&sa, 0, sizeof(sa));
+    sa.sa_handler = &handler;
+    sigemptyset(&sa.sa_mask);
+    sa.sa_flags = SA_RESTART;
+    if (sigaction(SIGALRM, &sa, NULL) < 0) {
+        perror("sigaction");
+        exit(EXIT_FAILURE); // FIXME
+    }
+}
+
+static void handler(int signal)
+{
+    int i, t;
+    int min = TIMER;
+
+    for (i = 0 ; i < pathc ; i++) {
+        delay[i] -= next;
+        if (delay[i] <= 0) {
+            dm_add(path[i]);
+            free(path[i]);
+            memmove(path+i, path+i+1, (pathc-i-1) * sizeof(*path));
+            memmove(delay+i, delay+i+1, (pathc-i-1) * sizeof(*delay));
+            pathc--;
+            i--;
+        } else {
+            if (delay[i] < min)
+                min = delay[i];
+        }
+    }
+
+    if (min < TIMER) {
+        set_timer(min);
+    }
+}
+
+void dm_scheduledadd(const char *device)
+{
+    int i, t;
+    int min = TIMER;
+    static int handler = 0;
+    struct itimerval timer;
+    sigset_t sigset_old, sigset_mask;
+
+    if (!handler) {
+        install_handler();
+    }
+
+    sigemptyset(&sigset_mask);
+    sigaddset(&sigset_mask, SIGALRM);
+    sigprocmask(SIG_BLOCK, &sigset_mask, &sigset_old);
+
+    for (i = 0 ; i < pathc ; i++) {
+        if (!strcmp(device, path[i])) {
+            if (getitimer(ITIMER_REAL, &timer) < 0) {
+                perror("getitimer");
+                exit(EXIT_FAILURE); // FIXME
+            }
+            t = timer.it_value.tv_usec + 1000000 * timer.it_value.tv_sec;
+            delay[i] = TIMER + next - t;
+            return;
+        }
+    }
+
+    notice(NEW, device);
+
+    if (pathc == paths) {
+        paths += 5;
+        if ((delay = realloc(delay, paths * sizeof(int))) == NULL) {
+            perror("realloc");
+            exit(EXIT_FAILURE);
+        }
+        if ((path = realloc(path, paths * sizeof(char*))) == NULL) {
+            perror("realloc");
+            exit(EXIT_FAILURE);
+        }
+    }
+    if ((path[pathc] = malloc(strlen(device) * sizeof(char) + 1)) == NULL) {
+        perror("malloc");
+        exit(EXIT_FAILURE);
+    }
+    strcpy(path[pathc], device);
+    delay[pathc] = TIMER;
+    pathc++;
+    
+    if (pathc == 1) {
+        set_timer(TIMER);
+    }
+
+    sigprocmask(SIG_SETMASK, &sigset_old, NULL);
+}
+
+void dm_add(const char *path)
+{
+    if (devc == MAX_DEVICES) {
+        fprintf(stderr, "%s: too many device\n", __FUNCTION__);
+        notice(ADDFAIL, path);
+        return;
+    }
+
+    if (device_new(devices+devc, path) < 0) {
+        notice(ADDFAIL, path);
+        return;
+    }
+
+    notice(ADD, path);
+
+    devc++;
+}
+
+void dm_select(fd_set *readfds, fd_set *writefds)
+{
+    int i;
+    for (i = 0 ; i < devc ; i++) {
+        struct device *dev = devices[i];
+        if (BUF_SIZE - dev->fbufsize > 0) {
+            FD_SET(dev->fd, readfds);
+        }
+        if (BUF_SIZE - dev->sbufsize > 0 && dev->state == CONNECTED) {
+            FD_SET(dev->sock, readfds);
+        }
+        if (dev->sbufsize > 0) {
+            FD_SET(dev->fd, writefds);
+        }
+        if (dev->fbufsize > 0 && dev->state == CONNECTED) {
+            FD_SET(dev->sock, writefds);
+        }
+    }
+}
+
+void dm_event(fd_set *readfds, fd_set *writefds)
+{
+    int i = 0;
+
+    while (i < devc) {
+        struct device *dev = devices[i];
+        if (FD_ISSET(dev->fd, readfds)) {
+            if (device_read(dev->fd, dev->fbuf, &(dev->fbufsize)) < 0) {
+                dm_del(i);
+                continue;
+            }
+            if (dev->state != CONNECTED) {
+                if (device_connect(dev) < 0) {
+                    dm_del(i);
+                    continue;
+                }
+            }
+        }
+        if (dev->state == CONNECTED && FD_ISSET(dev->sock, readfds)) {
+            if (device_read(dev->sock, dev->sbuf, &(dev->sbufsize)) < 0) {
+                dm_del(i);
+                continue;
+            }
+        }
+        if (FD_ISSET(dev->fd, writefds)) {
+            if (device_write(dev->fd, dev->sbuf, &(dev->sbufsize)) < 0) {
+                dm_del(i);
+                continue;
+            }
+        }
+        if (dev->state == CONNECTED && FD_ISSET(dev->sock, writefds)) {
+            if (device_write(dev->sock, dev->fbuf, &(dev->fbufsize)) < 0) {
+                dm_del(i);
+                continue;
+            }
+        }
+        i++;
+    }
+}
+
+void dm_del(int offset)
+{
+    notice(DEL, devices[offset]->path);
+    device_delete(devices+offset);
+    memmove(devices+offset, devices+offset+1, (--devc-offset) * sizeof(*devices));
+}

devicemanager.h

@@ -0,0 +1,18 @@
+#ifndef _DEVICE_MANAGER_H
+#define _DEVICE_MANAGER_H
+
+#include <sys/select.h>
+
+// Add device to managed devices list
+void dm_add(const char *device);
+
+// Add fd to fd set for reading and writting
+void dm_select(fd_set *readfds, fd_set *writefds);
+
+// Manage events for fd in readfds and writefds
+void dm_event(fd_set *readfds, fd_set *writefds);
+
+// Remove device from managed devices list
+void dm_del(int offset);
+
+#endif // _DEVICE_MANAGER_H

getsockfd.c

@@ -0,0 +1,54 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <netinet/in.h>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int getsockfd(const char * host, const char * port) 
+{ 
+    struct hostent * hostent; 
+    struct servent * servent; 
+    struct sockaddr_in address; 
+    int numero, sock; 
+ 
+    memset(&address, 0, sizeof(struct sockaddr_in)); 
+    if (inet_aton(host, &(address.sin_addr)) == 0) { 
+        if ((hostent = gethostbyname(host)) == NULL) { 
+            fprintf(stderr, "%s: unknow host\n", __FUNCTION__); 
+            return -1; 
+        } 
+        address.sin_addr.s_addr = ((struct in_addr *) (hostent->h_addr))->s_addr; 
+    } 
+    if (sscanf(port, "%d", &numero) == 1) { 
+        address.sin_port = htons(numero); 
+    } else if ((servent = getservbyname(port, "tcp")) == NULL) { 
+        fprintf(stderr, "%s: unknow service %s\n", __FUNCTION__, port);
+        return -1; 
+    } else { 
+        address.sin_port = servent->s_port; 
+    } 
+    address.sin_family = AF_INET; 
+    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) { 
+        perror("socket"); 
+        return -1; 
+    } 
+    if (connect(sock, (struct sockaddr *) &address, sizeof(struct sockaddr_in)) < 0) { 
+        perror("connect"); 
+        return -1; 
+    } 
+ 
+    return sock; 
+}
+
+#ifdef __cplusplus
+}
+#endif

getttyfd.c

@@ -0,0 +1,141 @@
+#include <termios.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static speed_t convertspeed(int s);
+
+int getttyfd(const char * device, int s)
+{
+	struct termios config;
+	int tty;
+	speed_t speed;
+
+	speed = convertspeed(s);
+
+	tty = open(device, O_RDWR | O_NOCTTY | O_NDELAY | O_NONBLOCK);
+	if(tty == -1) {
+		fprintf(stderr, "%s: failed to open port '%s' (%m)\n", __FUNCTION__, device);
+		return -1;
+	}
+	if(!isatty(tty)) {
+		fprintf(stderr, "%s: '%s' is not a tty (%m)\n", __FUNCTION__, device);
+		return -1;
+	}
+	if(tcgetattr(tty, &config) < 0) {
+        perror("tcgetattr");
+		fprintf(stderr, "%s: failed to get port config\n", __FUNCTION__);
+		return -1;
+	}
+	//
+	// Input flags - Turn off input processing
+	// convert break to null byte, no CR to NL translation,
+	// no NL to CR translation, don't mark parity errors or breaks
+	// no input parity check, don't strip high bit off,
+	// no XON/XOFF software flow control
+	//
+	config.c_iflag &= ~(IGNBRK | BRKINT | ICRNL |
+						INLCR | PARMRK | INPCK | ISTRIP | IXON);
+	//
+	// Output flags - Turn off output processing
+	// no CR to NL translation, no NL to CR-NL translation,
+	// no NL to CR translation, no column 0 CR suppression,
+	// no Ctrl-D suppression, no fill characters, no case mapping,
+	// no local output processing
+	//
+	// config.c_oflag &= ~(OCRNL | ONLCR | ONLRET |
+	//                     ONOCR | ONOEOT| OFILL | OLCUC | OPOST);
+	config.c_oflag = 0;
+	//
+	// No line processing:
+	// echo off, echo newline off, canonical mode off, 
+	// extended input processing off, signal chars off
+	//
+	config.c_lflag &= ~(ECHO | ECHONL | ICANON | IEXTEN | ISIG);
+	//
+	// Turn off character processing
+	// clear current char size mask, no parity checking,
+	// no output processing, force 8 bit input
+	//
+	config.c_cflag &= ~(CSIZE | PARENB);
+	config.c_cflag |= CS8;
+	//
+	// One input byte is enough to return from read()
+	// Inter-character timer off
+	//
+	config.c_cc[VMIN]  = 1;
+	config.c_cc[VTIME] = 0;
+	//
+	// Communication speed (simple version, using the predefined
+	// constants)
+	//
+	if(cfsetispeed(&config, speed) < 0 || cfsetospeed(&config, speed) < 0) {
+        perror("cfsetispeed");
+		fprintf(stderr, "%s: failed to set speed\n");
+		return -1;
+	}
+	//
+	// Finally, apply the configuration
+	//
+	if(tcsetattr(tty, TCSAFLUSH, &config) < 0) {
+        perror("tcsetattr");
+		fprintf(stderr, "%s: failed to apply config\n", __FUNCTION__);
+		return -1;
+	}
+	
+	return tty;
+}
+
+static speed_t convertspeed(int speed)
+{
+	switch (speed) {
+		case 50:
+			return B50;
+		case 75:
+			return B75;
+		case 110:
+			return B110;
+		case 134:
+			return B134;
+		case 150:
+			return B150;
+		case 200:
+			return B200;
+		case 300:
+			return B300;
+		case 600:
+			return B600;
+		case 1200:
+			return B1200;
+		case 1800:
+			return B1800;
+		case 2400:
+			return B2400;
+		case 4800:
+			return B4800;
+		case 9600:
+			return B9600;
+		case 19200:
+			return B19200;
+		case 38400:
+			return B38400;
+		case 57600:
+			return B57600;
+		case 115200:
+			return B115200;
+		case 230400:
+			return B230400;
+	}
+	fprintf(stderr, "Warning: unknow speed value %d, use 9600 instead\n", speed);
+	return B9600;
+}
+
+#ifdef __cplusplus
+}
+#endif

ini.c

@@ -0,0 +1,158 @@
+/* inih -- simple .INI file parser
+
+inih is released under the New BSD license (see LICENSE.txt). Go to the project
+home page for more info:
+
+http://code.google.com/p/inih/
+
+*/
+
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+
+#include "ini.h"
+
+#define MAX_LINE 200
+#define MAX_SECTION 50
+#define MAX_NAME 50
+
+/* Strip whitespace chars off end of given string, in place. Return s. */
+static char* rstrip(char* s)
+{
+    char* p = s + strlen(s);
+    while (p > s && isspace(*--p))
+        *p = '\0';
+    return s;
+}
+
+/* Return pointer to first non-whitespace char in given string. */
+static char* lskip(const char* s)
+{
+    while (*s && isspace(*s))
+        s++;
+    return (char*)s;
+}
+
+/* Return pointer to first char c or ';' comment in given string, or pointer to
+   null at end of string if neither found. ';' must be prefixed by a whitespace
+   character to register as a comment. */
+static char* find_char_or_comment(const char* s, char c)
+{
+    int was_whitespace = 0;
+    while (*s && *s != c && !(was_whitespace && *s == ';')) {
+        was_whitespace = isspace(*s);
+        s++;
+    }
+    return (char*)s;
+}
+
+/* Version of strncpy that ensures dest (size bytes) is null-terminated. */
+static char* strncpy0(char* dest, const char* src, size_t size)
+{
+    strncpy(dest, src, size);
+    dest[size - 1] = '\0';
+    return dest;
+}
+
+/* See documentation in header file. */
+int ini_parse_file(FILE* file,
+                   int (*handler)(void*, const char*, const char*,
+                                  const char*),
+                   void* user)
+{
+    /* Uses a fair bit of stack (use heap instead if you need to) */
+    char line[MAX_LINE];
+    char section[MAX_SECTION] = "";
+    char prev_name[MAX_NAME] = "";
+
+    char* start;
+    char* end;
+    char* name;
+    char* value;
+    int lineno = 0;
+    int error = 0;
+
+    /* Scan through file line by line */
+    while (fgets(line, sizeof(line), file) != NULL) {
+        lineno++;
+
+        start = line;
+#if INI_ALLOW_BOM
+        if (lineno == 1 && (unsigned char)start[0] == 0xEF &&
+                           (unsigned char)start[1] == 0xBB &&
+                           (unsigned char)start[2] == 0xBF) {
+            start += 3;
+        }
+#endif
+        start = lskip(rstrip(start));
+
+        if (*start == ';' || *start == '#') {
+            /* Per Python ConfigParser, allow '#' comments at start of line */
+        }
+#if INI_ALLOW_MULTILINE
+        else if (*prev_name && *start && start > line) {
+            /* Non-black line with leading whitespace, treat as continuation
+               of previous name's value (as per Python ConfigParser). */
+            if (!handler(user, section, prev_name, start) && !error)
+                error = lineno;
+        }
+#endif
+        else if (*start == '[') {
+            /* A "[section]" line */
+            end = find_char_or_comment(start + 1, ']');
+            if (*end == ']') {
+                *end = '\0';
+                strncpy0(section, start + 1, sizeof(section));
+                *prev_name = '\0';
+            }
+            else if (!error) {
+                /* No ']' found on section line */
+                error = lineno;
+            }
+        }
+        else if (*start && *start != ';') {
+            /* Not a comment, must be a name[=:]value pair */
+            end = find_char_or_comment(start, '=');
+            if (*end != '=') {
+                end = find_char_or_comment(start, ':');
+            }
+            if (*end == '=' || *end == ':') {
+                *end = '\0';
+                name = rstrip(start);
+                value = lskip(end + 1);
+                end = find_char_or_comment(value, '\0');
+                if (*end == ';')
+                    *end = '\0';
+                rstrip(value);
+
+                /* Valid name[=:]value pair found, call handler */
+                strncpy0(prev_name, name, sizeof(prev_name));
+                if (!handler(user, section, name, value) && !error)
+                    error = lineno;
+            }
+            else if (!error) {
+                /* No '=' or ':' found on name[=:]value line */
+                error = lineno;
+            }
+        }
+    }
+
+    return error;
+}
+
+/* See documentation in header file. */
+int ini_parse(const char* filename,
+              int (*handler)(void*, const char*, const char*, const char*),
+              void* user)
+{
+    FILE* file;
+    int error;
+
+    file = fopen(filename, "r");
+    if (!file)
+        return -1;
+    error = ini_parse_file(file, handler, user);
+    fclose(file);
+    return error;
+}

ini.h

@@ -0,0 +1,61 @@
+/* inih -- simple .INI file parser
+
+inih is released under the New BSD license (see LICENSE.txt). Go to the project
+home page for more info:
+
+http://code.google.com/p/inih/
+
+*/
+
+#ifndef __INI_H__
+#define __INI_H__
+
+/* Make this header file easier to include in C++ code */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+
+/* Parse given INI-style file. May have [section]s, name=value pairs
+   (whitespace stripped), and comments starting with ';' (semicolon). Section
+   is "" if name=value pair parsed before any section heading. name:value
+   pairs are also supported as a concession to Python's ConfigParser.
+
+   For each name=value pair parsed, call handler function with given user
+   pointer as well as section, name, and value (data only valid for duration
+   of handler call). Handler should return nonzero on success, zero on error.
+
+   Returns 0 on success, line number of first error on parse error (doesn't
+   stop on first error), or -1 on file open error.
+*/
+int ini_parse(const char* filename,
+              int (*handler)(void* user, const char* section,
+                             const char* name, const char* value),
+              void* user);
+
+/* Same as ini_parse(), but takes a FILE* instead of filename. This doesn't
+   close the file when it's finished -- the caller must do that. */
+int ini_parse_file(FILE* file,
+                   int (*handler)(void* user, const char* section,
+                                  const char* name, const char* value),
+                   void* user);
+
+/* Nonzero to allow multi-line value parsing, in the style of Python's
+   ConfigParser. If allowed, ini_parse() will call the handler with the same
+   name for each subsequent line parsed. */
+#ifndef INI_ALLOW_MULTILINE
+#define INI_ALLOW_MULTILINE 1
+#endif
+
+/* Nonzero to allow a UTF-8 BOM sequence (0xEF 0xBB 0xBF) at the start of
+   the file. See http://code.google.com/p/inih/issues/detail?id=21 */
+#ifndef INI_ALLOW_BOM
+#define INI_ALLOW_BOM 1
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __INI_H__ */

notice.c

@@ -0,0 +1,41 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "notice.h"
+
+void notice(enum notice type, const char *path)
+{
+    notice_sock(type, path, NULL, NULL);
+}
+
+void notice_idfail(const char *path, int id)
+{
+    printf("[ID %d FAIL] %s\n", id, path);
+}
+
+void notice_sock(enum notice type, const char *path, const char *host,
+        const char *service)
+{
+    switch (type) {
+        case ADD:
+            printf("[OPEN ] %s\n", path);
+            break;
+        case ADDFAIL:
+            printf("[FAIL ] %s\n", path);
+            break;
+        case DEL:
+            printf("[CLOSE] %s\n", path);
+            break;
+        case NEW:
+            printf("[NEW  ] %s\n", path);
+            break;
+        case CONNECT:
+            printf("[CONNECTED] %s ↔ %s:%s\n", path, host, service);
+            break;
+        case SOCKFAIL:
+            printf("[FAIL     ] %s ↔ %s:%s\n", path, host, service);
+            break;
+        default:
+            printf("[?????????] %s\n", path);
+    }
+}

notice.h

@@ -0,0 +1,19 @@
+#ifndef _NOTICE_H_
+#define _NOTICE_H_
+
+enum notice {
+    ADD,
+    DEL,
+    ADDFAIL,
+    NEW,
+    SOCKFAIL,
+    IDFAIL,
+    CONNECT,
+};
+
+void notice(enum notice type, const char *path);
+void notice_idfail(const char *path, int id);
+void notice_sock(enum notice type, const char *path, const char *host,
+        const char *service);
+
+#endif // _NOTICE_H_

ports.ini

@@ -0,0 +1,5 @@
+1 = 1301
+2 = 1302
+3 = 1303
+4 = 1304
+5 = 1305

settings.c

@@ -0,0 +1,95 @@
+#include <stdlib.h>
+#include <errno.h>
+
+#include "ini.h"
+
+#include "settings.h"
+
+#define MATCH(s, n) strcmp(section, s) == 0 && strcmp(name, n) == 0
+
+static int default_ports[MAX_ID][2] = {
+    { 1, 1301 },
+    { 2, 1302 },
+    { 3, 1303 },
+    { 4, 1304 },
+    { 5, 1305 },
+    { 0, 0 }, // Keep this line to mark the end of the array
+};
+
+int speed = DEFAULT_SPEED;
+char *host = DEFAULT_HOST;
+static int *loaded_ports = NULL;
+static int loaded_ports_count = 0;
+static int loaded_ports_size = 0;
+
+static int handler(void *user, const char *section, const char *name,
+        const char *value)
+{
+    char *ret; int id; int port;
+
+    id = strtol(name, &ret, 10);
+    if (*ret != '\0' || id < 0 || id > MAX_ID) {
+        return 0;
+    }
+    port = atoi(value);
+    if (port < 1 || port > 65535) {
+        return 0;
+    }
+
+    if (loaded_ports_count == loaded_ports_size) {
+        loaded_ports_size += 5;
+        if ((loaded_ports = realloc(loaded_ports, loaded_ports_size
+                        * sizeof(int[2]))) == NULL) {
+            perror("realloc");
+            exit(EXIT_FAILURE);
+        }
+    }
+    loaded_ports[loaded_ports_count * 2 + 0] = id;
+    loaded_ports[loaded_ports_count * 2 + 1] = port;
+    loaded_ports_count += 1;
+
+    return 1;
+}
+
+int loadports(const char *filename)
+{
+    int ret;
+
+    if ((ret = ini_parse(filename, handler, NULL)) != 0) {
+        if (ret < 0) {
+            printf("Warning: can't open config file '%s' (%m)\n", filename);
+            return -1;
+        } else {
+            printf("Warning: errors occurred during config file"
+                    " parsing (first error at line %d)\n", ret);
+        }
+    }
+
+    return 0;
+}
+
+int getportbyid(int id)
+{
+    int i = 0;
+    int port;
+
+    if (loaded_ports) {
+        for (i = 0 ; i < loaded_ports_count ; i++) {
+            port = loaded_ports[i * 2 + 1];
+            if (loaded_ports[i * 2 + 0] == id)
+                break;
+        }
+        if (i == loaded_ports_count) {
+            port = 0;
+        }
+    } else {
+        do {
+            port = default_ports[i][1];
+            if (default_ports[i][0] == id)
+                break;
+            i++;
+        } while (port != 0);
+    }
+
+    return port;
+}

settings.h

@@ -0,0 +1,19 @@
+#ifndef _SETTINGS_H_
+#define _SETTINGS_H_
+
+#define DEFAULT_SPEED   9600
+#define DEFAULT_HOST    "localhost"
+#define MAX_ID          255
+
+extern int speed;
+extern char *host;
+
+/* Load ports list from config file. */
+int loadports(const char *filename);
+
+/* Return port number associated with provides id.
+ * If no port is associated with this id, return 0.
+ */
+int getportbyid(int id);
+
+#endif // _SETTINGS_H_

usbdaemon.c

@@ -0,0 +1,224 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <sys/inotify.h>
+
+#include "settings.h"
+
+#define EVENT_SIZE      (sizeof(struct inotify_event))
+#define BUF_LEN         (8*(EVENT_SIZE+16))
+
+#define ENV_PREFIX      "USBDAEMON"
+#define MAX_DEVICE      16
+
+const char *basedir = "/dev";
+
+void usage(const char *cmd);
+int addexistingdevices(const char *dir);
+int getinotifyfd(const char *dir);
+void gateway(int inotifyfd);
+int filter(const char *filename);
+
+int main(int argc, char *argv[])
+{
+    int option, inotifyfd;
+    char *env;
+    char *opt_host = NULL;
+    char *configfile = NULL;
+    char *opt_basedir = NULL;
+
+    env = getenv(ENV_PREFIX"_HOST");
+    if ((env != NULL) && (strlen(env) != 0)) {
+        if ((opt_host = malloc(strlen(env) + 1)) == NULL) {
+            perror("malloc");
+            exit(EXIT_FAILURE);
+        }
+        strcpy(opt_host, env);
+        host = opt_host;
+    }
+    env = getenv(ENV_PREFIX"_SPEED");
+    if ((env != NULL) && (strlen(env) != 0)) {
+        sscanf(env, "%d", &speed);
+    }
+    env = getenv(ENV_PREFIX"_CONFIG");
+    if ((env != NULL) && (strlen(env) != 0)) {
+        if ((configfile = malloc(strlen(env) + 1)) == NULL) {
+            perror("malloc");
+            exit(EXIT_FAILURE);
+        }
+        strcpy(configfile, env);
+    }
+    env = getenv(ENV_PREFIX"_DIR");
+    if ((env != NULL) && (strlen(env) != 0)) {
+        if ((opt_basedir = malloc(strlen(env) + 1)) == NULL) {
+            perror("malloc");
+            exit(EXIT_FAILURE);
+        }
+        strcpy(opt_basedir, env);
+        basedir = opt_basedir;
+    }
+
+    opterr = 1;
+    while (1) {
+        option = getopt(argc, argv, "h:s:c:d:");
+        if (option == -1)
+            break;
+        switch (option) {
+            case 'h':
+                if ((opt_host = malloc(strlen(optarg) + 1)) == NULL) {
+                    perror("malloc");
+                    exit(EXIT_FAILURE);
+                }
+                strcpy(opt_host, optarg);
+                host = opt_host;
+                break;
+            case 's':
+                sscanf(optarg, "%d", &speed);
+                break;
+            case 'c':
+                if ((configfile = malloc(strlen(optarg) + 1)) == NULL) {
+                    perror("malloc");
+                    exit(EXIT_FAILURE);
+                }
+                strcpy(configfile, optarg);
+                break;
+            case 'd':
+                if ((opt_basedir = malloc(strlen(optarg) + 1)) == NULL) {
+                    perror("malloc");
+                    exit(EXIT_FAILURE);
+                }
+                strcpy(opt_basedir, optarg);
+                basedir = opt_basedir;
+                break;
+            case '?':
+                usage(argv[0]);
+                exit(EXIT_FAILURE);
+            default:
+                break;
+        }
+    }
+
+    printf("Gateway settings:\n");
+    printf("\tHost: %s\n", host);
+    printf("\tSpeed: %d\n", speed);
+    printf("\tMonitoring device in: %s\n", basedir);
+    if (configfile) {
+        printf("\tConfig file: %s\n", configfile);
+        if (loadports(configfile) < 0) {
+            fprintf(stderr, "Warning: using defaults ports instead\n");
+        }
+    }
+
+    if (addexistingdevices(basedir) < 0) {
+        fprintf(stderr, "Warning: already connected device not managed\n");
+    }
+
+    if ((inotifyfd = getinotifyfd(basedir)) < 0) {
+        fprintf(stderr, "Warning: monitoring disabled");
+    }
+
+    gateway(inotifyfd);
+
+    return 0;
+}
+
+int filter(const char *filename)
+{
+    int a;
+    return sscanf(filename, "ttyUSB%d", &a) == 1;
+}
+
+int addexistingdevices(const char *basedir)
+{
+    struct dirent *item;
+    char path[256];
+    DIR *dir = opendir(basedir);
+
+    if (dir == NULL) {
+        perror("opendir");
+        return -1;
+    }
+    while (item = readdir(dir)) {
+        if (filter(item->d_name)) {
+            sprintf(path, "%s/%s", basedir, item->d_name);
+            dm_add(path);
+        }
+    }
+
+    closedir(dir);
+
+    return 0;
+}
+
+int getinotifyfd(const char *dir)
+{
+    int fd, wd;
+    
+    if ((fd = inotify_init1(O_NONBLOCK)) < 0) {
+        perror("intotify_init1");
+        return -1;
+    }
+
+    if (inotify_add_watch(fd, dir, IN_CREATE) < 0) {
+        perror("inotify_add_watch");
+        return -1;
+    }
+
+    return fd;
+}
+
+void gateway(int inotifyfd)
+{
+    int length, i;
+    char buffer[BUF_LEN];
+    char path[256];
+    fd_set readfds, writefds;
+
+    while (1) {
+        FD_ZERO(&readfds);
+        if (inotifyfd > -1) {
+            FD_SET(inotifyfd, &readfds);
+        }
+        FD_ZERO(&writefds);
+        dm_select(&readfds, &writefds);
+        
+        if (select(FD_SETSIZE, &readfds, &writefds, NULL, NULL) < 0) {
+            if (errno == EINTR) {
+                continue;
+            } else {
+                perror("select");
+                exit(EXIT_FAILURE); // FIXME
+            }
+        }
+
+        if (FD_ISSET(inotifyfd, &readfds)) {
+            if ((length = read(inotifyfd, buffer, BUF_LEN)) < 0) {
+                perror("read");
+                exit(EXIT_FAILURE); // FIXME
+            }
+            i = 0;
+            while (i < length) {
+                struct inotify_event *event = (struct inotify_event*)&(buffer[i]);
+                if (event->len && !(event->mask & IN_ISDIR)) {
+                    if (filter(event->name)) {
+                        sprintf(path, "%s/%s", basedir, event->name);
+                        dm_scheduledadd(path);
+                    }
+                }
+                i += EVENT_SIZE + event->len;
+            }
+        }
+
+        dm_event(&readfds, &writefds);
+    }
+}
+
+void usage(const char *cmd)
+{
+    printf("Usage: %s [-h host] [-s speed] [-c config_file] [-d device_dir]\n", cmd);
+}