X-Git-Url: http://www.privoxy.org/gitweb/?p=privoxy.git;a=blobdiff_plain;f=list.c;h=2cbe763d2b7e38b115c665866fa86be5392bcb60;hp=078723cc8dcab59e162f97f03fa13d29aa878fb3;hb=41d37e938e75b5eaa032257fa1979f145d403b74;hpb=5f390b415777db21894f1b856ab3d21c9c24f7c6

diff --git a/list.c b/list.c
index 078723cc..2cbe763d 100644
--- a/list.c
+++ b/list.c
@@ -1,4 +1,4 @@
-const char list_rcs[] = "$Id: list.c,v 1.11 2001/10/23 21:21:03 jongfoster Exp $";
+const char list_rcs[] = "$Id: list.c,v 1.17 2006/07/18 14:48:46 david__schmidt Exp $";
 /*********************************************************************
  *
  * File        :  $Source: /cvsroot/ijbswa/current/list.c,v $
@@ -8,7 +8,7 @@ const char list_rcs[] = "$Id: list.c,v 1.11 2001/10/23 21:21:03 jongfoster Exp $
  *                   `destroy_list', `enlist' and `list_to_text'
  *
  * Copyright   :  Written by and Copyright (C) 2001 the SourceForge
- *                IJBSWA team.  http://ijbswa.sourceforge.net
+ *                Privoxy team. http://www.privoxy.org/
  *
  *                Based on the Internet Junkbuster originally written
  *                by and Copyright (C) 1997 Anonymous Coders and
@@ -34,6 +34,32 @@ const char list_rcs[] = "$Id: list.c,v 1.11 2001/10/23 21:21:03 jongfoster Exp $
  *
  * Revisions   :
  *    $Log: list.c,v $
+ *    Revision 1.17  2006/07/18 14:48:46  david__schmidt
+ *    Reorganizing the repository: swapping out what was HEAD (the old 3.1 branch)
+ *    with what was really the latest development (the v_3_0_branch branch)
+ *
+ *    Revision 1.15.2.2  2004/05/25 02:04:23  david__schmidt
+ *    Removed the "arbitrary" 1000 filter limit in file.c.  See tracker #911950.
+ *
+ *    Revision 1.15.2.1  2002/11/28 18:14:54  oes
+ *    Added unmap function that removes all items with a given
+ *    name from a map.
+ *
+ *    Revision 1.15  2002/03/26 22:29:55  swa
+ *    we have a new homepage!
+ *
+ *    Revision 1.14  2002/03/24 13:25:43  swa
+ *    name change related issues
+ *
+ *    Revision 1.13  2002/03/07 03:46:17  oes
+ *    Fixed compiler warnings
+ *
+ *    Revision 1.12  2001/10/25 03:40:48  david__schmidt
+ *    Change in porting tactics: OS/2's EMX porting layer doesn't allow multiple
+ *    threads to call select() simultaneously.  So, it's time to do a real, live,
+ *    native OS/2 port.  See defines for __EMX__ (the porting layer) vs. __OS2__
+ *    (native). Both versions will work, but using __OS2__ offers multi-threading.
+ *
  *    Revision 1.11  2001/10/23 21:21:03  jongfoster
  *    New error handling - error codes are now jb_errs, not ints.
  *    Changed the way map() handles out-of-memory, to dramatically
@@ -128,7 +154,7 @@ static int list_is_valid (const struct list *the_list);
 
 /*********************************************************************
  *
- * Function    :  list_init
+ * Function    :  init_list
  *
  * Description :  Create a new, empty list in user-allocated memory.
  *                Caller should allocate a "struct list" variable,
@@ -217,7 +243,7 @@ static int list_is_valid (const struct list *the_list)
 #if 1
    const struct list_entry *cur_entry;
    const struct list_entry *last_entry = NULL;
-   int length = 0;
+   int entry = 0;
 
    assert(the_list);
 
@@ -231,24 +257,29 @@ static int list_is_valid (const struct list *the_list)
           * Just check that this string can be accessed - i.e. it's a valid
           * pointer.
           */
