The host parameter to connect_to() is now const.
[privoxy.git] / miscutil.c
index c3c270c..8b0fc5b 100644 (file)
@@ -1,4 +1,5 @@
-const char miscutil_rcs[] = "$Id: miscutil.c,v 1.3 2001/05/29 23:10:09 oes Exp $";
+/* vim:ts=3: */
+const char miscutil_rcs[] = "$Id: miscutil.c,v 1.9 2001/06/07 14:43:17 swa Exp $";
 /*********************************************************************
  *
  * File        :  $Source: /cvsroot/ijbswa/current/miscutil.c,v $
@@ -36,6 +37,81 @@ const char miscutil_rcs[] = "$Id: miscutil.c,v 1.3 2001/05/29 23:10:09 oes Exp $
  *
  * Revisions   :
  *    $Log: miscutil.c,v $
+ *    Revision 1.9  2001/06/07 14:43:17  swa
+ *    slight mistake in make_path, unix path style is /.
+ *
+ *    Revision 1.8  2001/06/05 22:32:01  jongfoster
+ *    New function make_path() to splice directory and file names together.
+ *
+ *    Revision 1.7  2001/06/03 19:12:30  oes
+ *    introduced bindup()
+ *
+ *    Revision 1.7  2001/06/03 11:03:48  oes
+ *    Makefile/in
+ *
+ *    introduced cgi.c
+ *
+ *    actions.c:
+ *
+ *    adapted to new enlist_unique arg format
+ *
+ *    conf loadcfg.c
+ *
+ *    introduced confdir option
+ *
+ *    filters.c filtrers.h
+ *
+ *     extracted-CGI relevant stuff
+ *
+ *    jbsockets.c
+ *
+ *     filled comment
+ *
+ *    jcc.c
+ *
+ *     support for new cgi mechansim
+ *
+ *    list.c list.h
+ *
+ *    functions for new list type: "map"
+ *    extended enlist_unique
+ *
+ *    miscutil.c .h
+ *    introduced bindup()
+ *
+ *    parsers.c parsers.h
+ *
+ *    deleted const struct interceptors
+ *
+ *    pcrs.c
+ *    added FIXME
+ *
+ *    project.h
+ *
+ *    added struct map
+ *    added struct http_response
+ *    changes struct interceptors to struct cgi_dispatcher
+ *    moved HTML stuff to cgi.h
+ *
+ *    re_filterfile:
+ *
+ *    changed
+ *
+ *    showargs.c
+ *    NO TIME LEFT
+ *
+ *    Revision 1.6  2001/06/01 18:14:49  jongfoster
+ *    Changing the calls to strerr() to check HAVE_STRERR (which is defined
+ *    in config.h if appropriate) rather than the NO_STRERR macro.
+ *
+ *    Revision 1.5  2001/06/01 10:31:51  oes
+ *    Added character class matching to trivimatch; renamed to simplematch
+ *
+ *    Revision 1.4  2001/05/31 17:32:31  oes
+ *
+ *     - Enhanced domain part globbing with infix and prefix asterisk
+ *       matching and optional unanchored operation
+ *
  *    Revision 1.3  2001/05/29 23:10:09  oes
  *
  *
@@ -203,9 +279,9 @@ char *safe_strerror(int err)
    char buf[BUFSIZ];
 
 
-#ifndef NOSTRERROR
+#ifdef HAVE_STRERROR
    s = strerror(err);
-#endif /* NOSTRERROR */
+#endif /* HAVE_STRERROR */
 
    if (s == NULL)
    {
@@ -394,14 +470,12 @@ char *strsav(char *old, const char *text_to_append)
 
 /*********************************************************************
  *
- * Function    :  trivimatch
+ * Function    :  simplematch
  *
- * Description :  Trivial string matching, with only one metacharacter,
- *                namely '*', which stands for zero or more arbitrary
- *                characters.
- *
- *                Note: The * is greedy, i.e. it will try to match as
- *                      much text es possible.
+ * Description :  String matching, with a (greedy) '*' wildcard that
+ *                stands for zero or more arbitrary characters and
+ *                character classes in [], which take both enumerations
+ *                and ranges.
  *
  * Parameters  :
  *          1  :  pattern = pattern for matching
@@ -410,15 +484,21 @@ char *strsav(char *old, const char *text_to_append)
  * Returns     :  0 if match, else nonzero
  *
  *********************************************************************/
-int trivimatch(char *pattern, char *text)
+int simplematch(char *pattern, char *text)
 {
-   char *fallback; 
-   char *pat = pattern;
-   char *txt = text;
-   int wildcard = 0;
+  char *fallback; 
+  char *pat = pattern;
+  char *txt = text;
+  int wildcard = 0;
+  
+  char lastchar = 'a';
+  unsigned i;
+  unsigned char charmap[32];
+  
   
    while (*txt)
    {
+
       /* EOF pattern but !EOF text? */
       if (*pat == '\0')
       {
@@ -428,49 +508,186 @@ int trivimatch(char *pattern, char *text)
       /* '*' in the pattern?  */
       if (*pat == '*') 
       {
-
+     
          /* The pattern ends afterwards? Speed up the return. */
          if (*++pat == '\0')
          {
             return 0;
          }
-
+     
          /* Else, set wildcard mode and remember position after '*' */
          wildcard = 1;
          fallback = pat;
       }
 
-      /* Compare: */
-      if (*pat != *txt)
+      /* Character range specification? */
+      if (*pat == '[')
       {
-         /* In wildcard mode, just try again */
+         memset(charmap, '\0', sizeof(charmap));
+
+         while (*++pat != ']')
+         {
+            if (!*pat)
+            { 
+               return 1;
+            }
+            else if (*pat == '-')
+            {
+               if ((*++pat == ']') || *pat == '\0')
+               {
+                  return(1);
+               }
+               for(i = lastchar; i <= *pat; i++)
+               {
+                  charmap[i / 8] |= (1 << (i % 8));
+               } 
+            }
+            else
+            {
+               charmap[*pat / 8] |= (1 << (*pat % 8));
+               lastchar = *pat;
+            }
+         }
+      } /* -END- if Character range specification */
+
+
+      /* Compare: Char match, or char range match*/
+      if ((*pat == *txt)  
+      || ((*pat == ']') && (charmap[*txt / 8] & (1 << (*txt % 8)))) )
+      {
+         /* Sucess, go ahead */
+         pat++;
+      }
+      else
+      {
+         /* In wildcard mode, just try again after failiure */
          if(wildcard)
          {
-            /* Without wildcard mode, this is fatal! */
             pat = fallback;
          }
 
-         /* Bad luck otherwise */
+         /* Else, bad luck */
          else
          {
             return 1;
          }
       }
-      /* We had a match, advance */
-      else
-      {
-         pat++;
-      }
       txt++;
-  }
+   }
+
+   /* Cut off extra '*'s */
+   if(*pat == '*')  pat++;
+
+   /* If this is the pattern's end, fine! */
+   return(*pat);
+
+}
+
+
+/*********************************************************************
+ *
+ * Function    :  bindup
+ *
+ * Description :  Duplicate the first n characters of a string that may
+ *                contain '\0' characters.
+ *
+ * Parameters  :
+ *          1  :  string = string to be duplicated
+ *          2  :  n = number of bytes to duplicate
+ *
+ * Returns     :  pointer to copy, or NULL if failiure
+ *
+ *********************************************************************/
+char *bindup(const char *string, int n)
+{
+   char *dup;
 
-  if(*pat == '*')  pat++;
+   if (NULL == (dup = (char *)malloc(n)))
+   {
+          return NULL;
+       }
+   else
+       {
+         memcpy(dup, string, n);
+       }
 
-  /* Hey, we've made it all the way through! */
-  return(*pat);
+   return dup;
 
 }
 
+
+/*********************************************************************
+ *
+ * Function    :  make_path
+ *
+ * Description :  Takes a directory name and a file name, returns 
+ *                the complete path.  Handles windows/unix differences.
+ *                If the file name is already an absolute path, or if
+ *                the directory name is NULL or empty, it returns 
+ *                the filename. 
+ *
+ * Parameters  :
+ *          1  :  dir: Name of directory or NULL for none.
+ *          2  :  file: Name of file.  Should not be NULL or empty.
+ *
+ * Returns     :  "dir/file" (Or on windows, "dir\file").
+ *                It allocates the string on the heap.  Caller frees.
+ *                Returns NULL in error (i.e. NULL file or out of
+ *                memory) 
+ *
+ *********************************************************************/
+char * make_path(const char * dir, const char * file)
+{
+#ifdef AMIGA
+   char path[512];
+
+   if(dir)
+   {
+      strncpy(path,dir,512);
+      path[511]=0;
+   } else {
+      path[0]=0;
+   }
+   if(AddPart(path,file,512))
+   {
+      return strdup(path);
+   } else {
+      return NULL;
+   }
+#else /* ndef AMIGA */
+
+   if ((file == NULL) || (*file == '\0'))
+   {
+      return NULL; /* Error */
+   }
+
+   if ((dir == NULL) || (*dir == '\0') /* No directory specified */
+#ifdef _WIN32
+      || (*file == '\\') || (file[1] == ':') /* Absolute path (DOS) */
+#else /* ifndef _WIN32 */
+      || (*file == '/') /* Absolute path (U*ix) */
+#endif /* ifndef _WIN32 */
+      )
+   {
+      return strdup(file);
+   }
+   else
+   {
+      char * path = malloc(strlen(dir) + strlen(file) + 2);
+      strcpy(path, dir);
+#ifdef _WIN32
+      strcat(path, "\\");
+#else /* ifndef _WIN32 */
+      if(path[strlen(path)-1] != '/') strcat(path, "/");
+#endif /* ifndef _WIN32 */
+      strcat(path, file);
+
+      return path;
+   }
+#endif /* ndef AMIGA */
+}
+
+
 /*
   Local Variables:
   tab-width: 3