Changeset 76 for trunk/src

Timestamp:

Dec 19, 2006, 10:01:59 PM (18 years ago)

Author:

rainer

Message:

Fix for ticket #38 (csv escaping) and #39 (building on cygwin). Also optimize a bit.

Location:

trunk/src

Files:

• cutest_sh_hash.c (modified) (1 diff)
• cutest_sh_utils.c (modified) (5 diffs)
• sh_database.c (modified) (9 diffs)
• sh_getopt.c (modified) (4 diffs)
• sh_hash.c (modified) (5 diffs)
• sh_portcheck.c (modified) (2 diffs)
• sh_processcheck.c (modified) (1 diff)
• sh_tiger0.c (modified) (2 diffs)
• sh_unix.c (modified) (6 diffs)
• sh_utils.c (modified) (10 diffs)
• slib.c (modified) (9 diffs)
• trustfile.c (modified) (6 diffs)

trunk/src/cutest_sh_hash.c

@@ -63 +63 @@
 
 
+void Test_csv_escape_ok (CuTest *tc) {
+#if defined(SH_WITH_CLIENT) || defined(SH_STANDALONE)
 
+  extern char * csv_escape(const char * str);
+
+  char   test0[80];
+  char   expec[80];
+  char  *ret;
+
+  strcpy(test0, "foobar");
+  strcpy(expec, "\"foobar\"");
+  ret = csv_escape(test0);
+  CuAssertStrEquals(tc, expec, ret);
+
+  strcpy(test0, "\"foobar\"");
+  strcpy(expec, "\"\"\"foobar\"\"\"");
+  ret = csv_escape(test0);
+  CuAssertStrEquals(tc, expec, ret);
+
+  strcpy(test0, "foo,bar");
+  strcpy(expec, "\"foo,bar\"");
+  ret = csv_escape(test0);
+  CuAssertStrEquals(tc, expec, ret);
+
+  strcpy(test0, "foob,\"a\"r");
+  strcpy(expec, "\"foob,\"\"a\"\"r\"");
+  ret = csv_escape(test0);
+  CuAssertStrEquals(tc, expec, ret);
+
+  strcpy(test0, "\",\"foobar\",\"");
+  strcpy(expec, "\"\"\",\"\"foobar\"\",\"\"\"");
+  ret = csv_escape(test0);
+  CuAssertStrEquals(tc, expec, ret);
+
+  strcpy(test0, "");
+  strcpy(expec, "");
+  ret = csv_escape(test0);
+  CuAssertStrEquals(tc, expec, ret);
+
+  strcpy(test0, "a");
+  strcpy(expec, "\"a\"");
+  ret = csv_escape(test0);
+  CuAssertStrEquals(tc, expec, ret);
+
+  strcpy(test0, "foo\"bar");
+  strcpy(expec, "\"foo\"\"bar\"");
+  ret = csv_escape(test0);
+  CuAssertStrEquals(tc, expec, ret);
+
+#else
+  (void) tc; /* fix compiler warning */
+#endif
+  return;
+}
+
+
+

trunk/src/cutest_sh_utils.c

@@ -6 +6 @@
 #include "samhain.h"
 #include "sh_utils.h"
+
+void Test_sl_strlcpy (CuTest *tc) {
+  int ret;
+  char out[] = "aaaaaa";
+  char in[]  = "bbb";
+
+  ret = sl_strlcpy (NULL, NULL, 0);
+  CuAssertIntEquals(tc, ret, SL_ENONE);
+
+  ret = sl_strlcpy (NULL, in, 0);
+  CuAssertIntEquals(tc, ret, SL_ENULL);
+
+  ret = sl_strlcpy (out, NULL, 0);
+  CuAssertIntEquals(tc, ret, SL_ENONE);
+
+  ret = sl_strlcpy (out, in, 0);
+  CuAssertIntEquals(tc, ret, SL_ENONE);
+
+  ret = sl_strlcpy (out, NULL, 7);
+  CuAssertIntEquals(tc, ret, SL_ENONE);
+  CuAssertStrEquals(tc, "", out);
+
+  out[0] = 'a';
+  ret = sl_strlcpy (out, in, 4);
+  CuAssertIntEquals(tc, ret, SL_ENONE);
+  CuAssertStrEquals(tc, "bbb", out);
+  CuAssertStrEquals(tc, "aa", &out[4]);
+  
+  return;
+}
+
+void Test_sl_strlcat (CuTest *tc) {
+  int ret;
+  char out[16] = "aaaaaa";
+  char in[16]  = "bbb";
+
+  ret = sl_strlcat (NULL, NULL, 0);
+  CuAssertIntEquals(tc, ret, SL_ENONE);
+
+  ret = sl_strlcat (NULL, in, 0);
+  CuAssertIntEquals(tc, ret, SL_ENONE);
+
+  ret = sl_strlcat (out, NULL, 0);
+  CuAssertIntEquals(tc, ret, SL_ENONE);
+
+  ret = sl_strlcat (out, in, 0);
+  CuAssertIntEquals(tc, ret, SL_ENONE);
+
+  ret = sl_strlcat (out, NULL, sizeof(out));
+  CuAssertIntEquals(tc, ret, SL_ENONE);
+  CuAssertStrEquals(tc, "aaaaaa", out);
+
+  ret = sl_strlcat (out, in, 7);
+  CuAssertIntEquals(tc, ret, SL_ETRUNC);
+  CuAssertStrEquals(tc, "aaaaaa", out);
+
+  ret = sl_strlcat (out, in, 8);
+  CuAssertIntEquals(tc, ret, SL_ETRUNC);
+  CuAssertStrEquals(tc, "aaaaaab", out);
+
+  ret = sl_strlcat (out, in, sizeof(out));
+  CuAssertIntEquals(tc, ret, SL_ENONE);
+  CuAssertStrEquals(tc, "aaaaaabbbb", out);
+
+  CuAssertStrEquals(tc, "bbb", in);
+
+  return;
+}
 
 void Test_sh_util_acl_compact (CuTest *tc) {
@@ -238 +306 @@
   CuAssertIntEquals(tc, ret, S_FALSE);
 
+  /* switch on utf8 checking for sh_util_obscurename() */
+
+  ret = sh_util_obscure_utf8("Y");
+  CuAssertIntEquals(tc, ret, 0);
 
   ret = sh_util_obscure_ok ("0x01,0x02,0x03");
@@ -244 +316 @@
   ret = sh_util_valid_utf8 (input);
   CuAssertIntEquals(tc, ret, S_TRUE);
+  ret = sh_util_obscurename (0, (char *)input, S_FALSE /* no log message */);
+  CuAssertIntEquals(tc, ret, 0);
 
   input[0] = '\t';
   ret = sh_util_valid_utf8 (input);
   CuAssertIntEquals(tc, ret, S_FALSE);
+  ret = sh_util_obscurename (0, (char *)input, S_FALSE /* no log message */);
+  CuAssertIntEquals(tc, ret, -1);
 
   input[0] = 0x01;
   ret = sh_util_valid_utf8 (input);
   CuAssertIntEquals(tc, ret, S_TRUE);
+  ret = sh_util_obscurename (0, (char *)input, S_FALSE /* no log message */);
+  CuAssertIntEquals(tc, ret, 0);
 
   input[0] = 0x02;
   ret = sh_util_valid_utf8 (input);
   CuAssertIntEquals(tc, ret, S_TRUE);
+  ret = sh_util_obscurename (0, (char *)input, S_FALSE /* no log message */);
+  CuAssertIntEquals(tc, ret, 0);
 
   input[0] = 0x03;
   ret = sh_util_valid_utf8 (input);
   CuAssertIntEquals(tc, ret, S_TRUE);
+  ret = sh_util_obscurename (0, (char *)input, S_FALSE /* no log message */);
+  CuAssertIntEquals(tc, ret, 0);
 
   input[0] = 0x04;
   ret = sh_util_valid_utf8 (input);
   CuAssertIntEquals(tc, ret, S_FALSE);
+  ret = sh_util_obscurename (0, (char *)input, S_FALSE /* no log message */);
+  CuAssertIntEquals(tc, ret, -1);
+
+  input[0] = 'f';
+  ret = sh_util_valid_utf8 (input);
+  CuAssertIntEquals(tc, ret, S_TRUE);
+  ret = sh_util_obscurename (0, (char *)input, S_FALSE /* no log message */);
+  CuAssertIntEquals(tc, ret, 0);
+
+  input[5] = ' ';
+  ret = sh_util_valid_utf8 (input);
+  CuAssertIntEquals(tc, ret, S_FALSE);
+  ret = sh_util_obscurename (0, (char *)input, S_FALSE /* no log message */);
+  CuAssertIntEquals(tc, ret, -1);
+
+  input[5] = 'r'; input[3] = ' ';
+  ret = sh_util_valid_utf8 (input);
+  CuAssertIntEquals(tc, ret, S_TRUE);
+  ret = sh_util_obscurename (0, (char *)input, S_FALSE /* no log message */);
+  CuAssertIntEquals(tc, ret, 0);
 
 
@@ -277 +379 @@
   char input[16] = "foobar";
 
+  /* switch off utf8 checking for sh_util_obscurename() */
+
+  ret = sh_util_obscure_utf8("N");
+  CuAssertIntEquals(tc, ret, 0);
+
   ret = sh_util_obscure_ok ("0xA1,0xA2,0xA3");
   CuAssertIntEquals(tc, ret, 0);
@@ -303 +410 @@
   CuAssertIntEquals(tc, ret, -1);
 
+  input[0] = 'f';
+  ret = sh_util_obscurename (0, input, S_FALSE /* no log message */);
+  CuAssertIntEquals(tc, ret, 0);
+
+  input[5] = ' ';
+  ret = sh_util_obscurename (0, input, S_FALSE /* no log message */);
+  CuAssertIntEquals(tc, ret, -1);
+
+  input[5] = 'r'; input[3] = ' ';
+  ret = sh_util_obscurename (0, input, S_FALSE /* no log message */);
+  CuAssertIntEquals(tc, ret, 0);
 #else
   CuAssertIntEquals(tc, ret, 0);

trunk/src/sh_database.c

@@ -1197 +1197 @@
   long len;
 
-  if (!end    || !val   || !size)
-    return end;
-
-  if (val[0] == '\0')
-    {
-      return end;
-    }
-  else
-    {
-      if (*size > 1)
+  if (!((end == NULL) || (val == NULL) || (size == NULL)))
+    {
+      if (val[0] != '\0')
         {
-          *end = ','; ++end; (*size) -= 1;
-          if (flag == 1) { *end = '\''; ++end; (*size) -= 1; }
-          *end = '\0';
+          if (*size > 1)
+            {
+              *end = ','; ++end; (*size) -= 1;
+              if (flag == 1) { *end = '\''; ++end; (*size) -= 1; }
+              *end = '\0';
+            }
+          len = (long) strlen(val);
+          if ((long) *size > (len+1))
+            {
+              (void) sl_strlcat(end, val, (size_t) *size);
+              end   += len; (*size) -= len;
+              if (flag == 1) { *end = '\''; ++end;  (*size) -= 1; }
+              *end = '\0'; 
+            }
         }
-      len = (long) strlen(val);
-      if ((long) *size > (len+1))
-        {
-          (void) sl_strlcat(end, val, (size_t) *size);
-          end   += len; (*size) -= len;
-          if (flag == 1) { *end = '\''; ++end;  (*size) -= 1; }
-          *end = '\0'; 
-        }
-    }
-
+    }
+  
   return end;
 }
