X-Git-Url: http://www.privoxy.org/gitweb/?p=privoxy.git;a=blobdiff_plain;f=list.c;h=b9963af1965e2af8f9ccd8e3f05ac4599a11b181;hp=6a624c96a7048b1606650bda83226d26e5992de7;hb=66b1e23830d60ea98b0ba2ac5644ef24a45f9c55;hpb=c5c165e95d33f316bc3d9334101b81aefb54d30b diff --git a/list.c b/list.c index 6a624c96..b9963af1 100644 --- a/list.c +++ b/list.c @@ -1,14 +1,11 @@ -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 $ * * 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 @@ -32,101 +29,8 @@ const char list_rcs[] = "$Id: list.c,v 1.18 2006/12/28 19:21:23 fabiankeil Exp $ * or write to the Free Software Foundation, Inc., 59 * Temple Place - Suite 330, Boston, MA 02111-1307, USA. * - * 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. - * - * Revision 1.9 2001/09/16 13:20:29 jongfoster - * Rewrite of list library. Now has seperate header and list_entry - * structures. Also added a large sprinking of assert()s to the list - * code. - * - * Revision 1.8 2001/08/07 14:00:20 oes - * Fixed comment - * - * Revision 1.7 2001/08/05 16:06:20 jongfoster - * Modifiying "struct map" so that there are now separate header and - * "map_entry" structures. This means that functions which modify a - * map no longer need to return a pointer to the modified map. - * Also, it no longer reverses the order of the entries (which may be - * important with some advanced template substitutions). - * - * Revision 1.6 2001/07/31 14:44:51 oes - * list_to_text() now appends empty line at end - * - * Revision 1.5 2001/06/29 21:45:41 oes - * Indentation, CRLF->LF, Tab-> Space - * - * Revision 1.4 2001/06/29 13:30:22 oes - * - Added Convenience function enlist_unique_header(), - * which takes the Header name and value as separate - * arguments and thus saves the pain of sprintf()ing - * and determining the Header name length to enlist_unique - * - Improved comments - * - Removed logentry from cancelled commit - * - * Revision 1.3 2001/06/03 19:12:24 oes - * functions for new struct map, extended enlist_unique - * - * Revision 1.2 2001/06/01 18:49:17 jongfoster - * Replaced "list_share" with "list" - the tiny memory gain was not - * worth the extra complexity. - * - * Revision 1.1 2001/05/31 21:11:53 jongfoster - * - Moved linked list support to new "list.c" file. - * Structure definitions are still in project.h, - * function prototypes are now in "list.h". - * - Added support for "struct list_share", which is identical - * to "struct list" except it saves memory by not duplicating - * the strings. Obviously, this only works if there is some - * other way of managing the memory used by the strings. - * (These list_share lists are used for lists which last - * for only 1 request, and where all the list entries are - * just coming directly from entries in the actionsfile.) - * Note that you still need to destroy list_share lists - * properly to free the nodes - it's only the strings - * which are shared. - * - * *********************************************************************/ - + #include "config.h" @@ -141,7 +45,7 @@ const char list_rcs[] = "$Id: list.c,v 1.18 2006/12/28 19:21:23 fabiankeil Exp $ #endif #include -#if !defined(_WIN32) && !defined(__OS2__) +#if !defined(_WIN32) #include #endif @@ -151,9 +55,6 @@ const char list_rcs[] = "$Id: list.c,v 1.18 2006/12/28 19:21:23 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); @@ -229,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. * @@ -278,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 @@ -446,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 */ @@ -459,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; @@ -494,30 +395,44 @@ 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) { - size_t length; - jb_err result; - char *str; + jb_err result = JB_ERR_MEMORY; + char *header; + size_t header_size; assert(the_list); assert(list_is_valid(the_list)); assert(name); assert(value); - length = strlen(name) + 2; - if (NULL == (str = (char *)malloc(length + strlen(value) + 1))) - { - return JB_ERR_MEMORY; - } - strcpy(str, name); - str[length - 2] = ':'; - str[length - 1] = ' '; - strcpy(str + length, value); + /* + 2 for the ': ', + 1 for the \0 */ + header_size = strlen(name) + 2 + strlen(value) + 1; + header = (char *)malloc(header_size); - result = enlist_unique(the_list, str, length); - - free(str); + if (NULL != header) + { + const size_t bytes_to_compare = strlen(name) + 2; + char *p = header; - assert(list_is_valid(the_list)); + 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)); + } return result; @@ -569,6 +484,9 @@ void list_remove_all(struct list *the_list) * adding an empty line at the end. NULL entries are ignored. * This function does not change the_list. * + * XXX: Should probably be renamed as it's only + * useful (and used) to flatten header lists. + * * Parameters : * 1 : the_list = pointer to list * @@ -579,42 +497,62 @@ void list_remove_all(struct list *the_list) char *list_to_text(const struct list *the_list) { struct list_entry *cur_entry; - char *ret = NULL; - char *s; - size_t size = 2; + char *text; + size_t text_length; + char *cursor; + size_t bytes_left; assert(the_list); assert(list_is_valid(the_list)); - for (cur_entry = the_list->first; cur_entry ; cur_entry = cur_entry->next) + /* + * Calculate the length of the final text. + * '2' because of the '\r\n' at the end of + * each string and at the end of the text. + */ + text_length = 2; + for (cur_entry = the_list->first; cur_entry; cur_entry = cur_entry->next) { if (cur_entry->str) { - size += strlen(cur_entry->str) + 2; + text_length += strlen(cur_entry->str) + 2; } } - if ((ret = (char *)malloc(size + 1)) == NULL) + bytes_left = text_length + 1; + + text = (char *)malloc(bytes_left); + if (NULL == text) { return NULL; } - ret[size] = '\0'; - - s = ret; + cursor = text; - for (cur_entry = the_list->first; cur_entry ; cur_entry = cur_entry->next) + for (cur_entry = the_list->first; cur_entry; cur_entry = cur_entry->next) { if (cur_entry->str) { - strcpy(s, cur_entry->str); - s += strlen(s); - *s++ = '\r'; *s++ = '\n'; + const int written = snprintf(cursor, bytes_left, "%s\r\n", cur_entry->str); + + assert(written > 0); + assert(written < bytes_left); + + bytes_left -= (size_t)written; + cursor += (size_t)written; } } - *s++ = '\r'; *s++ = '\n'; - return ret; + assert(bytes_left == 3); + + *cursor++ = '\r'; + *cursor++ = '\n'; + *cursor = '\0'; + + assert(text_length == cursor - text); + assert(text[text_length] == '\0'); + + return text; } @@ -911,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. */ @@ -934,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; + } @@ -951,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. @@ -993,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. @@ -1037,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)) { @@ -1112,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) { @@ -1132,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 @@ -1169,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. *