Changeset 481 for trunk/src/sh_socket.c

Timestamp:

Jul 18, 2015, 5:06:52 PM (9 years ago)

Author:

katerina

Message:

Enhancements and fixes for tickets #374, #375, #376, #377, #378, and #379.

File:

• trunk/src/sh_socket.c (modified) (37 diffs)

trunk/src/sh_socket.c

@@ -33 +33 @@
 #include <string.h>
 
+#if TIME_WITH_SYS_TIME
+#include <sys/time.h>
+#include <time.h>
+#else
+#if HAVE_SYS_TIME_H
+#include <sys/time.h>
+#else
+#include <time.h>
+#endif
+#endif
+
 #include "samhain.h"
 #include "sh_socket.h"
@@ -38 +49 @@
 #include "sh_unix.h"
 #include "sh_calls.h"
+#include "sh_guid.h"
+#include "sh_fifo.h"
+#include "sh_utils.h"
 
 #undef  FIL__
@@ -46 +60 @@
 #include <signal.h>
 
+typedef struct delta_tofetch {
+  char            uuid[SH_UUID_BUF];
+  time_t          last_time;
+  unsigned int    count;
+} SH_DELTA_DB;
+
+static SH_DELTA_DB * parse_entry(SH_DELTA_DB * db, const char * str)
+{
+  long last_time;
+  unsigned int count;
+  char buf[SH_UUID_BUF];
+  int res = sscanf(str, _("%u:%ld:%36s"), &count, &last_time, buf);
+  if (res == 3)
+    {
+      db->count = count;
+      db->last_time  = (time_t) last_time;
+      sl_strlcpy(db->uuid, buf, SH_UUID_BUF);
+      return db;
+    }
+  return NULL;
+}
+
+static char * unparse_entry(const SH_DELTA_DB * db, char * str, size_t len)
+{
+  int nbytes = sl_snprintf(str, len, _("%u:%ld:%s"), 
+                           db->count, (long) db->last_time, db->uuid);
+  if (nbytes < 0 || nbytes >= (int) len)
+    return NULL;
+  return str;
+}
+
+static SH_FIFO xfifo = SH_FIFO_INITIALIZER;
+
+int sh_socket_store_uuid(const char * cmd)
+{
+  char * p = sh_util_strdup(cmd);
+  char * q = strchr(cmd, ':');
+  char   entry[SH_BUFSIZE];
+  SH_DELTA_DB db;
+
+  if (!q) { SH_FREE(p); return -1; }
+
+  ++q;
+
+  if (0 != sh_uuid_check(q)) { SH_FREE(p); return -1; }
+
+  db.count = 0;
+  db.last_time = (time_t) 0;
+  sl_strlcpy(db.uuid, q, SH_UUID_BUF);
+  SH_FREE(p);
+
+  if (NULL != unparse_entry(&db, entry, sizeof(entry)))
+    {
+      sh_fifo_push(&xfifo, entry);
+      return 0;
+    }
+  return -1;
+}
+
+static unsigned int try_interval = 60;
+static unsigned int try_max = 2;
+
+int set_delta_retry_interval(const char * str)
+{
+  long val = strtol (str, (char **)NULL, 10);
+
+  if (val < 0 || val > INT_MAX)
+    return -1;
+  try_interval = (unsigned int) val;
+  return 0;
+}
+int set_delta_retry_count(const char * str)
+{
+  long val = strtol (str, (char **)NULL, 10);
+
+  if (val < 0 || val > INT_MAX)
+    return -1;
+  try_max = (unsigned int) val;
+  return 0;
+}
+
+char * sh_socket_get_uuid(int * errflag, unsigned int * count, time_t * last)
+{
+  char * entry = sh_fifo_pop(&xfifo);
+  char * uuid = NULL;
+
+  if (entry)
+    {
+      SH_DELTA_DB db;
+      time_t      now;
+      
+      if (NULL == parse_entry(&db, entry))
+        {
+          SH_FREE(entry);
+          sh_error_handle(SH_ERR_WARN, FIL__, __LINE__, 0, MSG_E_SUBGEN,
+                          _("Bad entry in fifo"), 
+                          _("sh_socket_get_uuid"));
+          *errflag = -1;
+          return NULL;
+        }
+
+      now = time(NULL);
+
+      if ( (db.count > 0) && ((unsigned long)(now - db.last_time) < try_interval) )
+        {
+          sh_fifo_push_tail(&xfifo, entry);
+          SH_FREE(entry);
+          *errflag = -1;
+          return NULL;
+        }
+
+      SH_FREE(entry);
+      uuid   = sh_util_strdup(db.uuid);
+      *count = db.count;
+      *last  = db.last_time;
+    }
+
+  *errflag = 0;
+  return uuid;
+}
+
+int sh_socket_return_uuid (const char * uuid, unsigned int count, time_t last)
+{
+  (void) last;
+
+  if (count < try_max)
+    {
+      char   entry[SH_BUFSIZE];
+      SH_DELTA_DB db;
+      time_t now = time(NULL);
+
+      db.count     = count + 1;
+      db.last_time = now;
+      sl_strlcpy(db.uuid, uuid, SH_UUID_BUF);
+
+      if (NULL != unparse_entry(&db, entry, sizeof(entry)))
+        return sh_fifo_push_tail(&xfifo, entry); /* >0 for success */
+    }
+  return -1;
+}
+
 void sh_socket_server_cmd(const char * srvcmd)
 {
@@ -54 +209 @@
       SL_RET0(_("sh_socket_server_cmd"));
     }
