[SCM] GNU Inetutils branch, master, updated. inetutils-1_9_1-77-g6dec6e1

[Mats Erik Andersson]

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "GNU Inetutils ".

The branch, master has been updated
       via  6dec6e1745be4386f3bc48ad6ca6df7e27100fe7 (commit)
       via  22a00b23073fe17a7b027b154b77e6da07a3d51c (commit)
       via  f730d11f7f578db86ec699c619f4a65e7ac60752 (commit)
      from  c76e1f1f0591a30a42d17bd7b18e1abd531b8d2a (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
http://git.savannah.gnu.org/cgit/inetutils.git/commit/?id=6dec6e1745be4386f3bc48ad6ca6df7e27100fe7


commit 6dec6e1745be4386f3bc48ad6ca6df7e27100fe7
Author: Mats Erik Andersson <address@hidden>
Date:   Fri Apr 20 03:54:17 2012 +0200

    rexec, rexecd: Implement support for IPv6.

diff --git a/ChangeLog b/ChangeLog
index 1d4e0da..e1aa06f 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,21 @@
+2012-04-20  Mats Erik Andersson  <address@hidden>
+
+       rexec, rexecd: Implement support for IPv6.
+
+       * src/rexec.c (options): New `-4/ipv4', `-6/ipv6', and `-a/ipany'.
+       (struct arguments): New member `int af'.
+       (parse_opt): Detect `4', `6', and `a'.
+       (do_rexec): New variables `ret', `addrlen', `hints', `ai', `res'.
+       New type `struct sockaddr_storage` for ADDR.  Removed `host'.
+       Replace gethostbyname() by getaddrinfo() in resolving host name.
+       (do_rexec) <use error stream>: Use `struct sockaddr_storage` for
+       SERV_ADDR and prepare bind() based on properties of ADDR.
+       * src/rexecd.c (main): Use `struct sockaddr_storage' for FROM.
+       (a_sin): Removed variable.
+       (doit): New signature `doit(int, struct sockaddr *, socklen_t)`
+       Change PORT to be `in_port_t'.  Remove call to bind().  Rewrite
+       preparations for connect() to detect address family.
+
 2012-04-19  Mats Erik Andersson  <address@hidden>
 
        Let `rexec' return a relevant return status.
diff --git a/src/rexec.c b/src/rexec.c
index b3eacbb..cbf7f7e 100644
--- a/src/rexec.c
+++ b/src/rexec.c
@@ -65,6 +65,9 @@ static struct argp_option options[] = {
   {"port",  'P', "port", 0, "Specify the port to connect to"},
   {"noerr", 'n', NULL, 0, "Disable the stderr stream"},
   {"error",  'e', "error", 0, "Specify a TCP port to use for stderr"},
+  {"ipv4",  '4', NULL, 0, "Use IPv4 address space."},
+  {"ipv6",  '6', NULL, 0, "Use IPv6 address space."},
+  {"ipany",  'a', NULL, 0, "Allow any address family. (default)"},
   { 0 }
 };
 
@@ -74,6 +77,7 @@ struct arguments
   const char *user;
   const char *password;
   const char *command;
+  int af;
   int port;
   int use_err;
   int err_port;
@@ -104,6 +108,15 @@ parse_opt (int key, char *arg, struct argp_state *state)
     case 'n':
       arguments->use_err = 0;
       break;
+    case '4':
+      arguments->af = AF_INET;
+      break;
+    case '6':
+      arguments->af = AF_INET6;
+      break;
+    case 'a':
+      arguments->af = AF_UNSPEC;
+      break;
     case ARGP_KEY_ARG:
       arguments->command = arg;
       state->next = state->argc;
@@ -131,6 +144,7 @@ main (int argc, char **argv)
   arguments.password = NULL;
   arguments.host = NULL;
   arguments.command = NULL;
+  arguments.af = AF_UNSPEC;
   arguments.err_port = 0;
   arguments.use_err = 1;
   arguments.port = 512;
@@ -181,35 +195,49 @@ do_rexec (struct arguments *arguments)
 {
   int err;
   char buffer[1024];
-  int sock;
-  char port_str[6];
-  struct sockaddr_in addr;
-  struct hostent *host;
+  int sock, ret;
+  char port_str[12];
+  socklen_t addrlen;
+  struct sockaddr_storage addr;
+  struct addrinfo hints, *ai, *res;
   int stdin_fd = STDIN_FILENO;
   int err_sock = -1;
 
-  sock = socket (AF_INET, SOCK_STREAM, 0);
-  if (sock < 0)
-    error (EXIT_FAILURE, errno, "cannot open socket");
-
-  host = gethostbyname (arguments->host);
-  if (host == NULL)
-    error (EXIT_FAILURE, errno, "cannot find host %s", arguments->host);
-
-  memset (&addr, 0, sizeof (addr));
-  addr.sin_family = AF_INET;
-  memmove ((caddr_t) &addr.sin_addr,
-#ifdef HAVE_STRUCT_HOSTENT_H_ADDR_LIST
-              host->h_addr_list[0],
-#else
-              host->h_addr,
-#endif
-              host->h_length);
+  snprintf (port_str, sizeof (port_str), "%d", arguments->port);
+
+  memset (&hints, 0, sizeof (hints));
+  hints.ai_family = arguments->af;
+  hints.ai_socktype = SOCK_STREAM;
+
+  ret = getaddrinfo (arguments->host, port_str, &hints, &res);
+  if (ret)
+    error (EXIT_FAILURE, errno, "getaddrinfo: %s", gai_strerror (ret));
+
+  for (ai = res; ai != NULL; ai = ai->ai_next)
+    {
+      sock = socket (ai->ai_family, ai->ai_socktype, ai->ai_protocol);
+      if (sock < 0)
+       continue;
+
+      if (connect (sock, ai->ai_addr, ai->ai_addrlen) < 0)
+       {
+         close (sock);
+         sock = -1;
+         continue;
+       }
+
+      break;   /* Acceptable.  */
+    }
 
-  addr.sin_port = htons ((short)arguments->port);
+  if (ai == NULL)
+    {
+      freeaddrinfo (res);
+      error (EXIT_FAILURE, errno, "cannot find host %s", arguments->host);
+    }
 
-  if (connect (sock, (struct sockaddr *) &addr, sizeof (addr)) < 0)
-    error (EXIT_FAILURE, errno, "cannot connect to the specified host");
+  addrlen = ai->ai_addrlen;
+  memcpy (&addr, ai->ai_addr, ai->ai_addrlen);
+  freeaddrinfo (res);
 
   if (!arguments->use_err)
     {
@@ -220,24 +248,42 @@ do_rexec (struct arguments *arguments)
     }
   else
     {
-      struct sockaddr_in serv_addr;
+      struct sockaddr_storage serv_addr;
       socklen_t len;
       int on = 1;
-      int serv_sock = socket (AF_INET, SOCK_STREAM, 0);
+      int serv_sock = socket (addr.ss_family, SOCK_STREAM, 0);
 
       if (serv_sock < 0)
         error (EXIT_FAILURE, errno, "cannot open socket");
 
+      setsockopt (serv_sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on));
+
       memset (&serv_addr, 0, sizeof (serv_addr));
 
-      serv_addr.sin_family = AF_INET;
+      /* Need to bind to explicit port, when err_port is non-zero,
+       * or to be assigned a free port, should err_port be naught.
+       */
+      switch (addr.ss_family)
+       {
+       case AF_INET:
 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
-      serv_addr.sin_len = sizeof (serv_addr);
+         ((struct sockaddr_in *) &serv_addr)->sin_len = addrlen;
 #endif
-      serv_addr.sin_port = arguments->err_port;
-      setsockopt (serv_sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on));
-      if (bind (serv_sock, (struct sockaddr *) &serv_addr,
-               sizeof (serv_addr)) < 0)
+         ((struct sockaddr_in *) &serv_addr)->sin_family = addr.ss_family;
+         ((struct sockaddr_in *) &serv_addr)->sin_port = arguments->err_port;
+         break;
+       case AF_INET6:
+#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
+         ((struct sockaddr_in6 *) &serv_addr)->sin6_len = addrlen;
+#endif
+         ((struct sockaddr_in6 *) &serv_addr)->sin6_family = addr.ss_family;
+         ((struct sockaddr_in6 *) &serv_addr)->sin6_port = arguments->err_port;
+         break;
+       default:
+         error (EXIT_FAILURE, EAFNOSUPPORT, "unknown address family");
+       }
+
+      if (bind (serv_sock, (struct sockaddr *) &serv_addr, addrlen) < 0)
         error (EXIT_FAILURE, errno, "cannot bind socket");
 
       len = sizeof (serv_addr);
@@ -247,8 +293,18 @@ do_rexec (struct arguments *arguments)
       if (listen (serv_sock, 1))
         error (EXIT_FAILURE, errno, "error listening on socket");
 
-      arguments->err_port = ntohs (serv_addr.sin_port);
-      sprintf (port_str, "%i", arguments->err_port);
+      switch (serv_addr.ss_family)
+       {
+       case AF_INET:
+         arguments->err_port = ntohs (((struct sockaddr_in *) 
&serv_addr)->sin_port);
+         break;
+       case AF_INET6:
+         arguments->err_port = ntohs (((struct sockaddr_in6 *) 
&serv_addr)->sin6_port);
+         break;
+       default:
+         error (EXIT_FAILURE, EAFNOSUPPORT, "unknown address family");
+       }
+      snprintf (port_str, sizeof (port_str), "%u", arguments->err_port);
       safe_write (sock, port_str, strlen (port_str) + 1);
 
       err_sock = accept (serv_sock, (struct sockaddr *) &serv_addr, &len);
diff --git a/src/rexecd.c b/src/rexecd.c
index db804d5..87b1098 100644
--- a/src/rexecd.c
+++ b/src/rexecd.c
@@ -84,7 +84,7 @@
 #include "libinetutils.h"
 
 void die (int code, const char *fmt, ...);
-int doit (int f, struct sockaddr_in *fromp);
+int doit (int f, struct sockaddr *fromp, socklen_t fromlen);
 
 const char doc[] = "remote execution daemon";
 
@@ -108,7 +108,7 @@ static struct argp argp = {
 int
 main (int argc, char **argv)
 {
-  struct sockaddr_in from;
+  struct sockaddr_storage from;
   socklen_t fromlen;
   int sockfd = STDIN_FILENO;
   int index;
@@ -123,7 +123,7 @@ main (int argc, char **argv)
   fromlen = sizeof (from);
   if (getpeername (sockfd, (struct sockaddr *) &from, &fromlen) < 0)
     error (EXIT_FAILURE, errno, "getpeername");
-  doit (sockfd, &from);
+  doit (sockfd, (struct sockaddr *) &from, fromlen);
   exit (EXIT_SUCCESS);
 }
 
@@ -137,12 +137,6 @@ char path[sizeof (PATH_DEFPATH) + sizeof ("PATH=")] = 
"PATH=";
 char *envinit[] = { homedir, shell, path, username, logname, NULL };
 extern char **environ;
 
-#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
-struct sockaddr_in a_sin = { sizeof (a_sin), AF_INET };
-#else
-struct sockaddr_in a_sin = { AF_INET };
-#endif
-
 char *getstr (const char *);
 
 static char *
@@ -158,13 +152,13 @@ get_user_password (struct passwd *pwd)
 }
 
 int
-doit (int f, struct sockaddr_in *fromp)
+doit (int f, struct sockaddr *fromp, socklen_t fromlen)
 {
   char *cmdbuf, *cp, *namep;
   char *user, *pass, *pw_password;
   struct passwd *pwd;
   int s;
-  unsigned short port;
+  in_port_t port;
   int pv[2], pid, cc;
   fd_set readfrom, ready;
   char buf[BUFSIZ], sig;
@@ -204,15 +198,23 @@ doit (int f, struct sockaddr_in *fromp)
   alarm (0);
   if (port != 0)
     {
-      s = socket (AF_INET, SOCK_STREAM, 0);
+      s = socket (fromp->sa_family, SOCK_STREAM, 0);
       if (s < 0)
        exit (EXIT_FAILURE);
       setsockopt (s, SOL_SOCKET, SO_REUSEADDR, &one, sizeof (one));
-      if (bind (s, (struct sockaddr *) &a_sin, sizeof (a_sin)) < 0)
-       exit (EXIT_FAILURE);
       alarm (60);
-      fromp->sin_port = htons (port);
-      if (connect (s, (struct sockaddr *) fromp, sizeof (*fromp)) < 0)
+      switch (fromp->sa_family)
+       {
+       case AF_INET:
+         ((struct sockaddr_in *) fromp)->sin_port = htons (port);
+         break;
+       case AF_INET6:
+         ((struct sockaddr_in6 *) fromp)->sin6_port = htons (port);
+         break;
+       default:
+         exit (EXIT_FAILURE);
+       }
+      if (connect (s, fromp, fromlen) < 0)
        exit (EXIT_FAILURE);
       alarm (0);
     }

http://git.savannah.gnu.org/cgit/inetutils.git/commit/?id=22a00b23073fe17a7b027b154b77e6da07a3d51c


commit 22a00b23073fe17a7b027b154b77e6da07a3d51c
Author: Mats Erik Andersson <address@hidden>
Date:   Thu Apr 19 23:23:40 2012 +0200

    rexec, rexecd: Reliability and exit codes.

diff --git a/ChangeLog b/ChangeLog
index b3eb406..1d4e0da 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,24 @@
+2012-04-19  Mats Erik Andersson  <address@hidden>
+
+       Let `rexec' return a relevant return status.
+
+       * src/rexec.c (remote_err): New variable.
+       (main): Return `remote_err' as status.
+       (do_rexec): New variable ON.  Set SO_REUSEADDR on SERV_SOCK.
+       (do_rexec) <while loop>: New variables CONSUMED and OFFSET.
+       Filter off initial bytes `\000' and `\001' appearing on either
+       of the sockets SOCK and ERR_SOCK, since these represent return
+       statuses and are now recorded in `remote_err'.
+
+       String storage sanitation and intelligible return codes.
+
+       * src/rexecd.c (username, logname, homedir, shell): Increase length.
+       (envinit): Use NULL as last member, not naught.
+       (doit): Set SO_REUSEADDR on socket S.  Use sizeof() to calculate
+       explicit offset in strncat() with environment variables.  Let
+       LOGNAME inherit the value from USER.
+       (doit, getstr) <die calls>: Use EXIT_FAILURE as first argument.
+
 2012-04-18  Mats Erik Andersson  <address@hidden>
 
        * src/rexec.c (do_exec): Set missing values for `sin_family' and
diff --git a/src/rexec.c b/src/rexec.c
index 6d83d0e..b3eacbb 100644
--- a/src/rexec.c
+++ b/src/rexec.c
@@ -116,6 +116,8 @@ static struct argp argp = {options, parse_opt, args_doc, 
doc};
 
 static void do_rexec (struct arguments *arguments);
 
+static int remote_err = EXIT_SUCCESS;
+
 int
 main (int argc, char **argv)
 {
@@ -164,7 +166,7 @@ main (int argc, char **argv)
 
   do_rexec (&arguments);
 
-  exit (EXIT_SUCCESS);
+  exit (remote_err);
 }
 
 static void
@@ -220,6 +222,7 @@ do_rexec (struct arguments *arguments)
     {
       struct sockaddr_in serv_addr;
       socklen_t len;
+      int on = 1;
       int serv_sock = socket (AF_INET, SOCK_STREAM, 0);
 
       if (serv_sock < 0)
@@ -232,6 +235,7 @@ do_rexec (struct arguments *arguments)
       serv_addr.sin_len = sizeof (serv_addr);
 #endif
       serv_addr.sin_port = arguments->err_port;
+      setsockopt (serv_sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on));
       if (bind (serv_sock, (struct sockaddr *) &serv_addr,
                sizeof (serv_addr)) < 0)
         error (EXIT_FAILURE, errno, "cannot bind socket");
@@ -262,7 +266,8 @@ do_rexec (struct arguments *arguments)
 
   while (1)
     {
-      int ret;
+      int consumed = 0;                /* Signals remote return status.  */
+      int ret, offset;
       fd_set rsocks;
 
       /* No other data to read.  */
@@ -314,8 +319,17 @@ do_rexec (struct arguments *arguments)
               continue;
             }
 
-          if (write (STDOUT_FILENO, buffer, err) < 0)
+         offset = 0;
+
+         if ((err > 0) && (consumed < 2))      /* Status can be two chars.  */
+           while ((err > offset) && (offset < 2)
+                  && (buffer[offset] == 0 || buffer[offset] == 1))
+             remote_err = buffer[offset++];
+
+          if (write (STDOUT_FILENO, buffer + offset, err - offset) < 0)
             error (EXIT_FAILURE, errno, "error writing");
+
+         consumed += err;
         }
 
      if (0 <= err_sock && FD_ISSET (err_sock, &rsocks))
@@ -332,8 +346,17 @@ do_rexec (struct arguments *arguments)
               continue;
             }
 
