Implemented lockfile stuff to prevent multiple running instances.

Implemented daemonizing, use -f to run in foreground.
Implemented logging to syslog (or to std{out,err} when running in foreground).
Modified the udev rules file (removed --pidfile etc.).

1 files changed, 188 insertions, 25 deletions

diff --git a/main.c b/main.c
index 832ff7f..0af0735 100644
--- a/main.c
+++ b/main.c
@@ -24,6 +24,10 @@
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
+#include <getopt.h>
+#include <stdarg.h>
+#include <syslog.h>
+#include <fcntl.h>
 #include <sys/socket.h>
 #include <sys/un.h>
 #include <sys/stat.h>
@@ -43,9 +47,12 @@
 #define DEFAULT_CHILDREN_CAPACITY 10
 #define DEBUG_LEVEL 0
 
+#define LOCKFILE "/var/run/usbmuxd.lock"
+
 static int quit_flag = 0;
 static int fsock = -1;
 static int verbose = DEBUG_LEVEL;
+static int foreground = 0;
 
 struct device_use_info {
     uint32_t device_id;
@@ -764,7 +771,43 @@ leave:
  */
 static int daemonize()
 {
-    // TODO still to be implemented, also logging is missing!
+    pid_t pid;
+    pid_t sid;
+
+    // already a daemon
+    if (getppid() == 1) return 0;
+
+    pid = fork();
+    if (pid < 0) {
+        exit(EXIT_FAILURE);
+    }
+
+    if (pid > 0) {
+        // exit parent process
+        exit(EXIT_SUCCESS);
+    }
+
+    // At this point we are executing as the child process
+
+    // Change the file mode mask
+    umask(0);
+
+    // Create a new SID for the child process
+    sid = setsid();
+    if (sid < 0) {
+        return -1;
+    }
+
+    // Change the current working directory.
+    if ((chdir("/")) < 0) {
+        return -2;
+    }
+
+    // Redirect standard files to /dev/null
+    freopen("/dev/null", "r", stdin);
+    freopen("/dev/null", "w", stdout);
+    freopen("/dev/null", "w", stderr);
+
     return 0;
 }
 
@@ -779,12 +822,85 @@ static void clean_exit(int sig)
     quit_flag = 1;
 }
 