-  if ((srvcmd[0] == 'S') && (srvcmd[1] == 'T') && 
-      (srvcmd[2] == 'O') && (srvcmd[3] == 'P'))
+
+  if (0 == strncmp(srvcmd, _("STOP"), 4))
     {
       TPT((0, FIL__, __LINE__, _("msg=<stop command from server>\n")));
@@ -65 +220 @@
 #endif
     } 
-  else if ((srvcmd[0] == 'R') && (srvcmd[1] == 'E') &&
-           (srvcmd[2] == 'L') && (srvcmd[3] == 'O') &&
-           (srvcmd[4] == 'A') && (srvcmd[5] == 'D'))
+
+  else if (0 == strncmp(srvcmd, _("RELOAD"), 6))
     {
       TPT((0, FIL__, __LINE__, _("msg=<reload command from server>\n")));
@@ -77 +231 @@
 #endif
     }
-  else if ((srvcmd[0] == 'S') && (srvcmd[1] == 'C') &&
-           (srvcmd[2] == 'A') && (srvcmd[3] == 'N'))
+
+  else if (0 == strncmp(srvcmd, _("DELTA:"), 6))
+    {
+      TPT((0, FIL__, __LINE__, _("msg=<delta load command from server>\n")));
+
+      if (sh_socket_store_uuid(srvcmd) == 0)
+        {
+          ++sh_load_delta_flag;
+          ++sig_raised;
+        }
+    }
+
+  else if (0 == strncmp(srvcmd, _("SCAN"), 4))
     {
       TPT((0, FIL__, __LINE__, _("msg=<scan command from server>\n")));
-      if (sh.flag.isdaemon == ON) 
+      if (sh.flag.isdaemon == S_TRUE) 
         { 
 #ifdef SIGTTOU
@@ -96 +261 @@
         }
     }