@@ -1250 +1246 @@
   char md5out[33];
   int  cnt;
+
+  size_t len_val;
+  size_t len_col;
 
   SL_ENTER(_("sh_database_entry"));
@@ -1331 +1330 @@
   /*@+type@*/
 
-  size   =  (int) (SH_QUERY_MAX - strlen(values));
-  end    =  values + strlen(values);
-  c_size =  1023   - (int) strlen(columns); /* sizeof(colums) == 1024 */
-  c_end  =  columns + strlen(columns);
+  len_val = strlen(values);
+  size    =  (int) (SH_QUERY_MAX - len_val);
+  end     =  values + len_val;
+
+  len_col = strlen(columns);
+  c_size  =  1023   - (int) len_col; /* sizeof(colums) == 1024 */
+  c_end   =  columns + len_col;
 
   i = 4;
@@ -1354 +1356 @@
           if (p != end)
             {
-              /* 
-               * 'host' is a reserved word in SQL
-               */
-              if (attr_tab[i].val == SH_SLOT_HOST)
-                c_end = null_or_val (c_end, _("fromhost"), &c_size,0);
-              /* 
-               * 'group' is a reserved word in SQL
-               */
-              else if (attr_tab[i].val == SH_SLOT_GROUP)
-                c_end = null_or_val (c_end, _("grp"), &c_size,0);
+              if ((attr_tab[i].val != SH_SLOT_HOST) &&
+                  (attr_tab[i].val != SH_SLOT_GROUP))
+                {
+                  c_end = null_or_val (c_end, attr_tab[i].attr, &c_size,0);
+                }
               else
-                c_end = null_or_val (c_end, attr_tab[i].attr, &c_size,0);
+                {
+                  /* 
+                   * 'host' is a reserved word in SQL
+                   */
+                  if (attr_tab[i].val == SH_SLOT_HOST)
+                    c_end = null_or_val (c_end, _("fromhost"), &c_size,0);
+                  /* 
+                   * 'group' is a reserved word in SQL
+                   */
+                  else /* if (attr_tab[i].val == SH_SLOT_GROUP) */
+                    c_end = null_or_val (c_end, _("grp"), &c_size,0);
+                }
             }
           /*@-type@*//* byte* versus char[..] */
@@ -1523 +1531 @@
   unsigned char * p = (unsigned char *) p_in;
 
-  while (*p != '\0') 
-    {
-      if (*p == '\\')
+  if (*p != '\0')
+    {
+      do 
         {
-          escp = (escp == 1) ? 0 : 1;
-        }
-      else if ((*p == '\'' || *p == '\"') && escp == 0)
-        {
-          retv = S_FALSE;
-        }
-      else if (*p > 0x7F)
-        {
-          retv = S_FALSE;
-        }
-      else 
-        {
-          escp = 0;
-        }
-      ++p;
-    }
-  if (escp == 1) 
-    retv = S_FALSE;
-  return retv;
+          if (*p <=  0x7F)
+            {
+              if (escp == 0)
+                {
+                  if      (!((*p == '\'') || (*p == '\"') || (*p != '\\'))) 
+                    /* do nothing */;
+                  else if (*p == '\\') escp = 1;
+                  else    retv = S_FALSE; /* (*p == '\'' || *p == '\"') */
+                }
+              else /* escp == 1 */
+                {
+                  escp = 0;
+                }
+            }
+          else /* *p > 0x7F */
+            {
+              retv = S_FALSE;
+            }
+          
+          ++p;
+          
+        } 
+      while (*p != '\0');
+    }
+
+  if (escp == 0)
+    return retv;
+  else
+    return S_FALSE;
 }
 
@@ -1580 +1598 @@
     SL_RETURN (NULL, _("sh_database_parse"));
 