-          if (write (STDERR_FILENO, buffer, err) < 0)
+         offset = 0;
+
+         if ((err > 0) && (consumed < 2))      /* Status can be two chars.  */
+           while ((err > offset) && (offset < 2)
+                  && (buffer[offset] == 0 || buffer[offset] == 1))
+             remote_err = buffer[offset++];
+
+          if (write (STDERR_FILENO, buffer + offset, err - offset) < 0)
             error (EXIT_FAILURE, errno, "error writing to stderr");
+
+         consumed += err;
         }
     }
 }
diff --git a/src/rexecd.c b/src/rexecd.c
index a888c0f..db804d5 100644
--- a/src/rexecd.c
+++ b/src/rexecd.c
@@ -127,12 +127,14 @@ main (int argc, char **argv)
   exit (EXIT_SUCCESS);
 }
 
-char username[20] = "USER=";
-char logname[23] = "LOGNAME=";
-char homedir[64] = "HOME=";
-char shell[64] = "SHELL=";
+/* Set lengths of USER and LOGNAME longer than
+ * the REXEC protocol prescribes.  */
+char username[32 + sizeof ("USER=")] = "USER=";
+char logname[32 + sizeof ("LOGNAME=")] = "LOGNAME=";   /* Identical to USER.  
*/
+char homedir[256 + sizeof ("HOME=")] = "HOME=";
+char shell[256 + sizeof ("SHELL=")] = "SHELL=";
 char path[sizeof (PATH_DEFPATH) + sizeof ("PATH=")] = "PATH=";
