X-Git-Url: http://www.privoxy.org/gitweb/?p=privoxy.git;a=blobdiff_plain;f=list.c;h=a2d7ff6bc5758d30a4c4b9f02096fff10af73817;hp=d779d4e5c861c07f26a3728b648203b144deb64e;hb=9f13f4b9706b231be792217dabc67adb702eb2ad;hpb=292da21cea2a42b0896d667cff7201ef0ea2894e

diff --git a/list.c b/list.c
index d779d4e5..a2d7ff6b 100644
--- a/list.c
+++ b/list.c
@@ -1,12 +1,11 @@
-const char list_rcs[] = "$Id: list.c,v 1.27 2012/03/04 11:41:32 fabiankeil Exp $";
 /*********************************************************************
  *
  * File        :  $Source: /cvsroot/ijbswa/current/list.c,v $
  *
  * Purpose     :  Declares functions to handle lists.
  *
- * 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
@@ -46,7 +45,7 @@ const char list_rcs[] = "$Id: list.c,v 1.27 2012/03/04 11:41:32 fabiankeil Exp $
 #endif
 #include <string.h>
 
-#if !defined(_WIN32) && !defined(__OS2__)
+#if !defined(_WIN32)
 #include <unistd.h>
 #endif
 
@@ -56,11 +55,9 @@ const char list_rcs[] = "$Id: list.c,v 1.27 2012/03/04 11:41:32 fabiankeil Exp $
 #include "list.h"
 #include "miscutil.h"
 
-const char list_h_rcs[] = LIST_H_VERSION;
-
-
+#ifndef NDEBUG
 static int list_is_valid (const struct list *the_list);
-
+#endif
 
 /*********************************************************************
  *
@@ -127,6 +124,7 @@ void destroy_list (struct list *the_list)
 }
 
 
+#ifndef NDEBUG
 /*********************************************************************
  *
  * Function    :  list_is_valid
@@ -134,7 +132,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.
  *
@@ -146,11 +144,6 @@ void destroy_list (struct list *the_list)
  *********************************************************************/
 static int list_is_valid (const struct list *the_list)
 {
-   /*
-    * If you don't want this check, just change the line below
-    * from "#if 1" to "#if 0".
-    */
-#if 1
    const struct list_entry *cur_entry;
    const struct list_entry *last_entry = NULL;
    int entry = 0;
@@ -203,10 +196,10 @@ static int list_is_valid (const struct list *the_list)
    }
 
    return (the_list->last == last_entry);
-#else
-   return 1;
-#endif
+
 }
+#endif /* ndef NDEBUG */
+
 
 /*********************************************************************
  *
@@ -876,15 +869,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;
+
 }
 
 
@@ -893,7 +895,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.
@@ -977,7 +979,7 @@ jb_err map(struct map *the_map,
 
    assert(the_map);
 
-   if ((NULL == value)
+   if ( (NULL == value)
      || (NULL == name)
      || (NULL == (new_entry = zalloc(sizeof(*new_entry)))))
    {
@@ -1055,7 +1057,7 @@ 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)
    {
@@ -1087,7 +1089,11 @@ jb_err unmap(struct map *the_map, const char *name)
          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
@@ -1111,7 +1117,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.
  *