-const char list_rcs[] = "$Id: list.c,v 1.9 2001/09/16 13:20:29 jongfoster Exp $";
+const char list_rcs[] = "$Id: list.c,v 1.10 2001/09/16 17:30:24 jongfoster Exp $";
/*********************************************************************
*
* File : $Source: /cvsroot/ijbswa/current/list.c,v $
*
* Revisions :
* $Log: list.c,v $
+ * 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
* 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;
if (NULL == (cur = (struct list_entry *)zalloc(sizeof(*cur))))
{
- return 1;
+ return JB_ERR_MEMORY;
}
if (str)
if (NULL == (cur->str = strdup(str)))
{
free(cur);
- return 1;
+ return JB_ERR_MEMORY;
}
}
/* else { cur->str = NULL; } - implied by zalloc */
}
assert(list_is_valid(the_list));
- return 0;
+ return JB_ERR_OK;
}
* 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;
if (NULL == (cur = (struct list_entry *)zalloc(sizeof(*cur))))
{
- return 1;
+ return JB_ERR_MEMORY;
}
if (str)
if (NULL == (cur->str = strdup(str)))
{
free(cur);
- return 1;
+ return JB_ERR_MEMORY;
}
}
/* else { cur->str = NULL; } - implied by zalloc */
}
assert(list_is_valid(the_list));
- return 0;
+ return JB_ERR_OK;
}
* 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,
+ int num_significant_chars)
{
struct list_entry *cur_entry;
&& (0 == strncmp(str, cur_entry->str, num_significant_chars)))
{
/* Already there */
- return 0;
+ return JB_ERR_OK;
}
}
}
if ( (cur_entry->str != NULL) && (0 == strcmp(str, cur_entry->str)))
{
/* Already there */
- return 0;
+ return JB_ERR_OK;
}
}
}
* 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;
+ jb_err result;
char *str;
assert(the_list);
length = strlen(name) + 2;
if (NULL == (str = (char *)malloc(length + strlen(value) + 1)))
{
- return 1;
+ return JB_ERR_MEMORY;
}
strcpy(str, name);
str[length - 2] = ':';
if ((ret = (char *)malloc(size + 1)) == NULL)
{
- return(NULL);
+ return NULL;
}
ret[size] = '\0';
}
*s++ = '\r'; *s++ = '\n';
- return(ret);
+ return ret;
}
* 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;
assert(list_is_valid(src));
assert(list_is_valid(dest));
- return 1;
+ return JB_ERR_MEMORY;
}
if (cur_src->str)
assert(list_is_valid(src));
assert(list_is_valid(dest));
- return 1;
+ return JB_ERR_MEMORY;
}
}
/* else { cur_dest->str = NULL; } - implied by zalloc */
assert(list_is_valid(src));
assert(list_is_valid(dest));
- return 1;
+ return JB_ERR_MEMORY;
}
if (cur_src->str)
{
assert(list_is_valid(src));
assert(list_is_valid(dest));
- return 1;
+ return JB_ERR_MEMORY;
}
}
/* else { cur_dest->str = NULL; } - implied by zalloc */
assert(list_is_valid(src));
assert(list_is_valid(dest));
- return 0;
+ return JB_ERR_OK;
}
* 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;
assert(list_is_valid(src));
assert(list_is_valid(dest));
- return 1;
+ return JB_ERR_MEMORY;
}
}
}
assert(list_is_valid(src));
assert(list_is_valid(dest));
- return 0;
+ return JB_ERR_OK;
}
* later, set the copy flags for constants or
* strings that will be independantly 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
* 2 : name = name to add
* 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)
if (NULL == (name = strdup(name)))
{
free(new_entry);
- return 1;
+ if (!value_needs_copying)
+ {
+ free((char *)value);
+ }
+ return JB_ERR_MEMORY;
}
}
{
if (NULL == (value = strdup(value)))
{
- if (name_needs_copying)
- {
- free((char *)name);
- }
+ free((char *)name);
free(new_entry);
- return 1;
+ return JB_ERR_MEMORY;
}
}
the_map->last = new_entry;
}
- return 0;
+ return JB_ERR_OK;
}
#ifndef LIST_H_INCLUDED
#define LIST_H_INCLUDED
-#define LIST_H_VERSION "$Id: list.h,v 1.7 2001/09/16 13:20:29 jongfoster Exp $"
+#define LIST_H_VERSION "$Id: list.h,v 1.8 2001/09/16 17:30:24 jongfoster Exp $"
/*********************************************************************
*
* File : $Source: /cvsroot/ijbswa/current/list.h,v $
*
* Revisions :
* $Log: list.h,v $
+ * Revision 1.8 2001/09/16 17:30:24 jongfoster
+ * Fixing a compiler warning.
+ *
* Revision 1.7 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
extern void init_list (struct list *the_list);
extern void destroy_list (struct list *the_list);
-extern int enlist (struct list *the_list, const char *str);
-extern int enlist_unique (struct list *the_list, const char *str, int num_significant_chars);
-extern int enlist_unique_header (struct list *the_list, const char *name, const char *value);
-extern int enlist_first (struct list *the_list, const char *str);
-extern int list_append_list_unique(struct list *dest, const struct list *src);
-extern int list_duplicate (struct list *dest, const struct list *src);
+extern jb_err enlist (struct list *the_list, const char *str);
+extern jb_err enlist_unique (struct list *the_list, const char *str, int num_significant_chars);
+extern jb_err enlist_unique_header (struct list *the_list, const char *name, const char *value);
+extern jb_err enlist_first (struct list *the_list, const char *str);
+extern jb_err list_append_list_unique(struct list *dest, const struct list *src);
+extern jb_err list_duplicate (struct list *dest, const struct list *src);
-extern int list_remove_item(struct list *the_list, const char *str);
-extern int list_remove_list(struct list *dest, const struct list *src);
-extern void list_remove_all (struct list *the_list);
+extern int list_remove_item(struct list *the_list, const char *str);
+extern int list_remove_list(struct list *dest, const struct list *src);
+extern void list_remove_all (struct list *the_list);
-extern int list_is_empty(const struct list *the_list);
+extern int list_is_empty(const struct list *the_list);
extern char * list_to_text(const struct list *the_list);
projects / privoxy.git / commitdiff