+
+  /* Unknown command 
+   */
   else
     {
-      sh_error_handle(SH_ERR_INFO, FIL__, __LINE__, 0, MSG_E_SUBGEN,
+      sh_error_handle(SH_ERR_WARN, FIL__, __LINE__, 0, MSG_E_SUBGEN,
                       srvcmd, 
                       _("sh_socket_server_cmd"));
@@ -104 +272 @@
   SL_RET0(_("sh_socket_server_cmd"));
 }
-/* #if defined (SH_WITH_CLIENT)
- */
-#endif
+#endif  /* #if defined (SH_WITH_CLIENT) */
 
 #if defined(SH_WITH_SERVER)
@@ -225 +391 @@
   struct stat buf;
 
-#ifdef SH_DEBUG_SOCKET
-  fprintf(stderr, "PROBE\n");
-#endif
-
   for (item = (client_t *) zAVLFirst(&avlcursor, all_clients); item;
        item = (client_t *) zAVLNext(&avlcursor))
     {
-#ifdef SH_DEBUG_SOCKET
-      fprintf(stderr, "%s %d\n", item->hostname, (int)item->status_now);
-#endif
-
       if (item->status_now != CLT_INACTIVE)
         {
@@ -242 +400 @@
           file = get_client_conf_file (item->hostname, &dummy);
 
-#ifdef SH_DEBUG_SOCKET
-          fprintf(stderr, "%s\n", file);
-#endif
           if (0 == stat (file, &buf))
             {
@@ -250 +405 @@
               while (new)
                 {
-#ifdef SH_DEBUG_SOCKET
-                  fprintf(stderr, "%s <> %s\n", new->clt, item->hostname);
-#endif
                   if (0 == sl_strcmp(new->clt, item->hostname))
                     {
                       flag = 1; /* Client is in list already */
 
-#ifdef SH_DEBUG_SOCKET
-                      fprintf(stderr, "%lu <> %lu\n", 
-                              (unsigned long) buf.st_mtime, 
-                              (unsigned long)new->cti);
-#endif
                       if (buf.st_mtime > new->cti)
                         {
@@ -368 +515 @@
 
 #define NEED_PASSWORD_AUTH
-
 #endif
 
@@ -540 +686 @@
   SL_RETURN( (0), _("sh_socket_open_int"));
 }
-/* #if !defined(HAVE_CMSGCRED) || !defined(SO_PEERCRED) */
-/* #endif */
-
-/*
-#if !defined(HAVE_GETPEEREID) && !defined(SO_PEERCRED) && !defined(HAVE_STRUCT_CMSGCRED) && !defined(HAVE_STRUCT_FCRED) && !(defined(HAVE_STRUCT_SOCKCRED) && defined(LOCAL_CREDS))
-static 
-int sh_socket_read (struct socket_cmd * srvcmd)
-{
-  srvcmd->cmd[0] = '\0';
-  srvcmd->clt[0] = '\0';
-  return 0;
-}
-#else
-*/
+
 
 /*
@@ -582 +715 @@
  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  */
-static 
-int sh_socket_read (struct socket_cmd * srvcmd)
-{
-  struct socket_cmd * list_cmd;
-  char message[SH_MAXMSG];
-  struct sockaddr_un name;
-  ACCEPT_TYPE_ARG3 size = sizeof(name);
-
+
+static int receive_message(int talkfd, struct msghdr * msg, size_t message_size)
+{
+  unsigned int retry = 0;
   int nbytes;
-  int talkfd;
-  int retry = 0;
-
-  char * cmd = NULL;
-  char * clt = NULL;
-
-  int  client_uid = -1;
+  char * message = msg->msg_iov->iov_base;
   char errbuf[SH_ERRBUF_SIZE];
 
-
-  struct msghdr msg;
-  struct iovec iov;
-
-#if defined(NEED_PASSWORD_AUTH)
-  char * eopw = NULL;
-  char * goodpassword = NULL;
-#endif
-
-#if defined(HAVE_GETPEEREID)
-  uid_t peer_uid;
-  gid_t peer_gid;
-#elif defined(SO_PEERCRED) 
-  struct ucred cr;
-#ifdef HAVE_SOCKLEN_T
-  socklen_t cl = sizeof(cr);
-#else
-  int       cl = sizeof(cr);
-#endif 
-
-#elif defined(HAVE_STRUCT_CMSGCRED) || defined(HAVE_STRUCT_FCRED) || (defined(HAVE_STRUCT_SOCKCRED) && defined(LOCAL_CREDS))
-
-#ifdef HAVE_STRUCT_CMSGCRED
-  typedef struct cmsgcred Cred;
-#define CRED_UID cmcred_uid 
-
-#elif HAVE_STRUCT_FCRED
-  typedef struct fcred Cred;
-#define CRED_UID fc_uid 
-
-#elif HAVE_STRUCT_SOCKCRED
-  typedef struct sockcred Cred;
-#define CRED_UID sc_uid 
-
-#endif
-  Cred       *cred;
-
-  /* Compute size without padding */
-  char   cmsgmem[ALIGN(sizeof(struct cmsghdr)) + ALIGN(sizeof(Cred))];   
-  /* for NetBSD */
-
-  /* Point to start of first structure */
-  struct cmsghdr *cmsg = (struct cmsghdr *) cmsgmem;
-#endif
-
-  if (pf_unix_fd  < 0)
-    {
-      return 0;
-    }
-
-  iov.iov_base = (char *) &message;
-  iov.iov_len  = sizeof(message);
-
-  memset (&msg, 0, sizeof (msg));
-  msg.msg_iov = &iov;
-  msg.msg_iovlen = 1;
-
-#if !defined(SO_PEERCRED) && !defined(HAVE_GETPEEREID)
-#if defined(HAVE_STRUCT_CMSGCRED) || defined(HAVE_STRUCT_FCRED) || (defined(HAVE_STRUCT_SOCKCRED) && defined(LOCAL_CREDS))
-  msg.msg_control = (char *) cmsg;
-  msg.msg_controllen = sizeof (cmsgmem);
-  memset (cmsg, 0, sizeof (cmsgmem));
-#endif
-#endif
-
-  /* the socket is non-blocking 
-   * 'name' is the address of the sender socket
-   */
   do {
-    talkfd = accept(pf_unix_fd, (struct sockaddr *) &name, &size);
-  } while (talkfd < 0 && errno == EINTR);
-
-  if ((talkfd < 0) && (errno == EAGAIN))
-    {
-      return 0;
-    }
-  else if (talkfd < 0)
-    {
-      sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
-                      sh_error_message (errno, errbuf, sizeof(errbuf)), 
-                      _("sh_socket_read: accept"));
-      return -1;
-    }
-
-
-#if defined(LOCAL_CREDS) && !defined(SO_PEERCRED) && !defined(HAVE_GETPEEREID)
-  /* Set the socket to receive credentials on the next message 
-   */
-  {
-    int on = 1;
-    if (setsockopt (talkfd, 0, LOCAL_CREDS, &on, sizeof (on)) < 0)
-      {
-        sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
-                        sh_error_message (errno, errbuf, sizeof(errbuf)), 
-                        _("sh_socket_read: setsockopt"));
-        sl_close_fd(FIL__, __LINE__, talkfd);
-        return -1;
-      }
-  }
-#endif
-
-  do {
-    nbytes = recvmsg (talkfd, &msg, 0);
+    nbytes = recvmsg (talkfd, msg, 0);
     if ((nbytes < 0) && (errno != EAGAIN))
       {
@@ -718 +740 @@
   } while ((nbytes < 0) && (retry < 3));
 
-#ifdef SH_DEBUG_SOCKET
-  fprintf(stderr, "%d bytes received\n", nbytes);
-#endif
-
   /* msg.msg_iov.iov_base, filled by recvmsg
    */
-  message[sizeof(message)-1] = '\0';
+  message[message_size-1] = '\0';
 
   if (nbytes < 0)
@@ -731 +749 @@
         {
           /* no data */
+          sh_error_handle(SH_ERR_ALL, FIL__, __LINE__, errno, MSG_E_SUBGEN,
+                          sh_error_message (errno, errbuf, sizeof(errbuf)), 
+                          _("sh_socket_read: recvfrom"));
           sl_close_fd(FIL__, __LINE__, talkfd);
           return 0;
@@ -740 +761 @@
       return -1;
     }
+  return 0;
+}
 
 #if defined(HAVE_GETPEEREID)
+
+static int get_peer_uid(int talkfd)
+{
+  uid_t peer_uid;
+  gid_t peer_gid;
+  char errbuf[SH_ERRBUF_SIZE];
+
   if (0 != getpeereid(talkfd, &peer_uid, &peer_gid))
     {
@@ -750 +780 @@
       return -1;
     }
-  client_uid = peer_uid;
-  cmd = message;
-#elif defined(SO_PEERCRED)
+  return peer_uid;
+}
+
+#elif defined(SO_PEERCRED) 
+
+static int get_peer_uid(int talkfd)
+{
+  char errbuf[SH_ERRBUF_SIZE];
+  struct ucred cr;
+#ifdef HAVE_SOCKLEN_T
+  socklen_t cl = sizeof(cr);
+#else
+  int       cl = sizeof(cr);
+#endif 
+
   if (0 != getsockopt(talkfd, SOL_SOCKET, SO_PEERCRED, &cr, &cl))
     {
@@ -761 +803 @@
       return -1;
     }
-  client_uid = cr.uid;
-  cmd = message;
-#elif defined(HAVE_STRUCT_CMSGCRED) || defined(HAVE_STRUCT_FCRED) || (defined(HAVE_STRUCT_SOCKCRED) && defined(LOCAL_CREDS))
-  if (cmsg->cmsg_len < sizeof (cmsgmem) || cmsg->cmsg_type != SCM_CREDS)
-    {
-      sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
-                      _("Message from recvmsg() was not SCM_CREDS"), 
-                      _("sh_socket_read"));
-
-      /* Check for file descriptors sent using SCM_RIGHTS, and
-       * close them. If MSG_CTRUNC is set, the buffer was too small,
-       * and no fds are duped.
-       */
-      if (msg.msg_controllen >= sizeof(struct cmsghdr) &&
-          (msg.msg_flags & MSG_CTRUNC) == 0)
-        {
-          unsigned int     data_size;
-          unsigned int     data_i;
-          int              fdcount, fdmax;
-          struct cmsghdr * cmptr;
-          int              fdsbuf[1 + (sizeof(cmsgmem)/sizeof(int))];
-
-          for (cmptr = CMSG_FIRSTHDR(&msg); cmptr != NULL;
-               cmptr = CMSG_NXTHDR(&msg, cmptr)) 
-            {
-              if (cmptr->cmsg_len > sizeof (cmsgmem) || 
-                  cmptr->cmsg_level != SOL_SOCKET ||
-                  cmptr->cmsg_type  != SCM_RIGHTS)
-                continue;
-
-              /* Crappy way of finding the data length.
-               * cmptr->cmsg_len includes both header and padding,
-               * how are you supposed to find the data length?
-               * cmptr->cmsg_len - ALIGN(sizeof(struct cmsghdr)) ?
-               */
-              data_size = 0;
-
-              for (data_i = 0; data_i < cmptr->cmsg_len; ++data_i)
-                {
-                  if (CMSG_LEN(data_i) == cmptr->cmsg_len)
-                    {
-                      data_size = data_i;
-                      break;
-                    }
-                }
-              memcpy(fdsbuf, CMSG_DATA(cmptr), data_size);
-              fdmax = data_size / sizeof(int);
-              for (fdcount = 0; fdcount < fdmax; ++fdcount)
-                (void) sl_close_fd(FIL__, __LINE__, fdsbuf[fdcount]);
-            }
-        }
-      
-      sl_close_fd(FIL__, __LINE__, talkfd);
-      return -1;
-    }
-  cred = (Cred *) CMSG_DATA (cmsg);
-  client_uid = cred->CRED_UID;
-  cmd = message;
-#elif defined(NEED_PASSWORD_AUTH)
+  return cr.uid;
+}
+
+#endif
+
+#if defined(NEED_PASSWORD_AUTH)
+char * check_password(char * message, int * client_uid, int talkfd)
+{
+  char * cmd = NULL;
+  char * eopw = NULL;
+  char * goodpassword = NULL;
+
   goodpassword = sh_get_sockpass();
   eopw = strchr(message, '@');
@@ -830 +825 @@
       strlen(goodpassword) < (sizeof(message)/2))
     {
-      client_uid = sh_socket_flaguid;
+      *client_uid = sh_socket_flaguid;
       cmd = &message[strlen(goodpassword)+1];
       sh_set_sockpass();
@@ -841 +836 @@
       sh_set_sockpass();
       sl_close_fd(FIL__, __LINE__, talkfd);
+      return NULL;
+    }
+  return cmd;
+}
+#endif
+
+static int list_all (int talkfd, char * cmd);
+static int process_message(int talkfd, char * cmd, struct socket_cmd * srvcmd);
+
+static 
+int sh_socket_read (struct socket_cmd * srvcmd)
+{
+  char message[SH_MAXMSG];
+  struct sockaddr_un name;
+  ACCEPT_TYPE_ARG3 size = sizeof(name);
+  int talkfd;
+  char * cmd = NULL;
+  int  client_uid = -1;
+  char errbuf[SH_ERRBUF_SIZE];
+  struct msghdr msg;
+  struct iovec iov;
+  int status;
+
+  if (pf_unix_fd  < 0)
+    return 0;
+
+  iov.iov_base = (char *) &message;
+  iov.iov_len  = sizeof(message);
+
+  memset (&msg, 0, sizeof (msg));
+  msg.msg_iov = &iov;
+  msg.msg_iovlen = 1;
+
+  /* the socket is non-blocking 
+   * 'name' is the address of the sender socket
+   */
+  do {
+    talkfd = accept(pf_unix_fd, (struct sockaddr *) &name, &size);
+  } while (talkfd < 0 && errno == EINTR);
+
+  if ((talkfd < 0) && (errno == EAGAIN))
+    {
+      return 0;
+    }
+  else if (talkfd < 0)
+    {
+      sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
+                      sh_error_message (errno, errbuf, sizeof(errbuf)), 
+                      _("sh_socket_read: accept"));
       return -1;
     }
+
+  if (receive_message(talkfd, &msg, sizeof(message)) < 0)
+    return -1;
+
+  /* Authenticate request by peer uid or password.
+   */
+#if defined(HAVE_GETPEEREID)
+  client_uid = get_peer_uid(talkfd);
+  cmd = message;
+
+#elif defined(SO_PEERCRED)
+  client_uid = get_peer_uid(talkfd);
+  cmd = message;
+
+#elif defined(NEED_PASSWORD_AUTH)
+  cmd = check_password(message, &client_uid, talkfd);
+
 #else
   sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
@@ -851 +912 @@
 #endif
 
-#ifdef SH_DEBUG_SOCKET
-  fprintf(stderr, "Peer uid=%d, required=%d\n",
-          client_uid, sh_socket_flaguid);
-#endif
-
   if (client_uid != sh_socket_flaguid)
     {
@@ -865 +921 @@
     }
 
-
-  /* Give a diagnostic message. 
-   */
-#ifdef SH_DEBUG_SOCKET
-  fprintf (stderr, "Server: got message: %s\n", cmd);
-#endif
-
-  clt = strchr(cmd, ':');
+  status = process_message(talkfd, cmd, srvcmd);
+
+  sl_close_fd(FIL__, __LINE__, talkfd);
+  return status;
+}
+
+static int check_valid_command(const char * str)
+{
+  unsigned int i = 0;
+  char * commands[] = { N_("DELTA"),  N_("RELOAD"),  N_("STOP"), N_("SCAN"),
+                        N_("CANCEL"), N_("LISTALL"), N_("LIST"), N_("PROBE"), NULL };
+
+  while (commands[i])
+    {
+      if (0 == strcmp(_(commands[i]), str))
+        {
+          return 0;
+        }
+      ++i;
+    }
+  return -1;
+}
+
+static int send_reply (int fd, char * msg)
+{
+  int nbytes = send (fd, msg, strlen(msg) + 1, 0);
+
+  if (nbytes < 0)
+    {
+      char errbuf[SH_ERRBUF_SIZE];
+      sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
+                      sh_error_message (errno, errbuf, sizeof(errbuf)), 
+                      _("send_reply"));
+      return -1;
+    }
+
+  return nbytes;
+}
+
+static int process_message(int talkfd, char * cmd, struct socket_cmd * srvcmd)
+{
+  int nbytes;
+  char error_type[SH_ERRBUF_SIZE] = { '\0' };
+  char * clt  = (cmd) ? strchr(cmd, ':') : NULL;
+
+  if (clt && 0 == strncmp(cmd, _("DELTA:"), 6))
+    {
+      /* DELTA:uuid:hostname 
+       */
+      char * uuid = clt;
+      
+      *uuid = '\0'; ++uuid;
+      clt = strchr(uuid, ':');
+      if (clt) { *clt = '\0'; ++clt; }
+      
+      if (sh_uuid_check(uuid) < 0)
+        {
+          sl_strlcpy(error_type, _("!E:uuid-format:"), sizeof(error_type));
+          sl_strlcat(error_type, uuid, sizeof(error_type));
+          clt = NULL;
+        }
+      
+      --uuid; *uuid = ':';
+    }
+  else if (clt && *clt == ':')
+    { 
+      *clt = '\0'; ++clt; 
+      if (check_valid_command(cmd) < 0)
+        {
+          sl_strlcpy(error_type, _("!E:cmd-invalid:"), sizeof(error_type));
+          sl_strlcat(error_type, cmd, sizeof(error_type));
+          clt = NULL;
+        }
+    }
+    
   if (clt != NULL) 
     {
-      *clt = '\0'; ++clt;
       if (sl_strlen(cmd) >= SH_MAXMSGLEN)
         {
-#ifdef SH_DEBUG_SOCKET
-          fprintf (stderr, "Server: command too long: %s\n", cmd);
-#endif
           sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
                           _("Bad message format: command too long"), 
                           _("sh_socket_read"));
-          sl_close_fd(FIL__, __LINE__, talkfd);
+          sl_strlcpy(error_type, _("!E:cmd-toolong"), sizeof(error_type));
+          send_reply(talkfd, error_type);
           return -1;
         }
       else if (sl_strlen(clt) >= SH_MAXMSGLEN)
         {
-#ifdef SH_DEBUG_SOCKET
-          fprintf (stderr, "Server: hostname too long: %s\n", clt);
-#endif
           sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
                           _("Bad message format: hostname too long"), 
                           _("sh_socket_read"));
-          sl_close_fd(FIL__, __LINE__, talkfd);
+          sl_strlcpy(error_type, _("!E:hostname-toolong"), sizeof(error_type));
+          send_reply(talkfd, error_type);
           return -1;
         }
-      if (cmd[0] == 'L' && cmd[1] == 'I' &&
-          cmd[2] == 'S' && cmd[3] == 'T')
-        {
-#ifdef SH_DEBUG_SOCKET
-          fprintf (stderr, "Server: list %s\n", clt);
-#endif
-          goto list_all;
-        }
-      else if (cmd[0] == 'P' && cmd[1] == 'R' &&
-          cmd[2] == 'O' && cmd[3] == 'B' && cmd[4] == 'E')
-        {
-#ifdef SH_DEBUG_SOCKET
-          fprintf (stderr, "Server: probe start %s\n", clt);
-#endif
+
+      if (0 == strncmp(cmd, _("LIST"), 4))
+        return list_all(talkfd, cmd);
+      else if (0 == strncmp(cmd, _("PROBE"), 4))
+        {
           sh_socket_probe4reload();
-#ifdef SH_DEBUG_SOCKET
-          fprintf (stderr, "Server: probe done  %s\n", clt);
-#endif
-          cmd[0] = 'L'; cmd[1] = 'I'; cmd[2] = 'S'; cmd[3] = 'T';cmd[4] = '\0';
-          goto list_all;
-        }
+          sl_strlcpy(cmd, _("LIST"), 5);
+          return list_all(talkfd, cmd);
+        }
+
       sl_strlcpy (srvcmd->cmd, cmd, SH_MAXMSGLEN);
       sl_strlcpy (srvcmd->clt, clt, SH_MAXMSGLEN);
@@ -925 +1032 @@
   else
     {
-#ifdef SH_DEBUG_SOCKET
-      fprintf (stderr, "Server: bad message\n");
-#endif
       sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
                       _("Bad message format"), 
                       _("sh_socket_read"));
-      sl_close_fd(FIL__, __LINE__, talkfd);
+      if (error_type[0] == '\0')
+        sl_strlcpy(error_type, _("!E:message-format"), sizeof(error_type));
+      send_reply(talkfd, error_type);
       return -1;
     }
 
   /* Bounce the message back to the sender. 
-   * 'name' is the receiver address; it has been been filled
-   *        with the sender address in the recvfrom call 
    */
-#ifdef SH_DEBUG_SOCKET
-  fprintf (stderr, "Server: send message: %s to %s\n", 
-           cmd, name.sun_path);
-#endif
-  /*
-  nbytes = sendto (pf_unix_fd, message, nbytes, 0,
-                       (struct sockaddr *) & name, size);
-  */
-  nbytes = send (talkfd, cmd, strlen(cmd) + 1, 0);
-  sl_close_fd(FIL__, __LINE__, talkfd);
-  if (nbytes < 0)
-    {
-      sh_error_handle((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
-                      sh_error_message (errno, errbuf, sizeof(errbuf)), 
-                      _("sh_socket_read: send"));
-      return -1;
-    }
-#ifdef SH_DEBUG_SOCKET
-  fprintf (stderr, "Server: message is out\n");
-#endif
+  nbytes = send_reply(talkfd, cmd);
+
   return nbytes;
-
- list_all:
-#ifdef SH_DEBUG_SOCKET
-  fprintf (stderr, "Server: list all\n");
-#endif
-  if (cmd[4] == 'A' && cmd[5] == 'L' && cmd[6] == 'L')
+}
+
+static int list_all (int talkfd, char * cmd)
+{
+  int nbytes;
+  struct socket_cmd * list_cmd;
+  char message[SH_MAXMSG];
+  char errbuf[SH_ERRBUF_SIZE];
+
+  if (0 == strncmp(cmd, _("LISTALL"), 7))
     {
       list_cmd = runlist;
       while (list_cmd)
         {
-          sl_snprintf(message, sizeof(message), _("SENT  %8s  %32s  %s"),
+          sl_snprintf(message, sizeof(message), _("SENT  %42s  %32s  %s"),
                       list_cmd->cmd, list_cmd->clt, list_cmd->cti);
-          /*
-          sl_strlcpy(message,     _("DONE"), SH_MAXMSG);
-          sl_strlcat(message,          "  ", SH_MAXMSG);
-          sl_strlcat(message, list_cmd->cmd, SH_MAXMSG);
-          sl_strlcat(message,          "  ", SH_MAXMSG);
-          sl_strlcat(message, list_cmd->clt, SH_MAXMSG);
-          sl_strlcat(message,          "  ", SH_MAXMSG);
-          sl_strlcat(message, list_cmd->cti, SH_MAXMSG);
-          */
+
           nbytes = send (talkfd, message, sl_strlen(message) + 1, 0);
           if (nbytes < 0)
@@ -987 +1069 @@
                               sh_error_message (errno, errbuf, sizeof(errbuf)), 
                               _("sh_socket_read: sendto"));
-              sl_close_fd(FIL__, __LINE__, talkfd);
               return -1;
             }
@@ -997 +1078 @@
   while (list_cmd)
     {
-      sl_snprintf(message, sizeof(message), _(">>>>  %8s  %32s  %s"),
+      sl_snprintf(message, sizeof(message), _(">>>>  %42s  %32s  %s"),
                   list_cmd->cmd, list_cmd->clt, list_cmd->cti);
-      /*
-      sl_strlcpy(message,     _(">>>>"), SH_MAXMSG);
-      sl_strlcat(message,          "  ", SH_MAXMSG);
-      sl_strlcat(message, list_cmd->cmd, SH_MAXMSG);
-      sl_strlcat(message,          "  ", SH_MAXMSG);
-      sl_strlcat(message, list_cmd->clt, SH_MAXMSG);
-      sl_strlcat(message,          "  ", SH_MAXMSG);
-      sl_strlcat(message, list_cmd->cti, SH_MAXMSG);
-      */
-      /*
-      nbytes = sendto (pf_unix_fd, message, sl_strlen(message) + 1, 0,
-                       (struct sockaddr *) & name, size);
-      */
+
       nbytes = send (talkfd, message, sl_strlen(message) + 1, 0);
       if (nbytes < 0)
@@ -1018 +1087 @@
                           sh_error_message (errno, errbuf, sizeof(errbuf)), 
                           _("sh_socket_read: sendto"));
-          sl_close_fd(FIL__, __LINE__, talkfd);
           return -1;
         }
@@ -1024 +1092 @@
     }
 
-  /*
-  nbytes = sendto (pf_unix_fd, _("END"), 4, 0,
-                   (struct sockaddr *) & name, size);
-  */
-  /* nbytes = *//* never read */ send (talkfd, _("END"), 4, 0);
-  sl_close_fd(FIL__, __LINE__, talkfd);
+  send (talkfd, _("END"), 4, 0);
   return 0;
 }
-/* #if !defined(HAVE_CMSGCRED) || !defined(SO_PEERCRED) */
-/* #endif */
 
 static void sh_socket_add2list (struct socket_cmd * in)
 {
-  struct socket_cmd  * new;
-
-  new = SH_ALLOC(sizeof(struct socket_cmd));
-  sl_strlcpy (new->cmd, in->cmd, sizeof(new->cmd));
-  sl_strlcpy (new->clt, in->clt, sizeof(new->clt));
-#ifdef SH_DEBUG_SOCKET
-  fprintf(stderr, "add2list: time set for %s\n", new->clt);
-#endif
-  (void) sh_unix_time(0, new->cti, sizeof(new->cti));
-  new->next = cmdlist;
-  cmdlist   = new;
-
-  return;
-}
-
-static void sh_socket_add2run (struct socket_cmd * in)
-{
-  struct socket_cmd  * new = runlist;
-  char * client_name       = in->clt;
+  struct socket_cmd  * new  = cmdlist;
+  struct socket_cmd  * last = cmdlist;
 
   while (new)
     {
-      if (0 == sl_strcmp(new->clt, client_name))
-        {
-          sl_strlcpy (new->cmd, in->cmd, sizeof(new->cmd));
-          sl_strlcpy (new->clt, in->clt, sizeof(new->clt));
-#ifdef SH_DEBUG_SOCKET
-          fprintf(stderr, "add2run: time reset for %s\n", new->clt);
-#endif
+      /* Only skip identical commands.
+       */
+      if (0 == sl_strcmp(new->clt,  in->clt) &&
+          0 == sl_strcmp(new->cmd,  in->cmd))
+        {
           (void) sh_unix_time(0, new->cti, sizeof(new->cti));
           return;
@@ -1073 +1115 @@
 
   new = SH_ALLOC(sizeof(struct socket_cmd));
-  sl_strlcpy (new->cmd, in->cmd, sizeof(new->cmd));
-  sl_strlcpy (new->clt, in->clt, sizeof(new->clt));
+  sl_strlcpy (new->cmd,  in->cmd,  sizeof(new->cmd));
+  sl_strlcpy (new->clt,  in->clt,  sizeof(new->clt));
+  (void) sh_unix_time(0, new->cti, sizeof(new->cti));
+  new->next  = NULL;
+
+  if (last)
+    {
+      while (last->next) { last = last->next; }
+      last->next = new;
+    }
+  else
+    {
+      cmdlist = new;
+    }
+  return;
+}
+
+static void sh_socket_add2run (struct socket_cmd * in)
+{
+  struct socket_cmd  * new  = runlist;
+  struct socket_cmd  * last = runlist;
+
+  while (new)
+    {
+      /* Only skip identical commands. First 5 will
+       * make all 'DELTA' identical.
+       */
+      if (0 == sl_strcmp(new->clt,  in->clt) &&
+          0 == sl_strncmp(new->cmd,  in->cmd, 5))
+        {
+          sl_strlcpy (new->cmd,  in->cmd,  sizeof(new->cmd));
+          (void) sh_unix_time(0, new->cti, sizeof(new->cti));
+          return;
+        }
+      new = new->next;
+    }
+
+  new = SH_ALLOC(sizeof(struct socket_cmd));
+  sl_strlcpy (new->cmd,  in->cmd,  sizeof(new->cmd));
+  sl_strlcpy (new->clt,  in->clt,  sizeof(new->clt));
 #ifdef SH_DEBUG_SOCKET
   fprintf(stderr, "add2run: time set for %s\n", new->clt);
 #endif
   (void) sh_unix_time(0, new->cti, sizeof(new->cti));
-  new->next = runlist;
-  runlist   = new;
-
+  new->next  = NULL;
+
+  if (last)
+    {
+      while (last->next) { last = last->next; }
+      last->next = new;
+    }
+  else
+    {
+      runlist = new;
+    }
   return;
 }
@@ -1087 +1175 @@
 
 
-static void sh_socket_rm2list (const char * client_name)
+static void sh_socket_rm2list (const char * client_name, int remove_all)
 {
   struct socket_cmd * old = cmdlist;
@@ -1098 +1186 @@
           if ((new == cmdlist) && (new->next == NULL))
             {
+              /* There is only one entry */
               cmdlist = NULL;
               SH_FREE(new);
@@ -1104 +1193 @@
           else if (new == cmdlist)
             {
+              /* first entry: new = old = cmdlist */
               cmdlist = new->next;
               SH_FREE(new);
-              return;
+              if (remove_all == S_FALSE)
+                return;
+              old = cmdlist;
+              new = cmdlist;
+              continue;
             }
           else
@@ -1112 +1206 @@
               old->next = new->next;
               SH_FREE(new);
-              return;
+              if (remove_all == S_FALSE)
+                return;
+              new = old;
             }
         }
@@ -1131 +1227 @@
 
   if (pf_unix_fd  < 0)
-    {
-      return 0;
-    }
+    return 0;
 
   sl_strlcpy(cancel_cmd, _("CANCEL"), sizeof(cancel_cmd)); 
@@ -1140 +1234 @@
     {
       if (0 == sl_strcmp(cmd.cmd, cancel_cmd))
-        {
-          sh_socket_rm2list  (cmd.clt);
-        }
+        sh_socket_rm2list  (cmd.clt, S_TRUE);
       else
-        {
-          sh_socket_rm2list  (cmd.clt);
-          sh_socket_add2list (&cmd);
-        }
+        sh_socket_add2list (&cmd);
     }
   return 0;
@@ -1164 +1253 @@
       if (0 == sl_strcmp(new->clt, client_name))
         {
-          sl_strlcpy(out, new->cmd, sizeof(out));
+          sl_strlcpy(out,  new->cmd,  sizeof(out));
           sh_socket_add2run (new);
-          sh_socket_rm2list  (client_name);
+          sh_socket_rm2list (client_name, S_FALSE);
           return out;
         }
@@ -1173 +1262 @@
   return NULL;
 }
-
 /* #if defined (SH_WITH_SERVER)
  */
 #endif
 
+
+#ifdef SH_CUTEST
+#include "CuTest.h"
+
+void Test_cmdlist (CuTest *tc) {
+
+#if defined (SH_WITH_SERVER)
+  struct socket_cmd cmd;
+  char * p;
+
+  sl_strlcpy(cmd.clt, "one", sizeof(cmd.clt));
+  sl_strlcpy(cmd.cmd, "RELOAD", sizeof(cmd.cmd));
+
+  sh_socket_add2list (&cmd);
+  p = sh_socket_check("one");
+  CuAssertPtrNotNull(tc, p);
+  CuAssertStrEquals(tc, "RELOAD", p);
+
+  p = sh_socket_check("one");
+  CuAssertPtrEquals(tc, NULL, p);
+
+  sh_socket_add2list (&cmd);
+  sl_strlcpy(cmd.cmd, "STOP",   sizeof(cmd.cmd));
+  sh_socket_add2list (&cmd);
+
+  sl_strlcpy(cmd.clt, "two", sizeof(cmd.clt));
+  sl_strlcpy(cmd.cmd, "STOP", sizeof(cmd.cmd));
+  sh_socket_add2list (&cmd);
+  sl_strlcpy(cmd.clt, "three", sizeof(cmd.clt));
+  sl_strlcpy(cmd.cmd, "STOP", sizeof(cmd.cmd));
+  sh_socket_add2list (&cmd);
+
+  sl_strlcpy(cmd.clt, "one", sizeof(cmd.clt));
+  sl_strlcpy(cmd.cmd, "DELTA",   sizeof(cmd.cmd));
+  sh_socket_add2list (&cmd);
+
+  p = sh_socket_check("one");
+  CuAssertPtrNotNull(tc, p);
+  CuAssertStrEquals(tc, "RELOAD", p);
+
+  sl_strlcpy(cmd.clt, "two", sizeof(cmd.clt));
+  sl_strlcpy(cmd.cmd, "RELOAD", sizeof(cmd.cmd));
+  sh_socket_add2list (&cmd);
+  sl_strlcpy(cmd.clt, "three", sizeof(cmd.clt));
+  sl_strlcpy(cmd.cmd, "RELOAD", sizeof(cmd.cmd));
+  sh_socket_add2list (&cmd);
+
+  p = sh_socket_check("one");
+  CuAssertPtrNotNull(tc, p);
+  CuAssertStrEquals(tc, "STOP", p);
+  p = sh_socket_check("one");
+  CuAssertPtrNotNull(tc, p);
+  CuAssertStrEquals(tc, "DELTA", p);
+  p = sh_socket_check("one");
+  CuAssertPtrEquals(tc, NULL, p);
+
+  /* Test removal in correct order */
+  sl_strlcpy(cmd.clt, "one", sizeof(cmd.clt));
+  sl_strlcpy(cmd.cmd, "RELOAD", sizeof(cmd.cmd));
+  sh_socket_add2list (&cmd);
+  sl_strlcpy(cmd.cmd, "STOP",   sizeof(cmd.cmd));
+  sh_socket_add2list (&cmd);
+  sl_strlcpy(cmd.cmd, "DELTA",  sizeof(cmd.cmd));
+  sh_socket_add2list (&cmd);
+  sl_strlcpy(cmd.cmd, "FOOBAR", sizeof(cmd.cmd));
+  sh_socket_add2list (&cmd);
+  
+  sh_socket_rm2list ("one", S_FALSE);
+
+  p = sh_socket_check("one");
+  CuAssertPtrNotNull(tc, p);
+  CuAssertStrEquals(tc, "STOP", p);
+
+  sh_socket_rm2list ("one", S_FALSE);
+  
+  p = sh_socket_check("one");
+  CuAssertPtrNotNull(tc, p);
+  CuAssertStrEquals(tc, "FOOBAR", p);
+
+  p = sh_socket_check("one");
+  CuAssertPtrEquals(tc, NULL, p);
+
+  sl_strlcpy(cmd.clt, "one", sizeof(cmd.clt));
+  sl_strlcpy(cmd.cmd, "RELOAD", sizeof(cmd.cmd));
+  sh_socket_add2list (&cmd);
+  sl_strlcpy(cmd.cmd, "STOP",   sizeof(cmd.cmd));
+  sh_socket_add2list (&cmd);
+
+  sl_strlcpy(cmd.clt, "two", sizeof(cmd.clt));
+  sl_strlcpy(cmd.cmd, "RELOAD", sizeof(cmd.cmd));
+  sh_socket_add2list (&cmd);
+  sl_strlcpy(cmd.clt, "three", sizeof(cmd.clt));
+  sl_strlcpy(cmd.cmd, "RELOAD", sizeof(cmd.cmd));
+  sh_socket_add2list (&cmd);
+
+  sl_strlcpy(cmd.clt, "one", sizeof(cmd.clt));
+  sl_strlcpy(cmd.cmd, "DELTA",  sizeof(cmd.cmd));
+  sh_socket_add2list (&cmd);
+  sl_strlcpy(cmd.cmd, "FOOBAR", sizeof(cmd.cmd));
+  sh_socket_add2list (&cmd);
+
+  sh_socket_rm2list ("one", S_TRUE);
+  p = sh_socket_check("one");
+  CuAssertPtrEquals(tc, NULL, p);
+
+  p = sh_socket_check("two");
+  CuAssertPtrNotNull(tc, p);
+  CuAssertStrEquals(tc, "STOP", p);
+  p = sh_socket_check("two");
+  CuAssertPtrNotNull(tc, p);
+  CuAssertStrEquals(tc, "RELOAD", p);
+  p = sh_socket_check("two");
+  CuAssertPtrEquals(tc, NULL, p);
+
+  p = sh_socket_check("three");
+  CuAssertPtrNotNull(tc, p);
+  CuAssertStrEquals(tc, "STOP", p);
+  p = sh_socket_check("three");
+  CuAssertPtrNotNull(tc, p);
+  CuAssertStrEquals(tc, "RELOAD", p);
+  p = sh_socket_check("three");
+  CuAssertPtrEquals(tc, NULL, p);
+
+  p = sh_socket_check("four");
+  CuAssertPtrEquals(tc, NULL, p);
+#else
+  (void) tc;
+#endif
+}
+
+#endif  /* #ifdef SH_CUTEST */
+
+
+