-char *envinit[] = { homedir, shell, path, username, logname, 0 };
+char *envinit[] = { homedir, shell, path, username, logname, NULL };
 extern char **environ;
 
 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
@@ -205,6 +207,7 @@ doit (int f, struct sockaddr_in *fromp)
       s = socket (AF_INET, SOCK_STREAM, 0);
       if (s < 0)
        exit (EXIT_FAILURE);
+      setsockopt (s, SOL_SOCKET, SO_REUSEADDR, &one, sizeof (one));
       if (bind (s, (struct sockaddr *) &a_sin, sizeof (a_sin)) < 0)
        exit (EXIT_FAILURE);
       alarm (60);
@@ -221,7 +224,7 @@ doit (int f, struct sockaddr_in *fromp)
   setpwent ();
   pwd = getpwnam (user);
   if (pwd == NULL)
-    die (1, "Login incorrect.");
+    die (EXIT_FAILURE, "Login incorrect.");
 
   endpwent ();
   pw_password = get_user_password (pwd);
@@ -229,7 +232,7 @@ doit (int f, struct sockaddr_in *fromp)
     {
       namep = crypt (pass, pw_password);
       if (strcmp (namep, pw_password))
-       die (1, "Password incorrect.");
+       die (EXIT_FAILURE, "Password incorrect.");
     }
   write (STDERR_FILENO, "\0", 1);
   if (port)
