-const char list_rcs[] = "$Id: list.c,v 1.10 2001/09/16 17:30:24 jongfoster Exp $";
+const char list_rcs[] = "$Id: list.c,v 1.18 2006/12/28 19:21:23 fabiankeil Exp $";
/*********************************************************************
*
* File : $Source: /cvsroot/ijbswa/current/list.c,v $
* Functions declared include:
* `destroy_list', `enlist' and `list_to_text'
*
- * Copyright : Written by and Copyright (C) 2001 the SourceForge
- * IJBSWA team. http://ijbswa.sourceforge.net
+ * Copyright : Written by and Copyright (C) 2001-2007 the SourceForge
+ * Privoxy team. http://www.privoxy.org/
*
* Based on the Internet Junkbuster originally written
- * by and Copyright (C) 1997 Anonymous Coders and
+ * by and Copyright (C) 1997 Anonymous Coders and
* Junkbusters Corporation. http://www.junkbusters.com
*
- * This program is free software; you can redistribute it
+ * This program is free software; you can redistribute it
* and/or modify it under the terms of the GNU General
* Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at
*
* Revisions :
* $Log: list.c,v $
+ * Revision 1.18 2006/12/28 19:21:23 fabiankeil
+ * Fixed gcc43 warning and enabled list_is_valid()'s loop
+ * detection again. It was ineffective since the removal of
+ * the arbitrary list length limit two years ago.
+ *
+ * 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
+ * reduce the amount of error-checking clutter needed.
+ *
* Revision 1.10 2001/09/16 17:30:24 jongfoster
* Fixing a compiler warning.
*
#endif
#include <string.h>
-#ifndef _WIN32
+#if !defined(_WIN32) && !defined(__OS2__)
#include <unistd.h>
#endif
/*********************************************************************
*
- * Function : list_init
+ * Function : init_list
*
* Description : Create a new, empty list in user-allocated memory.
* Caller should allocate a "struct list" variable,
* then pass it to this function.
* (Implementation note: Rather than calling this
* function, you can also just memset the memory to
- * zero, e.g. if you have a larger structure you
- * want to initialize quickly. However, that isn't
+ * zero, e.g. if you have a larger structure you
+ * want to initialize quickly. However, that isn't
* really good design.)
*
* Parameters :
* calling list_init().
*
* (Implementation note: You *can* reuse the_list
- * without calling list_init(), but please don't.
+ * without calling list_init(), but please don't.
* If you want to remove all entries from a list
- * and still have a usable list, then use
+ * and still have a usable list, then use
* list_remove_all().)
*
* Parameters :
for (cur_entry = the_list->first; cur_entry ; cur_entry = next_entry)
{
next_entry = cur_entry->next;
- freez((char *)cur_entry->str);
+ freez(cur_entry->str);
free(cur_entry);
}
* 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 dosn't contain
* circular references. It is likely to crash if
* it's passed complete garbage.
*
#if 1
const struct list_entry *cur_entry;
const struct list_entry *last_entry = NULL;
- int length = 0;
+ int entry = 0;
assert(the_list);
if (cur_entry->str)
{
/*
- * Just check that this string can be accessed - i.e. it's a valid
+ * 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
* 2 : str = string to add to the list (maybe NULL)
*
* Returns : JB_ERR_OK on success
- * JB_ERR_MEMORY on out-of-memory error.
+ * JB_ERR_MEMORY on out-of-memory error.
* On error, the_list will be unchanged.
*
*********************************************************************/
* 2 : str = string to add to the list (maybe NULL)
*
* Returns : JB_ERR_OK on success
- * JB_ERR_MEMORY on out-of-memory error.
+ * JB_ERR_MEMORY on out-of-memory error.
* On error, the_list will be unchanged.
*
*********************************************************************/
}
}
/* else { cur->str = NULL; } - implied by zalloc */
-
+
cur->next = the_list->first;
the_list->first = cur;
* Description : Append a string into a specified string list,
* if & only if it's not there already.
* If the num_significant_chars argument is nonzero,
- * only compare up to the nth character.
+ * only compare up to the nth character.
*
* Parameters :
* 1 : the_list = pointer to list
* for uniqueness test, or 0 to require an exact match.
*
* Returns : JB_ERR_OK on success
- * JB_ERR_MEMORY on out-of-memory error.
+ * JB_ERR_MEMORY on out-of-memory error.
* On error, the_list will be unchanged.
* "Success" does not indicate whether or not the
* item was already in the list.
*
*********************************************************************/
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;
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)
{
* 3 : value = HTTP header value (e.g. "text/html")
*
* Returns : JB_ERR_OK on success
- * JB_ERR_MEMORY on out-of-memory error.
+ * JB_ERR_MEMORY on out-of-memory error.
* On error, the_list will be unchanged.
* "Success" does not indicate whether or not the
* header was already in the list.
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;
assert(list_is_valid(the_list));
return result;
+
}
* Description : Remove all entries from a list. On return, the_list
* is a valid, empty list. Note that this is similar
* to destroy_list(), but the difference is that this
- * function guarantees that the list structure is still
+ * function guarantees that the list structure is still
* valid after the call.
*
* Parameters :
for (cur_entry = the_list->first; cur_entry ; cur_entry = next_entry)
{
next_entry = cur_entry->next;
- freez((char *)cur_entry->str);
+ freez(cur_entry->str);
free(cur_entry);
}
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));
* 1 : src = pointer to source list for copy.
*
* Returns : JB_ERR_OK on success
- * JB_ERR_MEMORY on out-of-memory error.
+ * JB_ERR_MEMORY on out-of-memory error.
* On error, dest will be empty.
*
*********************************************************************/
* 2 : src = pointer to source for merge.
*
* Returns : JB_ERR_OK on success
- * JB_ERR_MEMORY on out-of-memory error.
+ * JB_ERR_MEMORY on out-of-memory error.
* On error, some (but not all) of src might have
* been copied into dest.
*
* Parameters :
* 1 : the_list = pointer to list to test.
*
- * Returns : Nonzero iff the list contains no entries.
+ * Returns : Nonzero if the list contains no entries.
*
*********************************************************************/
int list_is_empty(const struct list *the_list)
{
assert(the_list);
assert(list_is_valid(the_list));
-
+
return (the_list->first == NULL);
}
+/*********************************************************************
+ *
+ * Function : list_contains_item
+ *
+ * Description : Tests whether a list item is already set.
+ * Does not change the list.
+ *
+ * Parameters :
+ * 1 : the_list = list to search in
+ * 2 : str = string to search for
+ *
+ * Returns : TRUE if the item was found,
+ * FALSE otherwise.
+ *
+ *********************************************************************/
+int list_contains_item(const struct list *the_list, const char *str)
+{
+ struct list_entry *entry;
+
+ assert(the_list);
+ assert(list_is_valid(the_list));
+ assert(str);
+
+ for (entry = the_list->first; entry != NULL; entry = entry->next)
+ {
+ if (entry->str == NULL)
+ {
+ /*
+ * NULL pointers are allowed in some lists.
+ * For example for csp->headers in case a
+ * header was removed.
+ */
+ continue;
+ }
+
+ if (0 == strcmp(str, entry->str))
+ {
+ /* Item found */
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+
/*********************************************************************
*
* Function : new_map
return;
}
- for (cur_entry = the_map->first; cur_entry != NULL; cur_entry = next_entry)
+ for (cur_entry = the_map->first; cur_entry != NULL; cur_entry = next_entry)
{
- freez((char *)cur_entry->name);
- freez((char *)cur_entry->value);
+ freez(cur_entry->name);
+ freez(cur_entry->value);
next_entry = cur_entry->next;
free(cur_entry);
* err = map(mymap, "xyz", 1, html_encode(somestring), 0);
*
* err will be set to JB_ERR_MEMORY if either call runs
- * out-of-memory. Without these features, you would
- * need to check the return value of html_encode in the
- * above example for NULL, which (at least) doubles the
+ * out-of-memory. Without these features, you would
+ * need to check the return value of html_encode in the
+ * above example for NULL, which (at least) doubles the
* amount of error-checking code needed.
*
* Parameters :
* 5 : value_needs_copying = flag set if a copy of value should be used
*
* Returns : JB_ERR_OK on success
- * JB_ERR_MEMORY on out-of-memory error.
+ * JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
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
projects / privoxy.git / blobdiff