Changeset 76 for trunk/src/sh_utils.c

Timestamp:

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

Author:

rainer

Message:

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

File:

• trunk/src/sh_utils.c (modified) (10 diffs)

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;