X-Git-Url: http://www.privoxy.org/gitweb/?p=privoxy.git;a=blobdiff_plain;f=list.c;h=b9963af1965e2af8f9ccd8e3f05ac4599a11b181;hp=030f0b80231771881a6c41bacda6d3f568eeca21;hb=a473a2a85dbf5325b270a906e85785ba4b032503;hpb=1806b665d35568d25f7d90fa17551881d21ca441 diff --git a/list.c b/list.c index 030f0b80..b9963af1 100644 --- a/list.c +++ b/list.c @@ -1,20 +1,17 @@ -const char list_rcs[] = "$Id: list.c,v 1.8 2001/08/07 14:00:20 oes 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 the SourceForge - * IJBSWA team. http://ijbswa.sourceforge.net + * 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 + * 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 @@ -32,91 +29,46 @@ const char list_rcs[] = "$Id: list.c,v 1.8 2001/08/07 14:00:20 oes 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.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" +#ifndef _WIN32 +/* FIXME: The following headers are not needed for Win32. Are they + * needed on other platforms? + */ #include #include #include #include +#endif #include -#ifndef _WIN32 +#if !defined(_WIN32) #include #endif #include #include "project.h" -#include "jcc.h" #include "list.h" #include "miscutil.h" -const char list_h_rcs[] = LIST_H_VERSION; +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, * 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 : @@ -142,9 +94,9 @@ void init_list(struct list *the_list) * 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 : @@ -162,7 +114,7 @@ void destroy_list (struct list *the_list) 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); } @@ -178,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. * @@ -197,7 +149,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); @@ -208,27 +160,32 @@ static int list_is_valid (const struct list *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. + * 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 (++length > 1000) + /* + if (entry > 1000) { return 0; } + */ /* * Check this isn't marked as the last entry, unless of course it's @@ -257,11 +214,12 @@ static int list_is_valid (const struct list *the_list) * 1 : the_list = pointer to list * 2 : str = string to add to the list (maybe NULL) * - * Returns : 0 on success, nonzero on out-of-memory error. On - * error, the_list will be unchanged. + * Returns : JB_ERR_OK on success + * JB_ERR_MEMORY on out-of-memory error. + * On error, the_list will be unchanged. * *********************************************************************/ -int enlist(struct list *the_list, const char *str) +jb_err enlist(struct list *the_list, const char *str) { struct list_entry *cur; @@ -270,7 +228,7 @@ int enlist(struct list *the_list, const char *str) if (NULL == (cur = (struct list_entry *)zalloc(sizeof(*cur)))) { - return 1; + return JB_ERR_MEMORY; } if (str) @@ -278,7 +236,7 @@ int enlist(struct list *the_list, const char *str) if (NULL == (cur->str = strdup(str))) { free(cur); - return 1; + return JB_ERR_MEMORY; } } /* else { cur->str = NULL; } - implied by zalloc */ @@ -297,7 +255,7 @@ int enlist(struct list *the_list, const char *str) } assert(list_is_valid(the_list)); - return 0; + return JB_ERR_OK; } @@ -312,11 +270,12 @@ int enlist(struct list *the_list, const char *str) * 1 : the_list = pointer to list * 2 : str = string to add to the list (maybe NULL) * - * Returns : 0 on success, nonzero on out-of-memory error. On - * error, the_list will be unchanged. + * Returns : JB_ERR_OK on success + * JB_ERR_MEMORY on out-of-memory error. + * On error, the_list will be unchanged. * *********************************************************************/ -int enlist_first(struct list *the_list, const char *str) +jb_err enlist_first(struct list *the_list, const char *str) { struct list_entry *cur; @@ -325,7 +284,7 @@ int enlist_first(struct list *the_list, const char *str) if (NULL == (cur = (struct list_entry *)zalloc(sizeof(*cur)))) { - return 1; + return JB_ERR_MEMORY; } if (str) @@ -333,11 +292,11 @@ int enlist_first(struct list *the_list, const char *str) if (NULL == (cur->str = strdup(str))) { free(cur); - return 1; + return JB_ERR_MEMORY; } } /* else { cur->str = NULL; } - implied by zalloc */ - + cur->next = the_list->first; the_list->first = cur; @@ -347,7 +306,7 @@ int enlist_first(struct list *the_list, const char *str) } assert(list_is_valid(the_list)); - return 0; + return JB_ERR_OK; } @@ -358,7 +317,7 @@ int enlist_first(struct list *the_list, const char *str) * 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 @@ -366,14 +325,15 @@ int enlist_first(struct list *the_list, const char *str) * 3 : num_significant_chars = number of chars to use * for uniqueness test, or 0 to require an exact match. * - * Returns : 0 on success, nonzero 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. + * Returns : JB_ERR_OK on success + * 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. * *********************************************************************/ -int enlist_unique(struct list *the_list, const char *str, - int num_significant_chars) +jb_err enlist_unique(struct list *the_list, const char *str, + size_t num_significant_chars) { struct list_entry *cur_entry; @@ -381,17 +341,17 @@ int 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) { 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 */ - return 0; + return JB_ERR_OK; } } } @@ -400,10 +360,10 @@ int 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 0; + return JB_ERR_OK; } } } @@ -425,40 +385,57 @@ int enlist_unique(struct list *the_list, const char *str, * 2 : name = HTTP header name (e.g. "Content-type") * 3 : value = HTTP header value (e.g. "text/html") * - * Returns : 0 on success, nonzero 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. + * Returns : JB_ERR_OK on success + * 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. * *********************************************************************/ -int enlist_unique_header(struct list *the_list, const char *name, const char *value) +jb_err enlist_unique_header(struct list *the_list, const char *name, + const char *value) { - int length; - int 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 1; - } - 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; + } @@ -469,7 +446,7 @@ int enlist_unique_header(struct list *the_list, const char *name, const char *va * 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 : @@ -489,7 +466,7 @@ void list_remove_all(struct list *the_list) 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); } @@ -507,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 * @@ -517,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; - int 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); + 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; } @@ -667,11 +667,12 @@ int list_remove_list(struct list *dest, const struct list *src) * All existing entries will be removed. * 1 : src = pointer to source list for copy. * - * Returns : 0 on success, nonzero on error. On error, dest - * will be empty. + * Returns : JB_ERR_OK on success + * JB_ERR_MEMORY on out-of-memory error. + * On error, dest will be empty. * *********************************************************************/ -int list_duplicate(struct list *dest, const struct list *src) +jb_err list_duplicate(struct list *dest, const struct list *src) { struct list_entry * cur_src; struct list_entry * cur_dest; @@ -695,7 +696,7 @@ int list_duplicate(struct list *dest, const struct list *src) assert(list_is_valid(src)); assert(list_is_valid(dest)); - return 1; + return JB_ERR_MEMORY; } if (cur_src->str) @@ -708,7 +709,7 @@ int list_duplicate(struct list *dest, const struct list *src) assert(list_is_valid(src)); assert(list_is_valid(dest)); - return 1; + return JB_ERR_MEMORY; } } /* else { cur_dest->str = NULL; } - implied by zalloc */ @@ -724,7 +725,7 @@ int list_duplicate(struct list *dest, const struct list *src) assert(list_is_valid(src)); assert(list_is_valid(dest)); - return 1; + return JB_ERR_MEMORY; } if (cur_src->str) { @@ -736,7 +737,7 @@ int list_duplicate(struct list *dest, const struct list *src) assert(list_is_valid(src)); assert(list_is_valid(dest)); - return 1; + return JB_ERR_MEMORY; } } /* else { cur_dest->str = NULL; } - implied by zalloc */ @@ -748,7 +749,7 @@ int list_duplicate(struct list *dest, const struct list *src) assert(list_is_valid(src)); assert(list_is_valid(dest)); - return 0; + return JB_ERR_OK; } @@ -763,12 +764,13 @@ int list_duplicate(struct list *dest, const struct list *src) * 1 : dest = pointer to destination list for merge. * 2 : src = pointer to source for merge. * - * Returns : 0 on success, nonzero on out-of-memory error. + * Returns : JB_ERR_OK on success + * JB_ERR_MEMORY on out-of-memory error. * On error, some (but not all) of src might have * been copied into dest. * *********************************************************************/ -int list_append_list_unique(struct list *dest, const struct list *src) +jb_err list_append_list_unique(struct list *dest, const struct list *src) { struct list_entry * cur; @@ -786,7 +788,7 @@ int list_append_list_unique(struct list *dest, const struct list *src) assert(list_is_valid(src)); assert(list_is_valid(dest)); - return 1; + return JB_ERR_MEMORY; } } } @@ -794,7 +796,7 @@ int list_append_list_unique(struct list *dest, const struct list *src) assert(list_is_valid(src)); assert(list_is_valid(dest)); - return 0; + return JB_ERR_OK; } @@ -807,32 +809,87 @@ int list_append_list_unique(struct list *dest, const struct list *src) * 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 * * 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; + } @@ -841,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. @@ -859,10 +916,10 @@ void free_map(struct map *the_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); @@ -883,7 +940,28 @@ 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. + * + * Note3: If this function returns JB_ERR_MEMORY, + * it will free(name) unless you specify + * name_needs_copying, and similarly it will + * free(value) unless you specify + * value_needs_copying. + * + * Due to Note2 and Note3 above, the following code + * is legal, and will never crash or leak memory even + * if the system runs out of memory: + * + * 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 + * amount of error-checking code needed. * * Parameters : * 1 : the_map = map to add to @@ -892,22 +970,31 @@ void free_map(struct map *the_map) * 4 : value = value to add * 5 : value_needs_copying = flag set if a copy of value should be used * - * Returns : 0 on success, nonzero on out-of-memory error. + * Returns : JB_ERR_OK on success + * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -int map(struct map *the_map, - const char *name, int name_needs_copying, - const char *value, int value_needs_copying) +jb_err map(struct map *the_map, + const char *name, int name_needs_copying, + const char *value, int value_needs_copying) { struct map_entry *new_entry; assert(the_map); - assert(name); - assert(value); - if (NULL == (new_entry = zalloc(sizeof(*new_entry)))) + if ( (NULL == value) + || (NULL == name) + || (NULL == (new_entry = zalloc(sizeof(*new_entry))))) { - return 1; + if ((name != NULL) && (!name_needs_copying)) + { + free((char *)name); + } + if ((value != NULL) && (!value_needs_copying)) + { + free((char *)value); + } + return JB_ERR_MEMORY; } if (name_needs_copying) @@ -915,7 +1002,11 @@ int map(struct map *the_map, if (NULL == (name = strdup(name))) { free(new_entry); - return 1; + if (!value_needs_copying) + { + free((char *)value); + } + return JB_ERR_MEMORY; } } @@ -923,12 +1014,9 @@ int map(struct map *the_map, { if (NULL == (value = strdup(value))) { - if (name_needs_copying) - { - free((char *)name); - } + free((char *)name); free(new_entry); - return 1; + return JB_ERR_MEMORY; } } @@ -947,7 +1035,76 @@ int map(struct map *the_map, the_map->last = new_entry; } - return 0; + return JB_ERR_OK; +} + + +/********************************************************************* + * + * 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 = NULL; + + 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); + if (last_entry == NULL) + { + /* The map only had a single entry which has just been removed. */ + break; + } + cur_entry = last_entry; + } + else + { + last_entry = cur_entry; + } + } + return JB_ERR_OK; } @@ -963,7 +1120,7 @@ int map(struct map *the_map, * 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. *