@@ -237,7 +240,7 @@ doit (int f, struct sockaddr_in *fromp)
       pipe (pv);
       pid = fork ();
       if (pid == -1)
-       die (1, "Try again.");
+       die (EXIT_FAILURE, "Try again.");
 
       if (pid)
        {
@@ -303,12 +306,13 @@ doit (int f, struct sockaddr_in *fromp)
   if (setuid ((uid_t) pwd->pw_uid) < 0)
     error (EXIT_FAILURE, errno, "failed to set user-ID");
   if (chdir (pwd->pw_dir) < 0)
-    die (1, "No remote directory.");
+    die (EXIT_FAILURE, "No remote directory.");
   strcat (path, PATH_DEFPATH);
   environ = envinit;
-  strncat (homedir, pwd->pw_dir, sizeof (homedir) - 6);
-  strncat (shell, pwd->pw_shell, sizeof (shell) - 7);
-  strncat (username, pwd->pw_name, sizeof (username) - 6);
+  strncat (homedir, pwd->pw_dir, sizeof (homedir) - sizeof ("HOME=") - 1);
+  strncat (shell, pwd->pw_shell, sizeof (shell) - sizeof ("SHELL=") - 1);
+  strncat (username, pwd->pw_name, sizeof (username) - sizeof ("USER=") - 1);
+  strncat (logname, pwd->pw_name, sizeof (logname) - sizeof ("LOGNAME=") - 1);
   cp = strrchr (pwd->pw_shell, '/');
   if (cp)
     cp++;
@@ -345,7 +349,7 @@ getstr (const char *err)
   char *buf = malloc (buf_len), *end = buf;
 
   if (!buf)
-    die (1, "Out of space reading %s", err);
+    die (EXIT_FAILURE, "Out of space reading %s", err);
 
   do
     {
@@ -354,7 +358,7 @@ getstr (const char *err)
       if (rd <= 0)
        {
          if (rd == 0)
-           die (1, "EOF reading %s", err);
+           die (EXIT_FAILURE, "EOF reading %s", err);
          else
            error (EXIT_FAILURE, 0, "%s", err);
        }
@@ -367,7 +371,7 @@ getstr (const char *err)
          buf_len += buf_len;
          buf = realloc (buf, buf_len);
          if (!buf)
-           die (1, "Out of space reading %s", err);
+           die (EXIT_FAILURE, "Out of space reading %s", err);
          end = buf + end_offs;
        }
     }

