Log functions always write a trailing newline.

diff --git a/src/socket2unix.c b/src/socket2unix.c
index 693892d5c44c8190c2f5b39b38e0e89ef1cdf4d4..7e761c62db253b056e796de9c592763a71ea8aa1 100644 (file)
--- 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("");
 
         errno = saved_errno;
         perror("");

+        /* perror writes a newline. */
+    } else {
+        fprintf(stderr, "\n");

     }
 
     funlockfile(stderr);
     }
 
     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) {
 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] != '/') {
     }
     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;
 }
     }
     return path;
 }


@@ -257,14 +260,13 @@ static int get_options(void) {
             char option[length + 1];
             strncpy(option, pos, length);
             option[length] = '\0';
             char option[length + 1];
             strncpy(option, pos, length);
             option[length] = '\0';

-            ERROR("unknown option '%s' in SOCKET2UNIX_OPTIONS\n",
-                  option);
+            ERROR("unknown option '%s' in SOCKET2UNIX_OPTIONS", option);

         }
     }
 
     if ((options & OPTION_CLIENT_ONLY) && (options & OPTION_SERVER_ONLY)) {
         ERROR("conflicting options 'client_only', 'server_only' "
         }
     }
 
     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;
     }
 
     return options;


@@ -355,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))) {
                 && 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;
     }
 
         return -1;
     }
 


@@ -374,7 +376,7 @@ static int set_sockaddr_un(struct sockaddr_un *sockaddr,
     } else {
         af   = "unknown";
         port = 0;
     } 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);
     }
 
              af_to_name(addr->sa_family), addr->sa_family);
     }
 


@@ -425,7 +427,7 @@ int socket(int domain, int type, int protocol) {
         return sockfd;
     }
 
         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));
         af_to_name(domain), sock_to_name(type), protocol);
 
     struct list *entry = xmalloc(sizeof(*entry));


@@ -447,12 +449,12 @@ int close(int fd) {
 
     struct list *entry = remove_sockfd(fd);
     if (entry == NULL) {
 
     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);
 
         return real_close(fd);
     }
     assert(fd == entry->orig_sockfd);
 

-    DBG("close(%d)\n", fd);
+    DBG("close(%d)", fd);

     free(entry->orig_addr);
     free(entry);
 
     free(entry->orig_addr);
     free(entry);
 


@@ -471,11 +473,11 @@ int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
 
     struct list *entry = find_sockfd(sockfd);
     if (!entry) {
 
     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);
         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));
 
         sockfd,
         af_to_name(entry->orig_domain), sock_to_name(entry->orig_type));
 


@@ -496,17 +498,17 @@ int listen(int sockfd, int backlog) {
     }
 
     if (global_options & OPTION_CLIENT_ONLY) {
     }
 
     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) {
         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);
         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));
 
         sockfd, backlog,
         af_to_name(entry->orig_domain), sock_to_name(entry->orig_type));
 


@@ -518,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) {
     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) {
 
     int attempts = 0;
     while (attempts < 10) {


@@ -546,11 +548,11 @@ int listen(int sockfd, int backlog) {
         }
 
         if (!S_ISSOCK(buf.st_mode)) {
         }
 
         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);
         }
 
                   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);
         if (unlink(sockaddr.sun_path) != 0) {
             DIE("listen(%d, ..): unlink '%s' failed",
                 sockfd, sockaddr.sun_path);


@@ -560,7 +562,7 @@ int listen(int sockfd, int backlog) {
     }
 
     if (attempts == 10) {
     }
 
     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. */
     }
 
     /* Replace the original socket of the program with our socket. */


@@ -584,17 +586,17 @@ int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen) {
     }
 
     if (global_options & OPTION_CLIENT_ONLY) {
     }
 
     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) {
         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);
         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));
 
         sockfd,
         af_to_name(entry->orig_domain), sock_to_name(entry->orig_type));
 


@@ -609,7 +611,7 @@ int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen) {
     if (addr == NULL || addrlen == NULL) {
         return sock;
     }
     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);
 
     if (*addrlen < size) {
         WARN("accept(%d, ..): invalid addrlen from program", sockfd);


@@ -636,7 +638,7 @@ int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
     }
 
     if (global_options & OPTION_SERVER_ONLY) {
     }
 
     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);
     }
 
         return real_connect(sockfd, addr, addrlen);
     }
 


@@ -648,11 +650,11 @@ int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
 
     struct list *entry = find_sockfd(sockfd);
     if (!entry) {
 
     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);
         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));
 
         sockfd,
         af_to_name(entry->orig_domain), sock_to_name(entry->orig_type));
 


@@ -668,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) {
 
     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) {
 
     if (real_connect(entry->orig_sockfd, (struct sockaddr *)&sockaddr,
                                          sizeof(sockaddr)) != 0) {


@@ -686,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");
 
     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);
 }
 
     return real_getsockname(sockfd, addr, addrlen);
 }


@@ -695,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");
 
     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);
 }
 
     return real_getpeername(sockfd, addr, addrlen);
 }


@@ -704,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");
 
     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);
         sockfd, level, level_to_name(level), optname);
 
     return real_getsockopt(sockfd, level, optname, optval, optlen);


@@ -713,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");
 
     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);
         sockfd, level, level_to_name(level), optname);
 
     return real_setsockopt(sockfd, level, optname, optval, optlen);