X-Git-Url: https://ruderich.org/simon/gitweb/?p=socket2unix%2Fsocket2unix.git;a=blobdiff_plain;f=src%2Fsocket2unix.c;h=7e761c62db253b056e796de9c592763a71ea8aa1;hp=12f03f56dd2654ed8fe767b17101f8b8110422c5;hb=a452581cde874113f833e590cd6765413dba81c0;hpb=f1c354120d8c23511e28edc0ddf0bdaefbe70e5a

diff --git a/src/socket2unix.c b/src/socket2unix.c
index 12f03f5..7e761c6 100644
--- a/src/socket2unix.c
+++ b/src/socket2unix.c
@@ -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;
     }
 
@@ -377,7 +376,7 @@ static int set_sockaddr_un(struct sockaddr_un *sockaddr,
     } 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));
@@ -450,12 +449,12 @@ int close(int 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)\n", fd);
+    DBG("close(%d)", fd);
     free(entry->orig_addr);
     free(entry);
 
@@ -474,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));
 
@@ -499,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));
 
@@ -521,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) {
@@ -549,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);
@@ -563,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. */
@@ -587,17 +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);
     }
 
     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));
 
@@ -612,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);
@@ -639,7 +638,7 @@ 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);
     }
 
@@ -651,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));
 
@@ -671,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) {
@@ -689,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);
 }
@@ -698,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);
 }
@@ -707,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);
@@ -716,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);