http://git.savannah.gnu.org/cgit/inetutils.git/commit/?id=f730d11f7f578db86ec699c619f4a65e7ac60752


commit f730d11f7f578db86ec699c619f4a65e7ac60752
Author: Mats Erik Andersson <address@hidden>
Date:   Wed Apr 18 16:53:20 2012 +0200

    rexec, rexecd: Corrected functionality.

diff --git a/ChangeLog b/ChangeLog
index 8774399..b3eb406 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,10 @@
+2012-04-18  Mats Erik Andersson  <address@hidden>
+
+       * src/rexec.c (do_exec): Set missing values for `sin_family' and
+       `sin_len' in SERV_ADDR.
+       * src/rexecd.c (die): Use vsnprintf() for variadic lists!  Send
+       also final newline character.  Call exit() at the end!
+
 2012-04-13  Mats Erik Andersson  <address@hidden>
 
        Improve checking of FTP access verification.
diff --git a/src/rexec.c b/src/rexec.c
index 57d6aee..6d83d0e 100644
--- a/src/rexec.c
+++ b/src/rexec.c
@@ -227,6 +227,10 @@ do_rexec (struct arguments *arguments)
 
       memset (&serv_addr, 0, sizeof (serv_addr));
 
+      serv_addr.sin_family = AF_INET;
+#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
+      serv_addr.sin_len = sizeof (serv_addr);
+#endif
       serv_addr.sin_port = arguments->err_port;
       if (bind (serv_sock, (struct sockaddr *) &serv_addr,
                sizeof (serv_addr)) < 0)
diff --git a/src/rexecd.c b/src/rexecd.c
index d5a7fc7..a888c0f 100644
--- a/src/rexecd.c
+++ b/src/rexecd.c
@@ -329,12 +329,13 @@ die (int code, const char *fmt, ...)
 
   va_start (ap, fmt);
   buf[0] = 1;
-  n = snprintf (buf + 1, sizeof buf - 1, fmt, ap);
+  n = vsnprintf (buf + 1, sizeof buf - 1, fmt, ap);
   va_end (ap);
   if (n > sizeof buf - 1)
     n = sizeof buf - 1;
-  buf[n] = '\n';
+  buf[n++] = '\n';
   write (STDERR_FILENO, buf, n);
+  exit (code);
 }
 
 char *

-----------------------------------------------------------------------

Summary of changes:
 ChangeLog    |   46 +++++++++++++++++
 src/rexec.c  |  153 ++++++++++++++++++++++++++++++++++++++++++++-------------
 src/rexecd.c |   73 +++++++++++++++-------------
 3 files changed, 204 insertions(+), 68 deletions(-)


hooks/post-receive
-- 
GNU Inetutils