-  while ((p != NULL) && (*p != '\0') && (*p != '>'))
+  while ((*p != '\0') && (*p != '>'))
     {
       if (p[0] == 'l' && p[1] == 'o' && p[2] == 'g' &&
@@ -1631 +1649 @@
   /* non-whitespace 
    */
-  i = 0;
   for (i=0; i < 64; ++i)
     {
-      key_str[i] = p[i];
-      if (p[i] == '=')
+      if (p[i] != '=')
+        {
+          key_str[i] = p[i];
+        }
+      else
         {
           key_str[i] = '\0';
@@ -1653 +1673 @@
         {
           q = strchr(&p[j+2], '"');
-          if (!q)
-            {
-              SL_RETURN(NULL, _("sh_database_parse"));
-            }
-          else
+          if (q)
             {
               *q = '\0';
 
-              if (S_FALSE == is_escaped(&p[j+2])) {
+              if (S_TRUE == is_escaped(&p[j+2])) {
+
+                if      (res->val == 1)
+                  (void) sl_strlcpy(db_entry->sev, &p[j+2], 
+                                    (size_t)res->size);
+                else if (res->val == 2)
+                  {
+                    z = strchr(&p[j+2], 'T');
+                    if (z) *z = ' ';
+                    (void) sl_strlcpy(db_entry->time, &p[j+2],  20);
+                  }
+                else if (res->val == 3)
+                  (void) sl_strlcpy(db_entry->host, &p[j+2], 
+                                    (size_t) res->size);
+                else if (res->val == 4)
+                  (void) sl_strlcpy(db_entry->msg,  &p[j+2], 
+                                    (size_t) res->size);
+                else if (res->size != 0)
+                  {
+                    (void) sl_strlcpy( (((char *)(db_entry))+ res->off),
+                                       &p[j+2], 
+                                       (size_t) res->size);
+                  }
+                else if (res->val >= START_SEC_LONGS)
+                  {
+                    db_entry->long_data[res->val-START_SEC_LONGS]
+                      = atol(&p[j+2]);
+                  }
+
+                *q = '"';
+                p  = q; 
+                ++p;
+
+                goto parse;
+              }
+              else { /* S_FALSE == is_escaped(&p[j+2]) */
                 sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
                                 _("Message not properly escaped"), 
@@ -1667 +1718 @@
                 SL_RETURN(NULL, _("sh_database_parse"));
               }
-
-              if      (res->val == 1)
-                (void) sl_strlcpy(db_entry->sev, &p[j+2], 
-                                  (size_t)res->size);
-              else if (res->val == 2)
-                {
-                  z = strchr(&p[j+2], 'T');
-                  if (z) *z = ' ';
-                  (void) sl_strlcpy(db_entry->time, &p[j+2],  20);
-                }
-              else if (res->val == 3)
-                (void) sl_strlcpy(db_entry->host, &p[j+2], 
-                                  (size_t) res->size);
-              else if (res->val == 4)
-                (void) sl_strlcpy(db_entry->msg,  &p[j+2], 
-                                  (size_t) res->size);
-              else if (res->size != 0)
-                {
-                  (void) sl_strlcpy( (((char *)(db_entry))+ res->off),
-                                     &p[j+2], 
-                                     (size_t) res->size);
-                }
-              else if (res->val >= START_SEC_LONGS)
-                {
-                  db_entry->long_data[res->val-START_SEC_LONGS]
-                    = atol(&p[j+2]);
-                }
-
-              *q = '"';
-              p  = q; 
-              ++p;
-
-              goto parse;
+            }
+          else /* q == NULL */
+            {
+              SL_RETURN(NULL, _("sh_database_parse"));
             }
         }

trunk/src/sh_getopt.c

@@ -65 +65 @@
 #endif
 static int sh_getopt_copyright (const char * dummy);
+static int sh_getopt_version (const char * dummy);
 
 static opttable_t op_table[] = {
@@ -265 +266 @@
     HAS_ARG_NO, 
     sh_getopt_usage },
+  { N_("version"),  
+    'v', 
+    N_("Show version and compiled-in options"),  
+    HAS_ARG_NO, 
+    sh_getopt_version },
 #if defined(HAVE_LIBPRELUDE) && defined(HAVE_LIBPRELUDE_9)
   /* need to skip over these */
@@ -301 +307 @@
 };
 
+
+static void sh_getopt_print_log_facilities ()
+{
+  fputs (_("Compiled-in log facilities:"), stdout);
+
+#ifndef DEFAULT_CONSOLE
+  printf (_(" console (/dev/console)"));
+#else
+  if (0 == strcmp (DEFAULT_CONSOLE, _("NULL")))
+    printf (_(" console (/dev/console)"));
+  else
+    printf (_(" console (%s)"), DEFAULT_CONSOLE);
+#endif
+  fputs  (_(", syslog"), stdout);
+  printf (_(", logfile (%s)"), DEFAULT_ERRFILE);
+
+#if defined(WITH_EXTERNAL)
+  fputs (_(", external program"), stdout);
+#endif
+
+#if defined(WITH_MESSAGE_QUEUE)
+  fputs (_(", message queue"), stdout);
+#endif
+ 
+#if defined(WITH_DATABASE)
+  fputs (_(", database"), stdout);
+#ifdef WITH_ODBC
+  fputs (_(" (odbc)"), stdout);
+#endif
+#ifdef WITH_ORACLE
+  fputs (_(" (Oracle)"), stdout);
+#endif
+#ifdef WITH_POSTGRES
+  fputs (_(" (PostgreSQL)"), stdout);
+#endif
+#ifdef WITH_MYSQL 
+  fputs (_(" (MySQL)"), stdout);
+#endif
+#endif
+
+#if defined(SH_WITH_CLIENT) || defined(SH_WITH_SERVER)
+  fputs (_(", server"), stdout);
+#endif
+
+#if defined(SH_WITH_MAIL)
+  fputs (_(", email"), stdout);
+#endif
+
+#ifdef HAVE_LIBPRELUDE
+#ifdef HAVE_LIBPRELUDE_8
+  fputs (_(", prelude (0.8)"), stdout);
+#else
+  fputs (_(", prelude (0.9+)"), stdout);
+#endif
+#endif
+
+  fputc ('\n', stdout);
+  return;
+}
+
+static void sh_getopt_print_options ()
+{
+  int num = 0;
+
+
+#if defined(SH_STANDALONE)
+  if (num > 0) fputc ('\n', stdout);
+  fputs (_("Standalone executable"), stdout); ++num;
+#endif
+#if defined(SH_WITH_CLIENT)
+  if (num > 0) fputc ('\n', stdout);
+  printf (_("Client executable (port %d)"), SH_DEFAULT_PORT); ++num;
+#endif
+#if defined(SH_WITH_CLIENT)
+  if (num > 0) fputc ('\n', stdout);
+  printf (_("Server executable (port %d, user %s)"), 
+          SH_DEFAULT_PORT, DEFAULT_IDENT); 
+  ++num;
+#endif
+
+  fputs (_(", compiled-in options:"), stdout);
+
+#if defined(HAVE_EGD_RANDOM)
+  if (num > 0) fputc ('\n', stdout);
+  printf (_(" use entropy gathering daemon (%s)"), EGD_SOCKET_NAME); ++num;
+#endif
+#if defined(HAVE_UNIX_RANDOM)
+  if (num > 0) fputc ('\n', stdout);
+  fputs (_(" use unix entropy gatherer"), stdout); ++num;
+#endif
+#if defined(HAVE_URANDOM)
+  if (num > 0) fputc ('\n', stdout);
+  printf (_(" use entropy device (%s)"), NAME_OF_DEV_RANDOM); ++num;
+#endif
+
+#ifdef WITH_GPG
+  if (num > 0) fputc ('\n', stdout);
+  printf (_(" GnuPG signatures (%s)"), DEFAULT_GPG_PATH); ++num;
+#ifdef HAVE_GPG_CHECKSUM
+  if (num > 0) fputc ('\n', stdout);
+  printf (_("   -- GnuPG checksum:  %s"), GPG_HASH); ++num;
+#endif
+#ifdef USE_FINGERPRINT
+  if (num > 0) fputc ('\n', stdout);
+  printf (_("   -- Key fingerprint: %s"), SH_GPG_FP); ++num;
+#endif
+#endif
+
+#if defined(SL_DEBUG)
+  if (num > 0) fputc ('\n', stdout);
+  fputs (_(" debug build"), stdout); ++num;
+#endif
+#if defined(SCREW_IT_UP)
+  if (num > 0) fputc ('\n', stdout);
+  fputs (_(" anti-debugger"), stdout); ++num;
+#endif
+#if defined(SH_USE_XML)
+  if (num > 0) fputc ('\n', stdout);
+  fputs (_(" xml log format"), stdout); ++num;
+#endif
+#if defined(HAVE_NTIME)
+  if (num > 0) fputc ('\n', stdout);
+  fputs (_(" use time server"), stdout); ++num;
+#endif
+
+#if defined(SH_WITH_CLIENT) || defined(SH_STANDALONE)
+#if defined(USE_XATTR)
+  if (num > 0) fputc ('\n', stdout);
+  fputs (_(" check SELinux attributes"), stdout); ++num;
+#endif
+#if defined(USE_ACL)
+  if (num > 0) fputc ('\n', stdout);
+  fputs (_(" check Posix ACLs"), stdout); ++num;
+#endif
+#if defined(RELOAD_DATABASE)
+  if (num > 0) fputc ('\n', stdout);
+  fputs (_(" fetch database on reload"), stdout); ++num;
+#endif
+#endif
+
+#if defined(SH_WITH_SERVER)
+
+#if !defined(HAVE_GETPEEREID) && !defined(SO_PEERCRED) && !defined(HAVE_STRUCT_CMSGCRED) && !defined(HAVE_STRUCT_FCRED) && !(defined(HAVE_STRUCT_SOCKCRED) && defined(LOCAL_CREDS))
+  if (num > 0) fputc ('\n', stdout);
+  fputs (_(" command socket authentication: use SetSocketPassword"), stdout); 
+  ++num;
+#else
+  if (num > 0) fputc ('\n', stdout);
+  fputs (_(" command socket authentication: use SetSocketAllowUID"), stdout); 
+  ++num;
+#endif
+
+#if defined(SH_USE_LIBWRAP)
+  if (num > 0) fputc ('\n', stdout);
+  fputs (_(" support tcp wrapper"), stdout); ++num;
+#endif
+#if defined(INET_SYSLOG)
+  if (num > 0) fputc ('\n', stdout);
+  fputs (_(" support listening on 514/udp (syslog)"), stdout); ++num;
+#endif
+#endif
+
+  if (num == 0)
+    fputs (_(" none"), stdout);
+  fputc ('\n', stdout);
+  return;
+}
+
+static void sh_getopt_print_modules ()
+{
+#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE) 
+  int num = 0;
+  
+  fputs (_("Compiled-in modules:"), stdout);
+#ifdef SH_USE_UTMP
+  if (num > 0) fputc (',', stdout);
+  fputs (_(" login/logout"), stdout); ++num;
+#endif
+#ifdef SH_USE_MOUNTS
+  if (num > 0) fputc (',', stdout);
+  fputs (_(" mount options"), stdout); ++num;
+#endif
+#ifdef SH_USE_USERFILES
+  if (num > 0) fputc (',', stdout);
+  fputs (_(" userfiles"), stdout); ++num;
+#endif
+#ifdef SH_USE_KERN
+  if (num > 0) fputc (',', stdout);
+  fputs (_(" kernel"), stdout); ++num;
+#endif
+#ifdef SH_USE_SUIDCHK
+  if (num > 0) fputc (',', stdout);
+  fputs (_(" suid"), stdout); ++num;
+#endif
+#ifdef SH_USE_PROCESSCHECK
+  if (num > 0) fputc (',', stdout);
+  fputs (_(" processes"), stdout); ++num;
+#endif
+#ifdef SH_USE_PORTCHECK
+  if (num > 0) fputc (',', stdout);
+  fputs (_(" ports"), stdout); ++num;
+#endif
+  if (num == 0)
+    fputs (_(" none"), stdout);
+  fputc ('\n', stdout);
+#endif
+  return;
+}
+
+static int sh_getopt_version (const char * dummy)
+{
+  (void) dummy;
+  fprintf (stdout,
+           _("This is samhain (%s), "\
+             "(c) 1999-2006 Rainer Wichmann (http://la-samhna.de).\n"),
+           VERSION);
+  fprintf (stdout, _("This software comes with ABSOLUTELY NO WARRANTY. "));
+  fprintf (stdout, _("Use at own risk.\n\n"));
+
+  sh_getopt_print_log_facilities ();
+  sh_getopt_print_modules ();
+  sh_getopt_print_options ();
+
+  _exit (EXIT_SUCCESS);
+  /*@notreached@*/
+  return 0; /* make compilers happy */
+}
 static int sh_getopt_copyright (const char * dummy)
 {
   fprintf (stdout, 
-           _("Copyright (C) 1999-2005 Rainer Wichmann"\
+           _("Copyright (C) 1999-2006 Rainer Wichmann"\
              " (http://la-samhna.de).\n\n"));
 
@@ -378 +611 @@
   fprintf (stdout,
            _("This is samhain (%s), "\
-             "(c) 1999-2005 Rainer Wichmann (http://la-samhna.de).\n"),
+             "(c) 1999-2006 Rainer Wichmann (http://la-samhna.de).\n"),
            VERSION);
   fprintf (stdout, _("This software comes with ABSOLUTELY NO WARRANTY. "));

trunk/src/sh_hash.c

@@ -1460 +1460 @@
   if (sh.flag.update == S_FALSE)
     {
-      if (pushdata_stdout == S_FALSE)
-        {
-          pushdata_fd = -1;
-          if ( SL_ISERROR(pushdata_fd = sl_open_write(file_path('D', 'W'), SL_YESPRIV))) {
-            SH_FREE(fullpath);
-            SH_FREE(linkpath);
-            sh_error_handle((-1), FIL__, __LINE__, pushdata_fd, MSG_E_ACCESS,
-                            geteuid(), file_path('D', 'W'));
-            SL_RET0(_("sh_hash_pushdata"));
-          }
-          if ( SL_ISERROR(status = sl_forward(pushdata_fd))) {
-            SH_FREE(fullpath);
-            SH_FREE(linkpath);
-            sh_error_handle((-1), FIL__, __LINE__, status, MSG_E_SUBGPATH,
-                            _("Fast forward failed"), _("sh_hash_pushdata"),
-                            file_path('D', 'W'));
-            SL_RET0(_("sh_hash_pushdata"));
-          }
+      if (pushdata_stdout == S_FALSE && pushdata_fd == -1)
+        {
+          if ( SL_ISERROR(pushdata_fd = sl_open_write(file_path('D', 'W'), SL_YESPRIV))) 
+            {
+              SH_FREE(fullpath);
+              SH_FREE(linkpath);
+              sh_error_handle((-1), FIL__, __LINE__, pushdata_fd, MSG_E_ACCESS,
+                              geteuid(), file_path('D', 'W'));
+              SL_RET0(_("sh_hash_pushdata"));
+            }
+          if ( SL_ISERROR(status = sl_forward(pushdata_fd))) 
+            {
+              SH_FREE(fullpath);
+              SH_FREE(linkpath);
+              sh_error_handle((-1), FIL__, __LINE__, status, MSG_E_SUBGPATH,
+                              _("Fast forward failed"), _("sh_hash_pushdata"),
+                              file_path('D', 'W'));
+              SL_RET0(_("sh_hash_pushdata"));
+            }
         }
     }
@@ -1726 +1727 @@
     {
       sl_write      (pushdata_fd,       &p, sizeof(sh_filestore_t));
-      sl_write_line (pushdata_fd, fullpath,    sl_strlen(fullpath));
-      sl_write_line (pushdata_fd, linkpath,    sl_strlen(linkpath));
+      sl_write_line_fast (pushdata_fd, fullpath, sl_strlen(fullpath));
+      sl_write_line_fast (pushdata_fd, linkpath, sl_strlen(linkpath));
       if (attr_string)
-        sl_write_line (pushdata_fd, attr_string,    sl_strlen(attr_string));
+        sl_write_line_fast (pushdata_fd, attr_string, sl_strlen(attr_string));
     } else {
       fwrite (&p, sizeof(sh_filestore_t), 1, stdout);
@@ -1742 +1743 @@
   if ((sh.flag.update != S_TRUE) && (pushdata_stdout == S_FALSE))
     {
-      sl_close (pushdata_fd);
-      pushdata_fd = -1;
+      if (sh.flag.checkSum != SH_CHECK_INIT || (buf == NULL && fileHash == NULL))
+        {
+          sl_close (pushdata_fd);
+          pushdata_fd = -1;
+        }
     }
 
@@ -3413 +3417 @@
     return 0;
 }
+
+/* Always quote the string, except if it is empty. Qoute quotes by
+ * doubling them.
+ */
+char * csv_escape(const char * str)
+{
+  const  char * p = str;
+  const  char * q;
+
+  size_t size       = 0;
+  size_t flag_quote = 0;
+  int    flag_comma = 0;
+  char * new;
+  char * pnew;
+
+  if (p)
+    {
+
+      while (*p) 
+        {
+          if (*p == ',')
+            flag_comma = 1;
+          else if (*p == '"')
+            ++flag_quote;
+          
+          ++size; ++p;
+        }
+
+      if (sl_ok_adds(size, flag_quote))
+        size += flag_quote;      /* double each quote */
+      else
+        return NULL;
+
+      if (sl_ok_adds(size, 3))
+        size += 3; /* two quotes and terminating null */
+      else
+        return NULL;
+      
+      new = SH_ALLOC(size);
+      
+      if (flag_quote != 0)
+        {
+          new[0] = '"';
+          pnew = &new[1];
+          q    = str;
+          while (*q)
+            {
+              *pnew = *q;
+              if (*pnew == '"')
+                {
+                  ++pnew; *pnew = '"';
+                }
+              ++pnew; ++q;
+            }
+          *pnew = '"'; ++pnew;
+          *pnew = '\0';
+        }
+      else
+        {
+          if (size > 3) 
+            {
+              new[0] = '"';
+              sl_strlcpy (&new[1], str, size-1);
+              new[size-2] = '"';
+              new[size-1] = '\0';
+            }
+          else
+            {
+              new[0] = '\0';
+            }
+        }
+
+      return new;
+    }
+  return NULL;
+}
+
+
  
 void sh_hash_list_db_entry_full_detail (sh_file_t * p)
 {
   char * tmp;
+  char * esc;
   char   str[81];
-  size_t i;
 
   if (ListWithDelimiter == S_TRUE)
@@ -3464 +3546 @@
 
   tmp = sh_util_safe_name(p->fullpath);
-  printf( _(" %s"), tmp);
+  if (ListWithDelimiter != S_TRUE)
+    {
+      printf( _(" %s"), tmp);
+    }
+  else
+    {
+      esc = csv_escape(tmp);
+      printf( _(" %s,"), (esc != NULL) ? esc : _("(null)"));
+      if (esc)
+        SH_FREE(esc);
+    }
   SH_FREE(tmp);
-  if (ListWithDelimiter == S_TRUE)
-    putchar(',');
 
   if ('l' == p->theFile.c_mode[0])
     {
       tmp = sh_util_safe_name(p->linkpath);
-      if (ListWithDelimiter == S_TRUE)
-        printf(_(" %s"), tmp);
+      if (ListWithDelimiter != S_TRUE)
+        {
+          printf(_(" -> %s"), tmp);
+        }
       else
-        printf(_(" -> %s"), tmp);
+        {
+          esc = csv_escape(tmp);
+          printf( _(" %s,"), (esc != NULL) ? esc : _("(null)"));
+          if (esc)
+            SH_FREE(esc);
+        }
       SH_FREE(tmp);
     }
-  if (ListWithDelimiter == S_TRUE)
-    putchar(',');
 
   if (p->attr_string)
     {
       tmp = sh_util_safe_name(p->attr_string);
-      if (ListWithDelimiter == S_TRUE) {
-        for (i = 0; i < strlen(tmp); ++i) 
-          if (tmp[i] == ',') tmp[i] = ';';
-      }
+      if (ListWithDelimiter != S_TRUE) 
+        {
+          printf(_(" %s"), tmp);
+        }
+      else
+        {
+          esc = csv_escape(tmp);
+          printf( _(" %s"), (esc != NULL) ? esc : _("(null)"));
+          if (esc)
+            SH_FREE(esc);
+        }
       printf(_(" %s"), tmp);
       SH_FREE(tmp);

trunk/src/sh_portcheck.c

@@ -40 +40 @@
 #include <unistd.h>
 
+#define PORTCHK_VERSION "1.0"
+
+#if defined(TEST_ONLY) || (defined(SH_USE_PORTCHECK) && (defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)))
+
+
 #define PORTMAP
 #include <rpc/rpc.h>
@@ -48 +53 @@
 #include <rpc/pmap_prot.h>
 #include <netdb.h>
-
-#define PORTCHK_VERSION "1.0"
-
-#if defined(TEST_ONLY) || (defined(SH_USE_PORTCHECK) && (defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)))
-
 
 /*

trunk/src/sh_processcheck.c

@@ -591 +591 @@
 }
 
+/* FIXME: add open, statvfs, sched_getaffinity
+ */
 static short sh_processes_check (pid_t pid, short res)
 {

trunk/src/sh_tiger0.c

@@ -331 +331 @@
         sh.statistics.bytes_hashed += 64;
         ++nblocks; ncount = 0;
-        for (i = 0; i < 56; i += 4) 
-          {
-            bbuf[i]   = (sh_byte) '\0';
-            bbuf[i+1] = (sh_byte) '\0';
-            bbuf[i+2] = (sh_byte) '\0';
-            bbuf[i+3] = (sh_byte) '\0';
-          }
-        /* memset(bbuf, 0, 56 ); */ 
+        sl_memset(bbuf, 0, 56 ); 
       }
 
@@ -361 +354 @@
 #endif
 
-    for (i = 0; i < 64; i += 4) 
-      {
-        bbuf[i]   = (sh_byte) '\0';
-        bbuf[i+1] = (sh_byte) '\0';
-        bbuf[i+2] = (sh_byte) '\0';
-        bbuf[i+3] = (sh_byte) '\0';
-      }
-
-    bptr = buffer;
-
-    memcpy(bptr, bbuf,     64); bptr +=    64;
-    memcpy(bptr, bbuf,     64); bptr +=    64;
-    memcpy(bptr, buffer,  128); bptr +=   128;
-    memcpy(bptr, buffer,  256); bptr +=   256;
-    memcpy(bptr, buffer,  512); bptr +=   512;
-    memcpy(bptr, buffer, 1024); bptr +=  1024;
-    memcpy(bptr, buffer, 2048); bptr +=  2048;
-    memcpy(bptr, buffer, 4096); bptr +=  4096;
-    memcpy(bptr, buffer, 8192); bptr +=  8192;
-    memcpy(bptr, buffer,16384);
+    sl_memset (bbuf,   '\0', sizeof(bbuf));
+    sl_memset (buffer, '\0', sizeof(buffer));
 
     if (what == TIGER_FILE)

trunk/src/sh_unix.c

@@ -3551 +3551 @@
   SL_ENTER(_("sh_unix_test_and_lock"));
 
-  if (filename != NULL)
-    {
-      status = retry_lstat (FIL__, __LINE__, filename, &buf);
-
-      /* no logfile to lock
-       */
-      if (status < 0)
-        SL_RETURN((-1),_("sh_unix_test_and_lock"));
-    }
-
   status = retry_lstat (FIL__, __LINE__, lockfile, &buf);
 
@@ -3573 +3563 @@
             sh.flag.islocked = GOOD;
           SL_RETURN((0),_("sh_unix_test_and_lock"));
+        }
+      else
+        {
+          sh_error_handle ((-1), FIL__, __LINE__, status,
+                           MSG_E_SUBGEN, 
+                           (filename == NULL) ? _("Cannot create PID file") : _("Cannot create lock file"),
+                           _("sh_unix_test_and_lock"));
+          SL_RETURN((-1),_("sh_unix_test_and_lock"));
         }
     }
@@ -3590 +3588 @@
       else
         {
-           sh_error_handle ((-1), FIL__, __LINE__, status,
-                            MSG_E_SUBGEN, 
-                            (filename == NULL) ? _("Cannot create PID file") : _("Cannot create lock file"),
-                            _("sh_unix_test_and_lock"));
+          sh_error_handle ((-1), FIL__, __LINE__, status,
+                           MSG_E_SUBGEN, 
+                           (filename == NULL) ? _("Cannot create PID file") : _("Cannot create lock file"),
+                           _("sh_unix_test_and_lock"));
           SL_RETURN((-1),_("sh_unix_test_and_lock"));
         }
@@ -3617 +3615 @@
       /* read the PID in the lock file
        */
-      status = sh_unix_getline (fd, line_in, sizeof(line_in));
+      status = sl_read (fd, line_in, sizeof(line_in));
+      line_in[sizeof(line_in)-1] = '\0';
 
       /* convert to numeric
@@ -3797 +3796 @@
 int sh_unix_lock (char * lockfile, char * flag)
 {
-  struct stat buf;
-  int status;
   int filed;
   int errnum;
@@ -3805 +3802 @@
   extern int get_the_fd (SL_TICKET ticket);
 
-
-  status = retry_lstat (FIL__, __LINE__, lockfile, &buf);
-  
   SL_ENTER(_("sh_unix_lock"));
 
-  if (0 == status) 
-    {
-      if (flag != NULL)
-        sh.flag.islocked       = BAD;
-      SL_RETURN((-1),_("sh_unix_lock"));
-    }
-
   sprintf (myPid, "%ld\n", (long) getpid());           /* known to fit  */
 
-  fd = sl_open_write (lockfile, SL_YESPRIV);
+  fd = sl_open_safe_rdwr (lockfile, SL_YESPRIV);       /* fails if file exists */
 
   if (!SL_ISERROR(fd))

trunk/src/sh_utils.c

@@ -268 +268 @@
   return out;
 }
-    
+
+
+char * sh_util_strdup_l (const char * str, size_t len)
+{
+  char * p = NULL;
+
+  SL_ENTER(_("sh_util_strdup_l"));
+
+  SH_VALIDATE_NE(str, NULL);
+  SH_VALIDATE_NE(len, 0);
+
+  if (sl_ok_adds (len, 1))
+    {
+      p   = SH_ALLOC (len + 1);
+      (void) sl_strlcpy (p, str, len+1);
+    }
+  else
+    {
+      safe_fatal(_("integer overflow in sh_util_strdup_l"), FIL__, __LINE__);
+    }
+  SL_RETURN( p, _("sh_util_strdup_l"));
+}
+
 char * sh_util_strdup (const char * str) 
 {
@@ -1413 +1435 @@
 
 static unsigned char sh_obscure_index[256];
+static int sh_obscure_no_check = S_FALSE;
 
 int sh_util_valid_utf8 (const unsigned char * str) 
 {
+  const int     sh_val_utf8_1 = 1;
+  const int     sh_val_utf8_2 = 2;
+  const int     sh_val_utf8_3 = 3;
+  const int     sh_val_utf8_4 = 4;
+
   size_t        len = strlen((char *)str);
   size_t        l   = 0;
-  unsigned char c;
+  int           typ = 0;
+  unsigned char c     = '\0';
+  unsigned char c2[2] = { 0x00, 0x00 };
+  unsigned char c3[3] = { 0x00, 0x00, 0x00 };
+
 
 #define SH_VAL_UTF8_1 ((c != '\0') && ((c & 0x80) == 0x00))
@@ -1425 +1457 @@
 #define SH_VAL_UTF8_4 ((c != '\0') && ((c & 0xF8) == 0xF0)) /* 1111 0xxx */
 #define SH_VAL_UTF8_N ((c != '\0') && ((c & 0xC0) == 0x80)) /* 10xx xxxx */
-#define SH_VAL_BAD    ((c == '"') || (c == '\t') || (c == '\b') || (c == '\f') || (c == '\n') || \
+#define SH_VAL_BAD    ((c == '"')  || (c == '\t') || (c == '\b') || \
+                       (c == '\f') || (c == '\n') || \
                        (c == '\r') || (c == '\v') || iscntrl((int) c) || \
                        (c != ' ' && !isgraph ((int) c)))
@@ -1435 +1468 @@
       if      (SH_VAL_UTF8_1) 
         {
-          if (SH_VAL_BAD && (sh_obscure_index[c] != 1)) return S_FALSE;
-          ++l; continue; /* ASCII character */
+          if (!(SH_VAL_BAD && (sh_obscure_index[c] != 1)))
+            {
+              typ = sh_val_utf8_1;
+              ++l; continue;
+            }
+          else
+            {
+              return S_FALSE;
+            }
         } 
       else if (SH_VAL_UTF8_2) 
         { 
-          if ((c & 0x3e) == 0x00) 
-            return S_FALSE; /* overlong 2-byte seq. */
-          ++l; if (l == len) return S_FALSE; c = str[l];
-          if(!SH_VAL_UTF8_N) return S_FALSE; 
-          ++l; continue;
-          
+          typ = sh_val_utf8_2;
+          c2[0] = c;
+          if ((c & 0x3e) != 0x00) /* !(overlong 2-byte seq.) */
+            {
+              ++l; 
+              if (l != len) {
+                c = str[l];
+                if(SH_VAL_UTF8_N) {
+                  c2[1] = c;
+                  ++l; continue;
+                } 
+                else {
+                  return S_FALSE;
+                } 
+              } 
+              else {
+                return S_FALSE; 
+              }
+            }
+          else
+            {
+              return S_FALSE; /* overlong 2-byte seq. */
+            }
         } 
       else if (SH_VAL_UTF8_3) 
         {
+          typ = sh_val_utf8_3;
+          c3[0] = c;
           ++l; if (l == len) return S_FALSE; c = str[l];
           if(!SH_VAL_UTF8_N) return S_FALSE;
           if (((str[l-1] & 0x1F) == 0x00) && ((c & 0x60) == 0x00))
             return S_FALSE; /* overlong 3-byte seq. */
+          c3[1] = c;
           ++l; if (l == len) return S_FALSE; c = str[l];
           if(!SH_VAL_UTF8_N) return S_FALSE;
+          c3[2] = c;
           ++l; continue;
         } 
       else if (SH_VAL_UTF8_4) 
         {
+          typ = sh_val_utf8_4;
           ++l; if (l == len) return S_FALSE; c = str[l];
           if(!SH_VAL_UTF8_N) return S_FALSE;
@@ -1471 +1533 @@
       return S_FALSE;
     }
-  return S_TRUE;
+
+  /* last character is invisible (space or else)
+   */
+  if (typ == sh_val_utf8_1)
+    { 
+      if (c != ' ')
+        return S_TRUE;
+      else
+        return S_FALSE;
+    }
+  else if (typ == sh_val_utf8_2)
+    {
+      if (c2[0] == 0xC2 && c2[1] == 0xA0) /* nbsp */
+        return S_FALSE;
+      else
+        return S_TRUE;
+    }
+  else if (typ == sh_val_utf8_3)
+    {
+      if (c3[0] == 0xE2) 
+        {
+          if (c3[1] == 0x80 && c3[2] >= 0x80 && c3[2] <= 0x8F)
+            return S_FALSE; /* various spaces, left-to-right, right-to-left */
+          else if (c3[1] == 0x80 && (c3[2] == 0xA8 || c3[2] == 0xA9 || 
+                                     c3[2] == 0xAD || c3[2] == 0xAF))
+            return S_FALSE; /* line sep, para sep, zw word joiner, nnbsp */
+          else if (c3[1] == 0x81 && (c3[2] == 0xA0 || c3[2] == 0xA1 || 
+                                     c3[2] == 0x9F))
+            return S_FALSE; /* word joiner, function app, math space */
+          else
+            return S_TRUE;
+        }
+      else if (c3[0] == 0xE3 && c3[1] == 0x80 && c3[2] == 0x80)
+        {
+          return S_FALSE; /* ideographic space */
+        }
+      else if (c3[0] == 0xEF && c3[1] == 0xBB && c3[2] == 0xBF)
+        {
+          return S_FALSE; /* zwnbsp */
+        }
+      else
+        {
+          return S_TRUE;
+        }
+    }
+  else
+    {
+      return S_TRUE;
+    }
 }
 
@@ -1488 +1598 @@
           sh_obscure_index[i] = (unsigned char)1;
         }
+      sh_obscure_no_check = S_TRUE;
       SL_RETURN(0, _("sh_util_obscure_ok"));
     }
+
+  sh_obscure_no_check = S_FALSE;
 
   for (i = 0; i < 255; ++i)
@@ -1526 +1639 @@
   SL_ENTER(_("sh_util_obscure_utf8"));
   i = sh_util_flagval(c, &(sh_obscure_check_utf8));
-
+  if (sh_obscure_check_utf8 == S_TRUE)
+    sh_obscure_no_check = S_FALSE;
   SL_RETURN(i, _("sh_util_obscure_utf8"));
 }
@@ -1536 +1650 @@
   char * safe;
   unsigned int i;
+  size_t len = 0;
 
   SL_ENTER(_("sh_util_obscurename"));
@@ -1541 +1656 @@
   ASSERT_RET((name != NULL), _("name != NULL"), (0))
 
-  if (sh_obscure_check_utf8 == S_TRUE)
-    {
-      if (S_FALSE == sh_util_valid_utf8(name))
-        {
-          goto err;
-        }
-      SL_RETURN((0),_("sh_util_obscurename"));
-    }
-
-  /* -- Check name. --
-   */
-  while (*name != '\0') 
-    {
-      if ( (*name) >  0x7F || (*name) == '"'  || (*name) == '\t' ||
-           (*name) == '\b' || (*name) == '\f' || 
-           (*name) == '\n' || (*name) == '\r' ||
-           (*name) == '\v' || iscntrl((int) *name) || 
-           ((*name) != ' ' && !isgraph ((int) *name)) ) 
-        {
-          i = (unsigned char) *name;
-          if (sh_obscure_index[i] != (unsigned char)1)
+  if (sh_obscure_no_check == S_FALSE)
+    {
+      if (sh_obscure_check_utf8 != S_TRUE)
+        {
+          /* -- Check name. --
+           */
+          while (*name != '\0') 
+            {
+              if ( (*name) >  0x7F || (*name) == '"'  || (*name) == '\t' ||
+                   (*name) == '\b' || (*name) == '\f' || 
+                   (*name) == '\n' || (*name) == '\r' ||
+                   (*name) == '\v' || iscntrl((int) *name) || 
+                   ((*name) != ' ' && !isgraph ((int) *name)) ) 
+                {
+                  i = (unsigned char) *name;
+                  if (sh_obscure_index[i] != (unsigned char)1)
+                    {
+                      goto err;
+                    }
+                }
+              name++; ++len;
+            }
+
+          /* Check for blank at end of name
+           */
+          if ((len > 0) && (name_orig[len-1] == ' '))
             {
               goto err;
             }
         }
-      name++;
-    }
-
+      else
+        {
+          if (S_FALSE == sh_util_valid_utf8(name))
+            {
+              goto err;
+            }
+          SL_RETURN((0),_("sh_util_obscurename"));
+        }
+    }
+      
   SL_RETURN((0),_("sh_util_obscurename"));
 
  err:
-
+  
   if (flag == S_TRUE)
     {
@@ -1822 +1949 @@
 }
 
-char * sh_util_strconcat (const char * arg1, ...)
+char * sh_util_strconcat (const char * arg1, ...) 
 {
   size_t    length, l2;

trunk/src/slib.c

@@ -48 +48 @@
 #define FD_ZERO(p)      memset((char *)(p), '\0', sizeof(*(p)))
 #endif
+
+#define SH_REAL_SET
 
 #include "slib.h"
@@ -566 +568 @@
   
 /*
- * A memset that does not get optimized away
+ * Have memset in a different translation unit (i.e. this) to prevent 
+ * it to get optimized away
  */
 void *sl_memset(void *s, int c, size_t n)
 {
-  volatile char *p = (char *) s;
-
-  if (s != NULL)
-    {
-      while (n--)
-        *p++ = c;
-    }
-  return s;
+  return memset(s, c,n);
 }
 
@@ -870 +866 @@
   register const char * q;
 
-  if (dst == NULL)
-    return SL_ENONE;
-  if (src == NULL || *src == '\0') 
-    return SL_ENONE;
-
-  if (siz > 0) {
-
-    /* How much free space do we have ?
-     */
-    dst_end  = strlen(dst);
-    dst_free = siz - dst_end - 1;
-
-    p = &dst[dst_end];
-    q = src;
-
-    while (dst_free > 0 && *q != '\0')
-      {
-        *p++ = *q++;
-        --dst_free;
-      }
-
-    /* NULL terminate dst.
-     */
-    *p = '\0';
-
-    if (*q != '\0') 
-      return SL_ETRUNC;
-  }
-
+  if (!(dst == NULL || src == NULL || *src == '\0'))
+    {
+      if (siz > 0) 
+        {
+
+          /* How much free space do we have ?
+           */
+          dst_end  = strlen(dst);
+          dst_free = siz - dst_end - 1;
+          
+          p = &dst[dst_end];
+          q = src;
+          
+          while (dst_free > 0 && *q != '\0')
+            {
+              *p++ = *q++;
+              --dst_free;
+            }
+        
+          /* NULL terminate dst.
+           */
+          *p = '\0';
+        
+          if (*q == '\0')
+            return SL_ENONE;
+          else
+            return SL_ETRUNC;
+        }
+    }
   return SL_ENONE;
 }
@@ -917 +913 @@
   /* SL_ENTER(_("sl_strlcpy")); */
 
-  if (dst == NULL)
-    return SL_ENULL;
-  if (src == NULL)
-    { 
+  if (!((dst == NULL) || (src == NULL))) 
+    {
+      if (siz > 0) {
+        /* copy siz-1 characters 
+         */
+        (void) strncpy(dst, src, siz-1);
+
+        /* NULL terminate
+         */
+        dst[siz-1] = '\0';
+      }
+      return SL_ENONE;
+    }
+  else if (src == NULL)
+    {
       if (siz > 0) 
         dst[0] = '\0';
       return SL_ENONE;
     }
-
-
-  if (siz > 0) {
-    /* copy siz-1 characters 
-     */
-    (void) strncpy(dst, src, siz-1);
-
-    /* NULL terminate
-     */
-    dst[siz-1] = '\0';
-  }
-  return SL_ENONE;
+  else
+    {
+      return SL_ENULL;
+    } 
 }
 
@@ -1574 +1573 @@
 }
 
-SL_TICKET sl_make_ticket (int fd, char * filename)
+SL_TICKET sl_make_ticket (int fd, const char * filename)
 {
   size_t    len;
@@ -2376 +2375 @@
 }
 
+int sl_write_line_fast (SL_TICKET ticket, void * msg, long nbytes)
+{
+  int  status;
+  char * p = (char *) msg;
+
+  SL_ENTER(_("sl_write_line_fast"));
+
+  /* Here nbytes is strlen(msg), so p[nbytes] is the terminating '\0'
+   * Overwrite the terminator, write out, then write back the terminator.
+   */
+  p[nbytes] = '\n';
+  status = sl_write(ticket,  msg, nbytes+1);
+  p[nbytes] = '\0';
+
+  SL_IRETURN(status, _("sl_write_line_fast"));
+}
+
 
 /* ---------------------------------------------------------------- 
@@ -2389 +2405 @@
 extern char  tf_path[MAXFILENAME];      /* Error path for trust function. */
 extern uid_t tf_euid;                   /* Space for EUID of process.     */
-
 
 char * sl_error_string(int errorcode)
@@ -2490 +2505 @@
 }
 
+#include "sh_mem.h"
+extern char * sh_util_strdup (const char * str);
+
+struct sl_trustfile_store {
+  char * filename;
+  uid_t  teuid;
+  struct sl_trustfile_store * next;
+};
+
+static struct sl_trustfile_store * sl_trusted_files = NULL;
+
+void sl_add_trusted_file(char * filename, uid_t teuid)
+{
+  struct sl_trustfile_store *new = SH_ALLOC(sizeof(struct sl_trustfile_store));
+
+  new->filename = sh_util_strdup (filename);
+  new->teuid    = teuid;
+  new->next     = sl_trusted_files;
+
+  sl_trusted_files = new;
+  return;
+}
+
+char * sl_check_trusted_file(char * filename, uid_t teuid)
+{
+  struct sl_trustfile_store *new = sl_trusted_files;
+
+  while (new)
+    {
+      if ((new->teuid == teuid) && (0 == strcmp(new->filename, filename)))
+        return filename;
+      new = new->next;
+    }
+
+  return NULL;
+}
+
+void sl_clear_trusted_file(struct sl_trustfile_store * file)
+{
+  if (file)
+    {
+      if (file->next != NULL)
+        sl_clear_trusted_file(file->next);
+      SH_FREE(file->filename);
+      SH_FREE(file);
+    }
+  return;
+}
+
 int sl_trustfile_euid(char * filename, uid_t teuid)
 {
-  long status;
+  long          status;
+  static time_t old = 0;
+  static time_t now;
+
   SL_ENTER(_("sl_trustfile_euid"));
 
@@ -2499 +2566 @@
     SL_IRETURN(SL_EBADNAME, _("sl_trustfile_euid"));
 
+  now = time(NULL);
+  if (now < (old + 300))
+    {
+      if (NULL != sl_check_trusted_file(filename, teuid))
+        {
+          sl_strlcpy(tf_path, filename, sizeof(tf_path));
+          SL_IRETURN(SL_ENONE, _("sl_trustfile_euid"));
+        }
+    }
+  else
+    {
+      sl_clear_trusted_file(sl_trusted_files);
+      sl_trusted_files = NULL;
+      old = now;
+    }
+
   tf_euid = teuid;
   status = sl_trustfile(filename, NULL, NULL);
+  if (status == SL_ENONE)
+    sl_add_trusted_file(filename, teuid);
   SL_IRETURN(status, _("sl_trustfile_euid"));
 }

trunk/src/trustfile.c

@@ -687 +687 @@
       if (retry_lstat(FIL__, __LINE__, fexp, &stbuf) < 0)
         {
-          (void) strcpy(tf_path, fexp);                  /* known to fit  */
+          (void) strncpy(tf_path, fexp, sizeof(tf_path));
+          tf_path[sizeof(tf_path)-1] = '\0';
 #ifdef TRUST_MAIN
           fprintf(stderr, "---------------------------------------------\n");
-              fprintf(stderr, "trustfile: ESTAT: stat(%s) failed, maybe the file does not exist\n",
-                      fexp);
+          fprintf(stderr, "trustfile: ESTAT: stat(%s) failed,\n", fexp);
+          fprintf(stderr, "maybe the file does not exist\n");
           fprintf(stderr, "---------------------------------------------\n");
 #endif
@@ -781 +782 @@
                   /* yes -- error 
                    */
-                  (void) strcpy(tf_path, fexp);          /* known to fit  */
+                  (void) strncpy(tf_path, fexp, sizeof(tf_path));
+                  tf_path[sizeof(tf_path)-1] = '\0';
 #ifdef TRUST_MAIN
                   fprintf(stderr, "---------------------------------------------\n");
@@ -850 +852 @@
           fprintf(stderr, "---------------------------------------------\n");
 #endif 
-          (void) strcpy(tf_path, fexp);                  /* known to fit  */
+          (void) strncpy(tf_path, fexp, sizeof(tf_path));
+          tf_path[sizeof(tf_path)-1] = '\0';
+
           tf_baduid = (uid_t) stbuf.st_uid;
           SL_IRETURN(SL_EBADUID, _("sl_trustfile"));
@@ -887 +891 @@
           fprintf(stderr, "---------------------------------------------\n");
 #endif 
-          (void) strcpy(tf_path, fexp);                  /* known to fit  */
+          (void) strncpy(tf_path, fexp, sizeof(tf_path));
+          tf_path[sizeof(tf_path)-1] = '\0';
+
           tf_badgid = (gid_t) stbuf.st_gid;
           SL_IRETURN(SL_EBADGID, _("sl_trustfile"));
@@ -909 +915 @@
           fprintf(stderr, "---------------------------------------------\n");
 #endif 
-          (void) strcpy(tf_path, fexp);                  /* known to fit  */
+          (void) strncpy(tf_path, fexp, sizeof(tf_path));
+          tf_path[sizeof(tf_path)-1] = '\0';
+
           SL_IRETURN(SL_EBADOTH, _("sl_trustfile"));
         }
@@ -932 +940 @@
    * yes, it can be trusted
    */
-  (void) strcpy(tf_path, fexp);                      /* known to fit  */
+  (void) strncpy(tf_path, fexp, sizeof(tf_path));
+  tf_path[sizeof(tf_path)-1] = '\0';
+
   SL_IRETURN(SL_ENONE, _("sl_trustfile"));
 }