Log functions always write a trailing newline.

[socket2unix/socket2unix.git] / src / socket2unix.c

diff --git a/src/socket2unix.c b/src/socket2unix.c
index 1f741b5f5680e9b97d0f09be17540f718523d2cd..7e761c62db253b056e796de9c592763a71ea8aa1 100644 (file)
--- a/src/socket2unix.c
+++ b/src/socket2unix.c
@@ -46,7 +46,7 @@
 #define LOG_LEVEL_DEBUG   3
 #define LOG_LEVEL_MASK    LOG_LEVEL_DEBUG
 
-#define LOG_LEVEL_PERROR  42
+#define LOG_LEVEL_PERROR  (1 << 10)
 
 #define OPTION_PARSED                                   (1 << 1)
 /* Don't intercept listen(), accept(). */
@@ -116,6 +116,9 @@ static void log_helper(int action, const char *file, int line, const char *forma
 
         errno = saved_errno;
         perror("");
+        /* perror writes a newline. */
+    } else {
+        fprintf(stderr, "\n");
     }
 
     funlockfile(stderr);
@@ -207,10 +210,10 @@ static struct list *remove_sockfd(int sockfd) {
 static const char *get_socket_path(void) {
     const char *path = getenv("SOCKET2UNIX_PATH");
     if (!path) {
-        ERROR("SOCKET2UNIX_PATH environment variable not defined\n");
+        ERROR("SOCKET2UNIX_PATH environment variable not defined");
     }
     if (path[0] != '/') {
-        ERROR("SOCKET2UNIX_PATH '%s' must be an absolute path\n", path);
+        ERROR("SOCKET2UNIX_PATH '%s' must be an absolute path", path);
     }
     return path;
 }
@@ -230,22 +233,24 @@ static int get_log_level(void) {
     return number;
 }
 static int get_options(void) {
-    const char *pos = getenv("SOCKET2UNIX_OPTIONS");
-    if (!pos) {
+    const char *start = getenv("SOCKET2UNIX_OPTIONS");
+    if (!start) {
         return OPTION_PARSED;
     }
 
     int options = OPTION_PARSED;
 
-    while (*pos != '\0') {
+    const char *end = start + strlen(start);
+    const char *pos, *curend;
+
+    for (pos = start; pos < end; pos = curend + 1) {
         size_t length;
 
-        const char *end = strchr(pos, ',');
-        if (end == NULL) {
-            length = strlen(pos);
-        } else {
-            length = (size_t)(end - pos);
+        curend = strchr(pos, ',');
+        if (curend == NULL) {
+            curend = end;
         }
+        length = (size_t)(curend - pos);
 
         if (!strncmp("client_only", pos, length)) {
             options |= OPTION_CLIENT_ONLY;
@@ -255,19 +260,13 @@ static int get_options(void) {
             char option[length + 1];
             strncpy(option, pos, length);
             option[length] = '\0';
-            ERROR("unknown option '%s' in SOCKET2UNIX_OPTIONS\n",
-                  option);
-        }
-
-        if (end == NULL) {
-            break;
+            ERROR("unknown option '%s' in SOCKET2UNIX_OPTIONS", option);
         }
-        pos = end + 1;
     }
 
     if ((options & OPTION_CLIENT_ONLY) && (options & OPTION_SERVER_ONLY)) {
         ERROR("conflicting options 'client_only', 'server_only' "
-              "in SOCKET2UNIX_OPTIONS\n");
+              "in SOCKET2UNIX_OPTIONS");
     }
 
     return options;
@@ -358,7 +357,7 @@ static int set_sockaddr_un(struct sockaddr_un *sockaddr,
                 && addrlen < sizeof(struct sockaddr_in))
             || (addr->sa_family == AF_INET6
                 && addrlen < sizeof(struct sockaddr_in6))) {
-        WARN("invalid addrlen from program\n");
+        WARN("invalid addrlen from program");
         return -1;
     }
 
@@ -370,14 +369,14 @@ static int set_sockaddr_un(struct sockaddr_un *sockaddr,
     int port;
     if (addr->sa_family == AF_INET) {
         af   = "v4";
-        port = ntohs(((struct sockaddr_in *)addr)->sin_port);
+        port = ntohs(((const struct sockaddr_in *)addr)->sin_port);
     } else if (addr->sa_family == AF_INET6) {
         af   = "v6";
-        port = ntohs(((struct sockaddr_in6 *)addr)->sin6_port);
+        port = ntohs(((const struct sockaddr_in6 *)addr)->sin6_port);
     } else {
         af   = "unknown";
         port = 0;
-        WARN("unknown sa_family '%s' (%d)\n",
+        WARN("unknown sa_family '%s' (%d)",
              af_to_name(addr->sa_family), addr->sa_family);
     }
 
@@ -428,7 +427,7 @@ int socket(int domain, int type, int protocol) {
         return sockfd;
     }
 
-    DBG("socket(%s, %s, %d)\n",
+    DBG("socket(%s, %s, %d)",
         af_to_name(domain), sock_to_name(type), protocol);
 
     struct list *entry = xmalloc(sizeof(*entry));
@@ -448,14 +447,14 @@ int close(int fd) {
     static int (*real_close)(int);
     LOAD_FUNCTION(real_close, "close");
 
-    DBG("close(%d)\n", fd);
-
     struct list *entry = remove_sockfd(fd);
     if (entry == NULL) {
-        DBG("close(%d): sockfd not found\n", fd);
+        DBG("close(%d): sockfd not found", fd);
         return real_close(fd);
     }
     assert(fd == entry->orig_sockfd);
+
+    DBG("close(%d)", fd);
     free(entry->orig_addr);
     free(entry);
 
@@ -466,8 +465,6 @@ int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
     static int (*real_bind)(int, const struct sockaddr *, socklen_t);
     LOAD_FUNCTION(real_bind, "bind");
 
-    DBG("bind(%d, ..)\n", sockfd);
-
     if (addr == NULL || addrlen < sizeof(addr->sa_family)
             || addr->sa_family == AF_UNIX
             || addr->sa_family == AF_LOCAL) {
@@ -476,11 +473,11 @@ int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
 
     struct list *entry = find_sockfd(sockfd);
     if (!entry) {
-        DBG("bind(%d, ..): sockfd not found\n", sockfd);
+        DBG("bind(%d, ..): sockfd not found", sockfd);
         return real_bind(sockfd, addr, addrlen);
     }
     assert(sockfd == entry->orig_sockfd);
-    DBG("bind(%d, ..): %s %s\n",
+    DBG("bind(%d, ..): %s %s",
         sockfd,
         af_to_name(entry->orig_domain), sock_to_name(entry->orig_type));
 
@@ -501,17 +498,17 @@ int listen(int sockfd, int backlog) {
     }
 
     if (global_options & OPTION_CLIENT_ONLY) {
-        DBG("listen(%d, %d): server hooking disabled\n", sockfd, backlog);
+        DBG("listen(%d, %d): server hooking disabled", sockfd, backlog);
         return real_listen(sockfd, backlog);
     }
 
     struct list *entry = find_sockfd(sockfd);
     if (!entry) {
-        DBG("listen(%d, %d): sockfd not found\n", sockfd, backlog);
+        DBG("listen(%d, %d): sockfd not found", sockfd, backlog);
         return real_listen(sockfd, backlog);
     }
     assert(sockfd == entry->orig_sockfd);
-    DBG("listen(%d, %d): %s %s\n",
+    DBG("listen(%d, %d): %s %s",
         sockfd, backlog,
         af_to_name(entry->orig_domain), sock_to_name(entry->orig_type));
 
@@ -523,10 +520,10 @@ int listen(int sockfd, int backlog) {
     struct sockaddr_un sockaddr;
     if (set_sockaddr_un(&sockaddr, entry->orig_addr,
                                    entry->orig_addrlen) != 0) {
-        ERROR("listen(%d, ..) failed\n", sockfd);
+        ERROR("listen(%d, ..) failed", sockfd);
     }
 
-    DBG("listen(%d, ..): using path '%s'\n", sockfd, sockaddr.sun_path);
+    DBG("listen(%d, ..): using path '%s'", sockfd, sockaddr.sun_path);
 
     int attempts = 0;
     while (attempts < 10) {
@@ -551,11 +548,11 @@ int listen(int sockfd, int backlog) {
         }
 
         if (!S_ISSOCK(buf.st_mode)) {
-            ERROR("listen(%d, ..): path '%s' exits and is no socket\n",
+            ERROR("listen(%d, ..): path '%s' exits and is no socket",
                   sockfd, sockaddr.sun_path);
         }
 
-        WARN("listen(%d, ..): unlinking '%s'\n", sockfd, sockaddr.sun_path);
+        WARN("listen(%d, ..): unlinking '%s'", sockfd, sockaddr.sun_path);
         if (unlink(sockaddr.sun_path) != 0) {
             DIE("listen(%d, ..): unlink '%s' failed",
                 sockfd, sockaddr.sun_path);
@@ -565,7 +562,7 @@ int listen(int sockfd, int backlog) {
     }
 
     if (attempts == 10) {
-        ERROR("listen(%d, ..): failed to create UNIX socket file\n", sockfd);
+        ERROR("listen(%d, ..): failed to create UNIX socket file", sockfd);
     }
 
     /* Replace the original socket of the program with our socket. */
@@ -589,19 +586,17 @@ int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen) {
     }
 
     if (global_options & OPTION_CLIENT_ONLY) {
-        DBG("accept(%d, ..): server hooking disabled\n", sockfd);
+        DBG("accept(%d, ..): server hooking disabled", sockfd);
         return real_accept(sockfd, addr, addrlen);
     }
 
-    DBG("accept(%d, ..)\n", sockfd);
-
     struct list *entry = find_sockfd(sockfd);
     if (!entry) {
-        DBG("accept(%d, ..): sockfd not found\n", sockfd);
+        DBG("accept(%d, ..): sockfd not found", sockfd);
         return real_accept(sockfd, addr, addrlen);
     }
     assert(sockfd == entry->orig_sockfd);
-    DBG("accept(%d, ..): %s %s\n",
+    DBG("accept(%d, ..): %s %s",
         sockfd,
         af_to_name(entry->orig_domain), sock_to_name(entry->orig_type));
 
@@ -616,7 +611,7 @@ int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen) {
     if (addr == NULL || addrlen == NULL) {
         return sock;
     }
-    DBG("accept(%d, ..): caller requested sockaddr\n", sockfd);
+    DBG("accept(%d, ..): caller requested sockaddr", sockfd);
 
     if (*addrlen < size) {
         WARN("accept(%d, ..): invalid addrlen from program", sockfd);
@@ -643,12 +638,10 @@ int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
     }
 
     if (global_options & OPTION_SERVER_ONLY) {
-        DBG("connect(%d, ..): client hooking disabled\n", sockfd);
+        DBG("connect(%d, ..): client hooking disabled", sockfd);
         return real_connect(sockfd, addr, addrlen);
     }
 
-    DBG("connect(%d, ..)\n", sockfd);
-
     if (addr == NULL || addrlen < sizeof(addr->sa_family)
             || addr->sa_family == AF_UNIX
             || addr->sa_family == AF_LOCAL) {
@@ -657,11 +650,11 @@ int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
 
     struct list *entry = find_sockfd(sockfd);
     if (!entry) {
-        DBG("connect(%d, ..): sockfd not found\n", sockfd);
+        DBG("connect(%d, ..): sockfd not found", sockfd);
         return real_connect(sockfd, addr, addrlen);
     }
     assert(sockfd == entry->orig_sockfd);
-    DBG("connect(%d, ..): %s %s\n",
+    DBG("connect(%d, ..): %s %s",
         sockfd,
         af_to_name(entry->orig_domain), sock_to_name(entry->orig_type));
 
@@ -677,10 +670,10 @@ int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
 
     struct sockaddr_un sockaddr;
     if (set_sockaddr_un(&sockaddr, addr, addrlen) != 0) {
-        ERROR("connect(%d, ..) failed\n", sockfd);
+        ERROR("connect(%d, ..) failed", sockfd);
     }
 
-    DBG("connect(%d, ..): using path '%s'\n", sockfd, sockaddr.sun_path);
+    DBG("connect(%d, ..): using path '%s'", sockfd, sockaddr.sun_path);
 
     if (real_connect(entry->orig_sockfd, (struct sockaddr *)&sockaddr,
                                          sizeof(sockaddr)) != 0) {
@@ -695,7 +688,7 @@ int getsockname(int sockfd, struct sockaddr *addr, socklen_t *addrlen) {
     static int (*real_getsockname)(int, struct sockaddr *, socklen_t *);
     LOAD_FUNCTION(real_getsockname, "getsockname");
 
-    DBG("getsockname(%d, ..)\n", sockfd);
+    DBG("getsockname(%d, ..)", sockfd);
 
     return real_getsockname(sockfd, addr, addrlen);
 }
@@ -704,7 +697,7 @@ int getpeername(int sockfd, struct sockaddr *addr, socklen_t *addrlen) {
     static int (*real_getpeername)(int, struct sockaddr *, socklen_t *);
     LOAD_FUNCTION(real_getpeername, "getpeername");
 
-    DBG("getpeername(%d, ..)\n", sockfd);
+    DBG("getpeername(%d, ..)", sockfd);
 
     return real_getpeername(sockfd, addr, addrlen);
 }
@@ -713,7 +706,7 @@ int getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optl
     static int (*real_getsockopt)(int, int, int, void *, socklen_t *);
     LOAD_FUNCTION(real_getsockopt, "getsockopt");
 
-    DBG("getsockopt(%d, %d %s, %d, ..)\n",
+    DBG("getsockopt(%d, %d %s, %d, ..)",
         sockfd, level, level_to_name(level), optname);
 
     return real_getsockopt(sockfd, level, optname, optval, optlen);
@@ -722,7 +715,7 @@ int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t
     static int (*real_setsockopt)(int, int, int, const void *, socklen_t);
     LOAD_FUNCTION(real_setsockopt, "setsockopt");
 
-    DBG("setsockopt(%d, %d %s, %d, ..)\n",
+    DBG("setsockopt(%d, %d %s, %d, ..)",
         sockfd, level, level_to_name(level), optname);
 
     return real_setsockopt(sockfd, level, optname, optval, optlen);