+static void logmsg(int prio, char *format, ...)
+{
+    va_list args;
+    va_start(args, format);
+
+    if (!foreground) {
+        // daemon. log using syslog.
+        vsyslog(prio, format, args);
+    } else {
+        // running in foreground. log to stdout/stderr.
+        char msgbuf[256];
+        FILE *lfp = stdout;
+        switch(prio) {
+            case LOG_EMERG:
+            case LOG_ALERT:
+            case LOG_CRIT:
+            case LOG_ERR:
+            case LOG_WARNING:
+                lfp = stderr;
+                break;
+            default:
+                lfp = stdout;
+        }
+        strcpy(msgbuf, "usbmuxd: ");
+        vsnprintf(msgbuf+9, 244, format, args);
+        strcat(msgbuf, "\n");
+        fputs(msgbuf, lfp);
+    }
+
+    va_end(args);
+}
+
+static void usage()
+{
+    printf("usage: usbmuxd [options]\n");
+    printf("\t-h|--help        print this message.\n");
+    printf("\t-v|--verbose     be verbose\n");
+    printf("\t-f|--foreground  do not daemonize\n");
+    printf("\n");
+}
+
+static void parse_opts(int argc, char **argv)
+{
+    static struct option longopts[] = {
+        { "help",       0, NULL, 'h' },
+        { "foreground", 0, NULL, 'f' },
+        { "verbose",    0, NULL, 'v' },
+        { NULL,         0, NULL, 0}
+    };
+    int c;
+
+    while (1) {
+        c = getopt_long(argc, argv, "hfv", longopts, (int *) 0);
+        if (c == -1) {
+            break;
+        }
+
+        switch (c) {
+            case 'h':
+                usage();
+                exit(0);
+            case 'f':
+                foreground = 1;
+                break;
+            case 'v':
+                sock_stuff_set_verbose(++verbose);
+                break;
+            default:
+                usage();
+                exit(2);
+        }
+    }
+}
+
 /**
  * main function. Initializes all stuff and then loops waiting in accept.
  */
 int main(int argc, char **argv)
 {
-    int foreground = 1;
     struct sockaddr_un c_addr;
     socklen_t len = sizeof(struct sockaddr_un);
     struct client_data *cdata = NULL;
@@ -793,20 +909,47 @@ int main(int argc, char **argv)
     int i;
     int result = 0;
     int cnt = 0;
+    FILE *lfd = NULL;
+    struct flock lock;
 
-    for (i = 1; i < argc; i++) {
-        if (argv[i] != NULL && (!strncmp("-v", argv[i], 2) || !strncmp("--verbose", argv[i], 10))) {
-            sock_stuff_set_verbose(++verbose);
-        }
+    parse_opts(argc, argv);
+
+    argc -= optind;
+    argv += optind;
+
+    if (!foreground) {
+        openlog("usbmuxd", LOG_PID, 0);
     }
 
-    if (verbose >= 2) fprintf(stderr, "usbmuxd: starting\n");
+    if (verbose >= 2) logmsg(LOG_NOTICE, "starting");
 
-    // TODO: Parameter checking.
+    // signal(SIGHUP, reload_conf); // none yet
+    signal(SIGINT, clean_exit);
+    signal(SIGQUIT, clean_exit);
+    signal(SIGTERM, clean_exit);
+    signal(SIGPIPE, SIG_IGN); 
+
+    // check for other running instance
+    lfd = fopen(LOCKFILE, "r");
+    if (lfd) {
+        lock.l_type = 0;
+        lock.l_whence = SEEK_SET;
+        lock.l_start = 0;
+        lock.l_len = 0;
+        fcntl(fileno(lfd), F_GETLK, &lock);
+        fclose(lfd);
+        if (lock.l_type != F_UNLCK) {
+            logmsg(LOG_NOTICE, "another instance is already running. exiting.");
+            return -1;
+        }
+    }
 
     fsock = create_unix_socket(USBMUXD_SOCKET_FILE);
     if (fsock < 0) {
-        if (verbose >= 1) fprintf(stderr, "Could not create socket, exiting\n");
+        logmsg(LOG_ERR, "Could not create socket, exiting");
+        if (!foreground) {
+            closelog();
+        }
         return -1;
     }
 
@@ -814,26 +957,36 @@ int main(int argc, char **argv)
 
     if (!foreground) {
         if (daemonize() < 0) {
+            fprintf(stderr, "usbmuxd: FATAL: Could not daemonize!\n");
+            syslog(LOG_ERR, "FATAL: Could not daemonize!");
+            closelog();
             exit(EXIT_FAILURE);
         }
     }
 
-    // signal(SIGHUP, reload_conf); // none yet
-    signal(SIGINT, clean_exit);
-    signal(SIGQUIT, clean_exit);
-    signal(SIGTERM, clean_exit);
-    signal(SIGPIPE, SIG_IGN); 
+    // now open the lockfile and place the lock
+    lfd = fopen(LOCKFILE, "w");
+    if (lfd) {
+        lock.l_type = F_WRLCK;
+        lock.l_whence = SEEK_SET;
+        lock.l_start = 0;
+        lock.l_len = 0;
+        fcntl(fileno(lfd), F_SETLK, &lock);
+    }
 
     // Reserve space for 10 clients which should be enough. If not, the
     // buffer gets enlarged later.
     children = (struct client_data**)malloc(sizeof(struct client_data*) * children_capacity);
     if (!children) {
-        if (verbose >= 2) fprintf(stderr, "usbmuxd: Out of memory when allocating memory for child threads. Terminating.\n");
+        logmsg(LOG_ERR, "Out of memory when allocating memory for child threads. Terminating.");
+        if (!foreground) {
+            closelog();
+        }
         exit(EXIT_FAILURE);
     }
     memset(children, 0, sizeof(struct client_data*) * children_capacity);
 
-    if (verbose >= 2) fprintf(stderr, "usbmuxd: waiting for connection\n");
+    if (verbose >= 2) logmsg(LOG_NOTICE, "waiting for connection");
     while (!quit_flag) {        
         // Check the file descriptor before accepting a connection.
         // If no connection attempt is made, just repeat...
@@ -845,7 +998,7 @@ int main(int argc, char **argv)
                     if (children[i]) {
                         if (children[i]->dead != 0) {
                             pthread_join(children[i]->thread, NULL);
-                            if (verbose >= 3) fprintf(stderr, "usbmuxd: reclaimed client thread (fd=%d)\n", children[i]->socket);
+                            if (verbose >= 3) logmsg(LOG_NOTICE, "reclaimed client thread (fd=%d)", children[i]->socket);
                             free(children[i]);
                             children[i] = NULL;
                             cnt++;
@@ -864,7 +1017,7 @@ int main(int argc, char **argv)
                 }
                 continue;
             } else {
-                if (verbose >= 3) fprintf(stderr, "usbmuxd: select error: %s\n", strerror(errno));
+                if (verbose >= 3) logmsg(LOG_ERR, "usbmuxd: select error: %s", strerror(errno));
                 continue;
             }
         }
@@ -873,7 +1026,7 @@ int main(int argc, char **argv)
         memset(cdata, 0, sizeof(struct client_data));
         if (!cdata) {
             quit_flag = 1;
-            if (verbose >= 1) fprintf(stderr, "usbmuxd: Error: Out of memory! Terminating.\n");
+            logmsg(LOG_ERR, "Error: Out of memory! Terminating.");
             break;
         }
 
@@ -883,12 +1036,12 @@ int main(int argc, char **argv)
             if (errno == EINTR) {
                 continue;
             } else {
-                if (verbose >= 3) fprintf(stderr, "usbmuxd: Error in accept: %s\n", strerror(errno));
+                if (verbose >= 3) logmsg(LOG_ERR, "Error in accept: %s", strerror(errno));
                 continue;
             }
         }
 
-        if (verbose >= 1) fprintf(stderr, "usbmuxd: new client connected (fd=%d)\n", cdata->socket);
+        if (verbose >= 1) logmsg(LOG_NOTICE, "new client connected (fd=%d)", cdata->socket);
 
         // create client thread:
         if (pthread_create(&cdata->thread, NULL, usbmuxd_client_init_thread, cdata) == 0) {
@@ -900,19 +1053,19 @@ int main(int argc, char **argv)
                 children_capacity++;
                 children = realloc(children, sizeof(struct client_data*) * children_capacity);
                 if (!children) {
-                    if (verbose >= 1) fprintf(stderr, "usbmuxd: Out of memory when enlarging child thread buffer\n");
+                    logmsg(LOG_ERR, "Out of memory when enlarging child thread buffer");
                 }
             }
             children[i] = cdata;
         } else {
-            if (verbose >= 3) fprintf(stderr, "usbmuxd: Failed to create client_init_thread.\n");
+            logmsg(LOG_ERR, "Failed to create client_init_thread.");
             close(cdata->socket);
             free(cdata);
             cdata = NULL;
         }
     }
 
-    if (verbose >= 3) fprintf(stderr, "usbmuxd: terminating\n");
+    if (verbose >= 3) logmsg(LOG_NOTICE, "terminating");
 
     // preparing for shutdown: wait for child threads to terminate (if any)
     if (verbose >= 2) fprintf(stderr, "usbmuxd: waiting for child threads to terminate...\n");
@@ -934,7 +1087,17 @@ int main(int argc, char **argv)
 
     unlink(USBMUXD_SOCKET_FILE);
 
-    if (verbose >= 1) fprintf(stderr, "usbmuxd: terminated\n");
+    // unlock lock file and close it.
+    if (lfd) {
+        lock.l_type = F_UNLCK;
+        fcntl(fileno(lfd), F_SETLK, lock);
+        fclose(lfd);
+    }
+
+    if (verbose >= 1) logmsg(LOG_NOTICE, "usbmuxd: terminated");
+    if (!foreground) {
+        closelog();
+    }
 
     return 0;
 }