X-Git-Url: http://www.privoxy.org/gitweb/?p=privoxy.git;a=blobdiff_plain;f=list.c;h=b9963af1965e2af8f9ccd8e3f05ac4599a11b181;hp=c91521f3926b143c33cf0656c75be557d89430e3;hb=60513e33c518dd45644143581976e601d4d6aa60;hpb=52cf256c05896e5e82b9cac9afbaee41c9c597ab

diff --git a/list.c b/list.c
index c91521f3..b9963af1 100644
--- a/list.c
+++ b/list.c
@@ -1,14 +1,11 @@
-const char list_rcs[] = "$Id: list.c,v 1.22 2010/11/22 10:32:40 fabiankeil Exp $";
 /*********************************************************************
  *
  * File        :  $Source: /cvsroot/ijbswa/current/list.c,v $
  *
  * Purpose     :  Declares functions to handle lists.
- *                Functions declared include:
- *                   `destroy_list', `enlist' and `list_to_text'
  *
- * Copyright   :  Written by and Copyright (C) 2001-2007 the SourceForge
- *                Privoxy team. http://www.privoxy.org/
+ * Copyright   :  Written by and Copyright (C) 2001-2007 members of the
+ *                Privoxy team. https://www.privoxy.org/
  *
  *                Based on the Internet Junkbuster originally written
  *                by and Copyright (C) 1997 Anonymous Coders and
@@ -48,7 +45,7 @@ const char list_rcs[] = "$Id: list.c,v 1.22 2010/11/22 10:32:40 fabiankeil Exp $
 #endif
 #include <string.h>
 
-#if !defined(_WIN32) && !defined(__OS2__)
+#if !defined(_WIN32)
 #include <unistd.h>
 #endif
 
@@ -58,9 +55,6 @@ const char list_rcs[] = "$Id: list.c,v 1.22 2010/11/22 10:32:40 fabiankeil Exp $
 #include "list.h"
 #include "miscutil.h"
 
-const char list_h_rcs[] = LIST_H_VERSION;
-
-
 static int list_is_valid (const struct list *the_list);
 
 
@@ -136,7 +130,7 @@ void destroy_list (struct list *the_list)
  * Description :  Check that a string list is valid.  The intended
  *                usage is "assert(list_is_valid(the_list))".
  *                Currently this checks that "the_list->last"
- *                is correct, and that the list dosn't contain
+ *                is correct, and that the list doesn't contain
  *                circular references.  It is likely to crash if
  *                it's passed complete garbage.
  *
@@ -185,13 +179,13 @@ static int list_is_valid (const struct list *the_list)
        * 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
@@ -353,7 +347,7 @@ jb_err enlist_unique(struct list *the_list, const char *str,
    {
       for (cur_entry = the_list->first; cur_entry != NULL; cur_entry = cur_entry->next)
       {
-         if ( (cur_entry->str != NULL)
+         if ((cur_entry->str != NULL)
            && (0 == strncmp(str, cur_entry->str, num_significant_chars)))
          {
             /* Already there */
@@ -366,7 +360,7 @@ jb_err enlist_unique(struct list *the_list, const char *str,
       /* Test whole string */
       for (cur_entry = the_list->first; cur_entry != NULL; cur_entry = cur_entry->next)
       {
-         if ( (cur_entry->str != NULL) && (0 == strcmp(str, cur_entry->str)))
+         if ((cur_entry->str != NULL) && (0 == strcmp(str, cur_entry->str)))
          {
             /* Already there */
             return JB_ERR_OK;
@@ -417,8 +411,24 @@ jb_err enlist_unique_header(struct list *the_list, const char *name,
    if (NULL != header)
    {
       const size_t bytes_to_compare = strlen(name) + 2;
+      char *p = header;
 
       snprintf(header, header_size, "%s: %s", name, value);
+      /*
+       * The trailing "\r\n" is added by list_to_text(),
+       * if the caller passed them anyway, cut the header
+       * at the first one or dump core if this is a debug
+       * build.
+       */
+      do
+      {
+         if ((*p == '\r') || (*p == '\n'))
+         {
+            assert(*p != '\r');
+            assert(*p != '\n');
+            *p = '\0';
+         }
+      } while (*p++);
       result = enlist_unique(the_list, header, bytes_to_compare);
       free(header);
       assert(list_is_valid(the_list));
@@ -839,7 +849,7 @@ int list_contains_item(const struct list *the_list, const char *str)
       if (entry->str == NULL)
       {
          /*
-          * NULL pointers are allowed in some lists. 
+          * NULL pointers are allowed in some lists.
           * For example for csp->headers in case a
           * header was removed.
           */
@@ -862,15 +872,24 @@ int list_contains_item(const struct list *the_list, const char *str)
  * Function    :  new_map
  *
  * Description :  Create a new, empty map.
+ *                Causes program exit if the memory allocation fails.
  *
  * Parameters  :  N/A
  *
- * Returns     :  A new, empty map, or NULL if out of memory.
+ * Returns     :  A new, empty map
  *
  *********************************************************************/
 struct map *new_map(void)
 {
-   return (struct map *) zalloc(sizeof(struct map));
+   struct map *empty_map = zalloc(sizeof(struct map));
+
+   if (NULL == empty_map)
+   {
+      exit(1);
+   }
+
+   return empty_map;
+
 }
 
 
@@ -879,7 +898,7 @@ struct map *new_map(void)
  * Function    :  free_map
  *
  * Description :  Free the memory occupied by a map and its
- *                depandant strings
+ *                dependent strings
  *
  * Parameters  :
  *          1  :  the_map = map to be freed.  May be NULL.
@@ -921,7 +940,7 @@ void free_map(struct map *the_map)
  *
  *                Note: Since all strings will be free()d in free_map()
  *                      later, set the copy flags for constants or
- *                      strings that will be independantly free()d.
+ *                      strings that will be independently free()d.
  *
  *                Note2: This function allows NULL parameters - it
  *                       returns JB_ERR_MEMORY in that case.
@@ -965,7 +984,7 @@ jb_err map(struct map *the_map,
 
    if ( (NULL == value)
      || (NULL == name)
-     || (NULL == (new_entry = zalloc(sizeof(*new_entry)))) )
+     || (NULL == (new_entry = zalloc(sizeof(*new_entry)))))
    {
       if ((name != NULL) && (!name_needs_copying))
       {
@@ -1040,8 +1059,8 @@ jb_err unmap(struct map *the_map, const char *name)
 
    assert(the_map);
    assert(name);
-   
-   last_entry = the_map->first;
+
+   last_entry = NULL;
 
    for (cur_entry = the_map->first; cur_entry != NULL; cur_entry = cur_entry->next)
    {
@@ -1060,20 +1079,24 @@ jb_err unmap(struct map *the_map, const char *name)
          }
 
          /*
-          * Update the map's last pointer 
+          * 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);
-
+         if (last_entry == NULL)
+         {
+            /* The map only had a single entry which has just been removed. */
+            break;
+         }
          cur_entry = last_entry;
       }
       else
@@ -1097,7 +1120,7 @@ jb_err unmap(struct map *the_map, const char *name)
  *          2  :  name = name parameter to look for
  *
  * Returns     :  the value if found, else the empty string.
- *                Return value is alloced as part of the map, so
+ *                Return value is allocated as part of the map, so
  *                it is freed when the map is destroyed.  Caller
  *                must not free or modify it.
  *