-         strlen(cur_entry->str);
+         (void)strlen(cur_entry->str);
       }
 
       /*
        * Check for looping back to first
        */
-      if ((length != 0) && (cur_entry == the_list->first))
+      if ((entry++ != 0) && (cur_entry == the_list->first))
       {
          return 0;
       }
 
       /*
-       * Arbitrarily limit length to prevent infinite loops.
-       */
-      if (++length > 1000)
-      {
+       * Arbitrarily limit list length to prevent infinite loops.
+       * Note that the 1000 limit was hit by a real user in tracker 911950;
+       * removing it for now.  Real circular references should eventually
+       * be caught by the check above, anyway.
+       */         
+      /*
+      if (entry > 1000)
+      {           
          return 0;
-      }
+      }           
+      */          
 
       /*
        * Check this isn't marked as the last entry, unless of course it's
@@ -396,7 +427,7 @@ jb_err enlist_first(struct list *the_list, const char *str)
  *
  *********************************************************************/
 jb_err enlist_unique(struct list *the_list, const char *str,
-                     int num_significant_chars)
+                     size_t num_significant_chars)
 {
    struct list_entry *cur_entry;
 
@@ -404,7 +435,7 @@ jb_err enlist_unique(struct list *the_list, const char *str,
    assert(list_is_valid(the_list));
    assert(str);
    assert(num_significant_chars >= 0);
-   assert((size_t)num_significant_chars <= strlen(str));
+   assert(num_significant_chars <= strlen(str));
 
    if (num_significant_chars > 0)
    {
@@ -458,7 +489,7 @@ jb_err enlist_unique(struct list *the_list, const char *str,
 jb_err enlist_unique_header(struct list *the_list, const char *name,
                             const char *value)
 {
-   int length;
+   size_t length;
    jb_err result;
    char *str;
 
@@ -484,6 +515,7 @@ jb_err enlist_unique_header(struct list *the_list, const char *name,
    assert(list_is_valid(the_list));
 
    return result;
+
 }
 
 
@@ -544,7 +576,7 @@ char *list_to_text(const struct list *the_list)
    struct list_entry *cur_entry;
    char *ret = NULL;
    char *s;
-   int size = 2;
+   size_t size = 2;
 
    assert(the_list);
    assert(list_is_valid(the_list));
@@ -1009,6 +1041,71 @@ jb_err map(struct map *the_map,
 }
 
 
+/*********************************************************************
+ *
+ * Function    :  unmap
+ *
+ * Description :  Remove all map_entry structs with a given name from
+ *                a given map.
+ *
+ * Parameters  :
+ *          1  :  the_map = map to look in
+ *          2  :  name = name to unmap
+ *
+ * Returns     :  JB_ERR_OK
+ *
+ *********************************************************************/
+jb_err unmap(struct map *the_map, const char *name)
+{
+   struct map_entry *cur_entry, *last_entry;
+
+   assert(the_map);
+   assert(name);
+   
+   last_entry = the_map->first;
+
+   for (cur_entry = the_map->first; cur_entry != NULL; cur_entry = cur_entry->next)
+   {
+      if (!strcmp(name, cur_entry->name))
+      {
+         /*
+          * Update the incoming pointer
+          */
+         if (cur_entry == the_map->first)
+         {
+            the_map->first = cur_entry->next;
+         }
+         else
+         {
+            last_entry->next = cur_entry->next;
+         }
+
+         /*
+          * Update the map's last pointer 
+          */
+         if (cur_entry == the_map->last)
+         {
+            the_map->last = last_entry;
+         }
+         
+         /*
+          * Free the map_entry
+          */
+         freez(cur_entry->name);
+         freez(cur_entry->value);
+         freez(cur_entry);
+
+         cur_entry = last_entry;
+      }
+      else
+      {
+         last_entry = cur_entry;
+      }
+   }
+   return JB_ERR_OK;
+}
+
+
 /*********************************************************************
  *
  * Function    :  lookup