list.c

   1 const char list_rcs[] = "$Id: list.c,v 1.13 2002/03/07 03:46:17 oes Exp $";
   2 /*********************************************************************
   3  *
   4  * File        :  $Source: /cvsroot/ijbswa/current/list.c,v $
   5  *
   6  * Purpose     :  Declares functions to handle lists.
   7  *                Functions declared include:
   8  *                   `destroy_list', `enlist' and `list_to_text'
   9  *
  10  * Copyright   :  Written by and Copyright (C) 2001 the SourceForge
  11  *                Privoxy team.  http://ijbswa.sourceforge.net
  12  *
  13  *                Based on the Internet Junkbuster originally written
  14  *                by and Copyright (C) 1997 Anonymous Coders and
  15  *                Junkbusters Corporation.  http://www.junkbusters.com
  16  *
  17  *                This program is free software; you can redistribute it
  18  *                and/or modify it under the terms of the GNU General
  19  *                Public License as published by the Free Software
  20  *                Foundation; either version 2 of the License, or (at
  21  *                your option) any later version.
  22  *
  23  *                This program is distributed in the hope that it will
  24  *                be useful, but WITHOUT ANY WARRANTY; without even the
  25  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
  26  *                PARTICULAR PURPOSE.  See the GNU General Public
  27  *                License for more details.
  28  *
  29  *                The GNU General Public License should be included with
  30  *                this file.  If not, you can view it at
  31  *                http://www.gnu.org/copyleft/gpl.html
  32  *                or write to the Free Software Foundation, Inc., 59
  33  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  34  *
  35  * Revisions   :
  36  *    $Log: list.c,v $
  37  *    Revision 1.13  2002/03/07 03:46:17  oes
  38  *    Fixed compiler warnings
  39  *
  40  *    Revision 1.12  2001/10/25 03:40:48  david__schmidt
  41  *    Change in porting tactics: OS/2's EMX porting layer doesn't allow multiple
  42  *    threads to call select() simultaneously.  So, it's time to do a real, live,
  43  *    native OS/2 port.  See defines for __EMX__ (the porting layer) vs. __OS2__
  44  *    (native). Both versions will work, but using __OS2__ offers multi-threading.
  45  *
  46  *    Revision 1.11  2001/10/23 21:21:03  jongfoster
  47  *    New error handling - error codes are now jb_errs, not ints.
  48  *    Changed the way map() handles out-of-memory, to dramatically
  49  *    reduce the amount of error-checking clutter needed.
  50  *
  51  *    Revision 1.10  2001/09/16 17:30:24  jongfoster
  52  *    Fixing a compiler warning.
  53  *
  54  *    Revision 1.9  2001/09/16 13:20:29  jongfoster
  55  *    Rewrite of list library.  Now has seperate header and list_entry
  56  *    structures.  Also added a large sprinking of assert()s to the list
  57  *    code.
  58  *
  59  *    Revision 1.8  2001/08/07 14:00:20  oes
  60  *    Fixed comment
  61  *
  62  *    Revision 1.7  2001/08/05 16:06:20  jongfoster
  63  *    Modifiying "struct map" so that there are now separate header and
  64  *    "map_entry" structures.  This means that functions which modify a
  65  *    map no longer need to return a pointer to the modified map.
  66  *    Also, it no longer reverses the order of the entries (which may be
  67  *    important with some advanced template substitutions).
  68  *
  69  *    Revision 1.6  2001/07/31 14:44:51  oes
  70  *    list_to_text() now appends empty line at end
  71  *
  72  *    Revision 1.5  2001/06/29 21:45:41  oes
  73  *    Indentation, CRLF->LF, Tab-> Space
  74  *
  75  *    Revision 1.4  2001/06/29 13:30:22  oes
  76  *    - Added Convenience function enlist_unique_header(),
  77  *      which takes the Header name and value as separate
  78  *      arguments and thus saves the pain of sprintf()ing
  79  *      and determining the Header name length to enlist_unique
  80  *    - Improved comments
  81  *    - Removed logentry from cancelled commit
  82  *
  83  *    Revision 1.3  2001/06/03 19:12:24  oes
  84  *    functions for new struct map, extended enlist_unique
  85  *
  86  *    Revision 1.2  2001/06/01 18:49:17  jongfoster
  87  *    Replaced "list_share" with "list" - the tiny memory gain was not
  88  *    worth the extra complexity.
  89  *
  90  *    Revision 1.1  2001/05/31 21:11:53  jongfoster
  91  *    - Moved linked list support to new "list.c" file.
  92  *      Structure definitions are still in project.h,
  93  *      function prototypes are now in "list.h".
  94  *    - Added support for "struct list_share", which is identical
  95  *      to "struct list" except it saves memory by not duplicating
  96  *      the strings.  Obviously, this only works if there is some
  97  *      other way of managing the memory used by the strings.
  98  *      (These list_share lists are used for lists which last
  99  *      for only 1 request, and where all the list entries are
 100  *      just coming directly from entries in the actionsfile.)
 101  *      Note that you still need to destroy list_share lists
 102  *      properly to free the nodes - it's only the strings
 103  *      which are shared.
 104  *
 105  *
 106  *********************************************************************/
 107 \f
 108
 109 #include "config.h"
 110
 111 #ifndef _WIN32
 112 /* FIXME: The following headers are not needed for Win32.  Are they
 113  * needed on other platforms?
 114  */
 115 #include <stdio.h>
 116 #include <sys/types.h>
 117 #include <stdlib.h>
 118 #include <ctype.h>
 119 #endif
 120 #include <string.h>
 121
 122 #if !defined(_WIN32) && !defined(__OS2__)
 123 #include <unistd.h>
 124 #endif
 125
 126 #include <assert.h>
 127
 128 #include "project.h"
 129 #include "list.h"
 130 #include "miscutil.h"
 131
 132 const char list_h_rcs[] = LIST_H_VERSION;
 133
 134
 135 static int list_is_valid (const struct list *the_list);
 136
 137
 138 /*********************************************************************
 139  *
 140  * Function    :  list_init
 141  *
 142  * Description :  Create a new, empty list in user-allocated memory.
 143  *                Caller should allocate a "struct list" variable,
 144  *                then pass it to this function.
 145  *                (Implementation note:  Rather than calling this
 146  *                function, you can also just memset the memory to
 147  *                zero, e.g. if you have a larger structure you
 148  *                want to initialize quickly.  However, that isn't
 149  *                really good design.)
 150  *
 151  * Parameters  :
 152  *          1  :  the_list = pointer to list
 153  *
 154  * Returns     :  N/A
 155  *
 156  *********************************************************************/
 157 void init_list(struct list *the_list)
 158 {
 159    memset(the_list, '\0', sizeof(*the_list));
 160 }
 161
 162
 163 /*********************************************************************
 164  *
 165  * Function    :  destroy_list
 166  *
 167  * Description :  Destroy a string list (opposite of list_init).
 168  *                On return, the memory used by the list entries has
 169  *                been freed, but not the memory used by the_list
 170  *                itself.  You should not re-use the_list without
 171  *                calling list_init().
 172  *
 173  *                (Implementation note:  You *can* reuse the_list
 174  *                without calling list_init(), but please don't.
 175  *                If you want to remove all entries from a list
 176  *                and still have a usable list, then use
 177  *                list_remove_all().)
 178  *
 179  * Parameters  :
 180  *          1  :  the_list = pointer to list
 181  *
 182  * Returns     :  N/A
 183  *
 184  *********************************************************************/
 185 void destroy_list (struct list *the_list)
 186 {
 187    struct list_entry *cur_entry, *next_entry;
 188
 189    assert(the_list);
 190
 191    for (cur_entry = the_list->first; cur_entry ; cur_entry = next_entry)
 192    {
 193       next_entry = cur_entry->next;
 194       freez(cur_entry->str);
 195       free(cur_entry);
 196    }
 197
 198    the_list->first = NULL;
 199    the_list->last = NULL;
 200 }
 201
 202
 203 /*********************************************************************
 204  *
 205  * Function    :  list_is_valid
 206  *
 207  * Description :  Check that a string list is valid.  The intended
 208  *                usage is "assert(list_is_valid(the_list))".
 209  *                Currently this checks that "the_list->last"
 210  *                is correct, and that the list dosn't contain
 211  *                circular references.  It is likely to crash if
 212  *                it's passed complete garbage.
 213  *
 214  * Parameters  :
 215  *          1  :  the_list = pointer to list.  Must be non-null.
 216  *
 217  * Returns     :  1 if list is valid, 0 otherwise.
 218  *
 219  *********************************************************************/
 220 static int list_is_valid (const struct list *the_list)
 221 {
 222    /*
 223     * If you don't want this check, just change the line below
 224     * from "#if 1" to "#if 0".
 225     */
 226 #if 1
 227    const struct list_entry *cur_entry;
 228    const struct list_entry *last_entry = NULL;
 229    int length = 0;
 230
 231    assert(the_list);
 232
 233    for (cur_entry = the_list->first; cur_entry ; cur_entry = cur_entry->next)
 234    {
 235       last_entry = cur_entry;
 236
 237       if (cur_entry->str)
 238       {
 239          /*
 240           * Just check that this string can be accessed - i.e. it's a valid
 241           * pointer.
 242           */
 243          strlen(cur_entry->str);
 244       }
 245
 246       /*
 247        * Check for looping back to first
 248        */
 249       if ((length != 0) && (cur_entry == the_list->first))
 250       {
 251          return 0;
 252       }
 253
 254       /*
 255        * Arbitrarily limit length to prevent infinite loops.
 256        */
 257       if (++length > 1000)
 258       {
 259          return 0;
 260       }
 261
 262       /*
 263        * Check this isn't marked as the last entry, unless of course it's
 264        * *really* the last entry.
 265        */
 266       if ((the_list->last == cur_entry) && (cur_entry->next != NULL))
 267       {
 268          /* This is the last entry, but there's data after it !!?? */
 269          return 0;
 270       }
 271    }
 272
 273    return (the_list->last == last_entry);
 274 #else
 275    return 1;
 276 #endif
 277 }
 278
 279 /*********************************************************************
 280  *
 281  * Function    :  enlist
 282  *
 283  * Description :  Append a string into a specified string list.
 284  *
 285  * Parameters  :
 286  *          1  :  the_list = pointer to list
 287  *          2  :  str = string to add to the list (maybe NULL)
 288  *
 289  * Returns     :  JB_ERR_OK on success
 290  *                JB_ERR_MEMORY on out-of-memory error.
 291  *                On error, the_list will be unchanged.
 292  *
 293  *********************************************************************/
 294 jb_err enlist(struct list *the_list, const char *str)
 295 {
 296    struct list_entry *cur;
 297
 298    assert(the_list);
 299    assert(list_is_valid(the_list));
 300
 301    if (NULL == (cur = (struct list_entry *)zalloc(sizeof(*cur))))
 302    {
 303       return JB_ERR_MEMORY;
 304    }
 305
 306    if (str)
 307    {
 308       if (NULL == (cur->str = strdup(str)))
 309       {
 310          free(cur);
 311          return JB_ERR_MEMORY;
 312       }
 313    }
 314    /* else { cur->str = NULL; }  - implied by zalloc */
 315
 316    /* cur->next = NULL;  - implied by zalloc */
 317
 318    if (the_list->last)
 319    {
 320       the_list->last->next = cur;
 321       the_list->last = cur;
 322    }
 323    else
 324    {
 325       the_list->first = cur;
 326       the_list->last = cur;
 327    }
 328
 329    assert(list_is_valid(the_list));
 330    return JB_ERR_OK;
 331 }
 332
 333
 334 /*********************************************************************
 335  *
 336  * Function    :  enlist_first
 337  *
 338  * Description :  Append a string as first element into a specified
 339  *                string list.
 340  *
 341  * Parameters  :
 342  *          1  :  the_list = pointer to list
 343  *          2  :  str = string to add to the list (maybe NULL)
 344  *
 345  * Returns     :  JB_ERR_OK on success
 346  *                JB_ERR_MEMORY on out-of-memory error.
 347  *                On error, the_list will be unchanged.
 348  *
 349  *********************************************************************/
 350 jb_err enlist_first(struct list *the_list, const char *str)
 351 {
 352    struct list_entry *cur;
 353
 354    assert(the_list);
 355    assert(list_is_valid(the_list));
 356
 357    if (NULL == (cur = (struct list_entry *)zalloc(sizeof(*cur))))
 358    {
 359       return JB_ERR_MEMORY;
 360    }
 361
 362    if (str)
 363    {
 364       if (NULL == (cur->str = strdup(str)))
 365       {
 366          free(cur);
 367          return JB_ERR_MEMORY;
 368       }
 369    }
 370    /* else { cur->str = NULL; }  - implied by zalloc */
 371
 372    cur->next = the_list->first;
 373
 374    the_list->first = cur;
 375    if (the_list->last == NULL)
 376    {
 377       the_list->last = cur;
 378    }
 379
 380    assert(list_is_valid(the_list));
 381    return JB_ERR_OK;
 382 }
 383
 384
 385 /*********************************************************************
 386  *
 387  * Function    :  enlist_unique
 388  *
 389  * Description :  Append a string into a specified string list,
 390  *                if & only if it's not there already.
 391  *                If the num_significant_chars argument is nonzero,
 392  *                only compare up to the nth character.
 393  *
 394  * Parameters  :
 395  *          1  :  the_list = pointer to list
 396  *          2  :  str = string to add to the list
 397  *          3  :  num_significant_chars = number of chars to use
 398  *                for uniqueness test, or 0 to require an exact match.
 399  *
 400  * Returns     :  JB_ERR_OK on success
 401  *                JB_ERR_MEMORY on out-of-memory error.
 402  *                On error, the_list will be unchanged.
 403  *                "Success" does not indicate whether or not the
 404  *                item was already in the list.
 405  *
 406  *********************************************************************/
 407 jb_err enlist_unique(struct list *the_list, const char *str,
 408                      size_t num_significant_chars)
 409 {
 410    struct list_entry *cur_entry;
 411
 412    assert(the_list);
 413    assert(list_is_valid(the_list));
 414    assert(str);
 415    assert(num_significant_chars >= 0);
 416    assert(num_significant_chars <= strlen(str));
 417
 418    if (num_significant_chars > 0)
 419    {
 420       for (cur_entry = the_list->first; cur_entry != NULL; cur_entry = cur_entry->next)
 421       {
 422          if ( (cur_entry->str != NULL)
 423            && (0 == strncmp(str, cur_entry->str, num_significant_chars)))
 424          {
 425             /* Already there */
 426             return JB_ERR_OK;
 427          }
 428       }
 429    }
 430    else
 431    {
 432       /* Test whole string */
 433       for (cur_entry = the_list->first; cur_entry != NULL; cur_entry = cur_entry->next)
 434       {
 435          if ( (cur_entry->str != NULL) && (0 == strcmp(str, cur_entry->str)))
 436          {
 437             /* Already there */
 438             return JB_ERR_OK;
 439          }
 440       }
 441    }
 442
 443    return enlist(the_list, str);
 444 }
 445
 446
 447 /*********************************************************************
 448  *
 449  * Function    :  enlist_unique_header
 450  *
 451  * Description :  Make a HTTP header from the two strings name and value,
 452  *                and append the result into a specified string list,
 453  *                if & only if there isn't already a header with that name.
 454  *
 455  * Parameters  :
 456  *          1  :  the_list = pointer to list
 457  *          2  :  name = HTTP header name (e.g. "Content-type")
 458  *          3  :  value = HTTP header value (e.g. "text/html")
 459  *
 460  * Returns     :  JB_ERR_OK on success
 461  *                JB_ERR_MEMORY on out-of-memory error.
 462  *                On error, the_list will be unchanged.
 463  *                "Success" does not indicate whether or not the
 464  *                header was already in the list.
 465  *
 466  *********************************************************************/
 467 jb_err enlist_unique_header(struct list *the_list, const char *name,
 468                             const char *value)
 469 {
 470    size_t length;
 471    jb_err result;
 472    char *str;
 473
 474    assert(the_list);
 475    assert(list_is_valid(the_list));
 476    assert(name);
 477    assert(value);
 478
 479    length = strlen(name) + 2;
 480    if (NULL == (str = (char *)malloc(length + strlen(value) + 1)))
 481    {
 482       return JB_ERR_MEMORY;
 483    }
 484    strcpy(str, name);
 485    str[length - 2] = ':';
 486    str[length - 1] = ' ';
 487    strcpy(str + length, value);
 488
 489    result = enlist_unique(the_list, str, length);
 490
 491    free(str);
 492
 493    assert(list_is_valid(the_list));
 494
 495    return result;
 496
 497 }
 498
 499
 500 /*********************************************************************
 501  *
 502  * Function    :  list_remove_all
 503  *
 504  * Description :  Remove all entries from a list.  On return, the_list
 505  *                is a valid, empty list.  Note that this is similar
 506  *                to destroy_list(), but the difference is that this
 507  *                function guarantees that the list structure is still
 508  *                valid after the call.
 509  *
 510  * Parameters  :
 511  *          1  :  the_list = pointer to list
 512  *
 513  * Returns     :  N/A
 514  *
 515  *********************************************************************/
 516 void list_remove_all(struct list *the_list)
 517 {
 518    struct list_entry *cur_entry;
 519    struct list_entry *next_entry;
 520
 521    assert(the_list);
 522    assert(list_is_valid(the_list));
 523
 524    for (cur_entry = the_list->first; cur_entry ; cur_entry = next_entry)
 525    {
 526       next_entry = cur_entry->next;
 527       freez(cur_entry->str);
 528       free(cur_entry);
 529    }
 530
 531    the_list->first = the_list->last = NULL;
 532
 533    assert(list_is_valid(the_list));
 534 }
 535
 536
 537 /*********************************************************************
 538  *
 539  * Function    :  list_to_text
 540  *
 541  * Description :  "Flatten" a string list into 1 long \r\n delimited string,
 542  *                adding an empty line at the end.  NULL entries are ignored.
 543  *                This function does not change the_list.
 544  *
 545  * Parameters  :
 546  *          1  :  the_list = pointer to list
 547  *
 548  * Returns     :  NULL on malloc error, else new long string.
 549  *                Caller must free() it.
 550  *
 551  *********************************************************************/
 552 char *list_to_text(const struct list *the_list)
 553 {
 554    struct list_entry *cur_entry;
 555    char *ret = NULL;
 556    char *s;
 557    size_t size = 2;
 558
 559    assert(the_list);
 560    assert(list_is_valid(the_list));
 561
 562    for (cur_entry = the_list->first; cur_entry ; cur_entry = cur_entry->next)
 563    {
 564       if (cur_entry->str)
 565       {
 566          size += strlen(cur_entry->str) + 2;
 567       }
 568    }
 569
 570    if ((ret = (char *)malloc(size + 1)) == NULL)
 571    {
 572       return NULL;
 573    }
 574
 575    ret[size] = '\0';
 576
 577    s = ret;
 578
 579    for (cur_entry = the_list->first; cur_entry ; cur_entry = cur_entry->next)
 580    {
 581       if (cur_entry->str)
 582       {
 583          strcpy(s, cur_entry->str);
 584          s += strlen(s);
 585          *s++ = '\r'; *s++ = '\n';
 586       }
 587    }
 588    *s++ = '\r'; *s++ = '\n';
 589
 590    return ret;
 591 }
 592
 593
 594 /*********************************************************************
 595  *
 596  * Function    :  list_remove_item
 597  *
 598  * Description :  Remove a string from a specified string list.
 599  *
 600  * Parameters  :
 601  *          1  :  the_list = pointer to list
 602  *          2  :  str = string to remove from the list - non-NULL
 603  *
 604  * Returns     :  Number of times it was removed.
 605  *
 606  *********************************************************************/
 607 int list_remove_item(struct list *the_list, const char *str)
 608 {
 609    struct list_entry *prev = NULL;
 610    struct list_entry *cur;
 611    struct list_entry *next;
 612    int count = 0;
 613
 614    assert(the_list);
 615    assert(list_is_valid(the_list));
 616    assert(str);
 617
 618    cur = the_list->first;
 619
 620    while (cur != NULL)
 621    {
 622       next = cur->next;
 623
 624       if ((cur->str != NULL) && (0 == strcmp(str, cur->str)))
 625       {
 626          count++;
 627
 628          if (prev != NULL)
 629          {
 630             prev->next = next;
 631          }
 632          else
 633          {
 634             the_list->first = next;
 635          }
 636          free((char *)cur->str);
 637          free(cur);
 638       }
 639       else
 640       {
 641          prev = cur;
 642       }
 643       cur = next;
 644    }
 645
 646    the_list->last = prev;
 647
 648    assert(list_is_valid(the_list));
 649
 650    return count;
 651 }
 652
 653
 654 /*********************************************************************
 655  *
 656  * Function    :  list_remove_list
 657  *
 658  * Description :  Remove all strings in one list from another list.
 659  *                This is currently a brute-force algorithm
 660  *                (it compares every pair of strings).
 661  *
 662  * Parameters  :
 663  *          1  :  dest = list to change
 664  *          2  :  src = list of strings to remove
 665  *
 666  * Returns     :  Total number of strings removed.
 667  *
 668  *********************************************************************/
 669 int list_remove_list(struct list *dest, const struct list *src)
 670 {
 671    struct list_entry *cur;
 672    int count = 0;
 673
 674    assert(src);
 675    assert(dest);
 676    assert(list_is_valid(src));
 677    assert(list_is_valid(dest));
 678
 679    for (cur = src->first; cur != NULL; cur = cur->next)
 680    {
 681       if (cur->str != NULL)
 682       {
 683          count += list_remove_item(dest, cur->str);
 684       }
 685    }
 686
 687    assert(list_is_valid(src));
 688    assert(list_is_valid(dest));
 689
 690    return count;
 691 }
 692
 693
 694 /*********************************************************************
 695  *
 696  * Function    :  list_duplicate
 697  *
 698  * Description :  Copy a string list
 699  *
 700  * Parameters  :
 701  *          1  :  dest = Destination list.  Must be a valid list.
 702  *                       All existing entries will be removed.
 703  *          1  :  src = pointer to source list for copy.
 704  *
 705  * Returns     :  JB_ERR_OK on success
 706  *                JB_ERR_MEMORY on out-of-memory error.
 707  *                On error, dest will be empty.
 708  *
 709  *********************************************************************/
 710 jb_err list_duplicate(struct list *dest, const struct list *src)
 711 {
 712    struct list_entry * cur_src;
 713    struct list_entry * cur_dest;
 714
 715    assert(src);
 716    assert(dest);
 717    assert(list_is_valid(src));
 718    assert(list_is_valid(dest));
 719
 720    list_remove_all(dest);
 721
 722    /* Need to process first entry specially so we can set dest->first */
 723    cur_src = src->first;
 724    if (cur_src)
 725    {
 726       cur_dest = dest->first = (struct list_entry *)zalloc(sizeof(*cur_dest));
 727       if (cur_dest == NULL)
 728       {
 729          destroy_list(dest);
 730
 731          assert(list_is_valid(src));
 732          assert(list_is_valid(dest));
 733
 734          return JB_ERR_MEMORY;
 735       }
 736
 737       if (cur_src->str)
 738       {
 739          cur_dest->str = strdup(cur_src->str);
 740          if (cur_dest->str == NULL)
 741          {
 742             destroy_list(dest);
 743
 744             assert(list_is_valid(src));
 745             assert(list_is_valid(dest));
 746
 747             return JB_ERR_MEMORY;
 748          }
 749       }
 750       /* else { cur_dest->str = NULL; }  - implied by zalloc */
 751
 752       /* Now process the rest */
 753       for (cur_src = cur_src->next; cur_src; cur_src = cur_src->next)
 754       {
 755          cur_dest = cur_dest->next = (struct list_entry *)zalloc(sizeof(*cur_dest));
 756          if (cur_dest == NULL)
 757          {
 758             destroy_list(dest);
 759
 760             assert(list_is_valid(src));
 761             assert(list_is_valid(dest));
 762
 763             return JB_ERR_MEMORY;
 764          }
 765          if (cur_src->str)
 766          {
 767             cur_dest->str = strdup(cur_src->str);
 768             if (cur_dest->str == NULL)
 769             {
 770                destroy_list(dest);
 771
 772                assert(list_is_valid(src));
 773                assert(list_is_valid(dest));
 774
 775                return JB_ERR_MEMORY;
 776             }
 777          }
 778          /* else { cur_dest->str = NULL; }  - implied by zalloc */
 779       }
 780
 781       dest->last = cur_dest;
 782    }
 783
 784    assert(list_is_valid(src));
 785    assert(list_is_valid(dest));
 786
 787    return JB_ERR_OK;
 788 }
 789
 790
 791 /*********************************************************************
 792  *
 793  * Function    :  list_append_list_unique
 794  *
 795  * Description :  Append a string list to another list.
 796  *                Duplicate items are not added.
 797  *
 798  * Parameters  :
 799  *          1  :  dest = pointer to destination list for merge.
 800  *          2  :  src = pointer to source for merge.
 801  *
 802  * Returns     :  JB_ERR_OK on success
 803  *                JB_ERR_MEMORY on out-of-memory error.
 804  *                On error, some (but not all) of src might have
 805  *                been copied into dest.
 806  *
 807  *********************************************************************/
 808 jb_err list_append_list_unique(struct list *dest, const struct list *src)
 809 {
 810    struct list_entry * cur;
 811
 812    assert(src);
 813    assert(dest);
 814    assert(list_is_valid(src));
 815    assert(list_is_valid(dest));
 816
 817    for (cur = src->first; cur; cur = cur->next)
 818    {
 819       if (cur->str)
 820       {
 821          if (enlist_unique(dest, cur->str, 0))
 822          {
 823             assert(list_is_valid(src));
 824             assert(list_is_valid(dest));
 825
 826             return JB_ERR_MEMORY;
 827          }
 828       }
 829    }
 830
 831    assert(list_is_valid(src));
 832    assert(list_is_valid(dest));
 833
 834    return JB_ERR_OK;
 835 }
 836
 837
 838 /*********************************************************************
 839  *
 840  * Function    :  list_is_empty
 841  *
 842  * Description :  Test whether a list is empty.  Does not change the list.
 843  *
 844  * Parameters  :
 845  *          1  :  the_list = pointer to list to test.
 846  *
 847  * Returns     :  Nonzero iff the list contains no entries.
 848  *
 849  *********************************************************************/
 850 int list_is_empty(const struct list *the_list)
 851 {
 852    assert(the_list);
 853    assert(list_is_valid(the_list));
 854
 855    return (the_list->first == NULL);
 856 }
 857
 858
 859 /*********************************************************************
 860  *
 861  * Function    :  new_map
 862  *
 863  * Description :  Create a new, empty map.
 864  *
 865  * Parameters  :  N/A
 866  *
 867  * Returns     :  A new, empty map, or NULL if out of memory.
 868  *
 869  *********************************************************************/
 870 struct map *new_map(void)
 871 {
 872    return (struct map *) zalloc(sizeof(struct map));
 873 }
 874
 875
 876 /*********************************************************************
 877  *
 878  * Function    :  free_map
 879  *
 880  * Description :  Free the memory occupied by a map and its
 881  *                depandant strings
 882  *
 883  * Parameters  :
 884  *          1  :  the_map = map to be freed.  May be NULL.
 885  *
 886  * Returns     :  N/A
 887  *
 888  *********************************************************************/
 889 void free_map(struct map *the_map)
 890 {
 891    struct map_entry *cur_entry;
 892    struct map_entry *next_entry;
 893
 894    if (the_map == NULL)
 895    {
 896       return;
 897    }
 898
 899    for (cur_entry = the_map->first; cur_entry != NULL; cur_entry = next_entry)
 900    {
 901       freez(cur_entry->name);
 902       freez(cur_entry->value);
 903
 904       next_entry = cur_entry->next;
 905       free(cur_entry);
 906    }
 907
 908    the_map->first = the_map->last = NULL;
 909
 910    free(the_map);
 911 }
 912
 913
 914 /*********************************************************************
 915  *
 916  * Function    :  map
 917  *
 918  * Description :  Add a mapping from given name to given value to a
 919  *                given map.
 920  *
 921  *                Note: Since all strings will be free()d in free_map()
 922  *                      later, set the copy flags for constants or
 923  *                      strings that will be independantly free()d.
 924  *
 925  *                Note2: This function allows NULL parameters - it
 926  *                       returns JB_ERR_MEMORY in that case.
 927  *
 928  *                Note3: If this function returns JB_ERR_MEMORY,
 929  *                       it will free(name) unless you specify
 930  *                       name_needs_copying, and similarly it will
 931  *                       free(value) unless you specify
 932  *                       value_needs_copying.
 933  *
 934  *                Due to Note2 and Note3 above, the following code
 935  *                is legal, and will never crash or leak memory even
 936  *                if the system runs out of memory:
 937  *
 938  *                    err = map(mymap, "xyz", 1, html_encode(somestring), 0);
 939  *
 940  *                err will be set to JB_ERR_MEMORY if either call runs
 941  *                out-of-memory.  Without these features, you would
 942  *                need to check the return value of html_encode in the
 943  *                above example for NULL, which (at least) doubles the
 944  *                amount of error-checking code needed.
 945  *
 946  * Parameters  :
 947  *          1  :  the_map = map to add to
 948  *          2  :  name = name to add
 949  *          3  :  name_needs_copying = flag set if a copy of name should be used
 950  *          4  :  value = value to add
 951  *          5  :  value_needs_copying = flag set if a copy of value should be used
 952  *
 953  * Returns     :  JB_ERR_OK on success
 954  *                JB_ERR_MEMORY on out-of-memory error.
 955  *
 956  *********************************************************************/
 957 jb_err map(struct map *the_map,
 958            const char *name, int name_needs_copying,
 959            const char *value, int value_needs_copying)
 960 {
 961    struct map_entry *new_entry;
 962
 963    assert(the_map);
 964
 965    if ( (NULL == value)
 966      || (NULL == name)
 967      || (NULL == (new_entry = zalloc(sizeof(*new_entry)))) )
 968    {
 969       if ((name != NULL) && (!name_needs_copying))
 970       {
 971           free((char *)name);
 972       }
 973       if ((value != NULL) && (!value_needs_copying))
 974       {
 975           free((char *)value);
 976       }
 977       return JB_ERR_MEMORY;
 978    }
 979
 980    if (name_needs_copying)
 981    {
 982       if (NULL == (name = strdup(name)))
 983       {
 984          free(new_entry);
 985          if (!value_needs_copying)
 986          {
 987              free((char *)value);
 988          }
 989          return JB_ERR_MEMORY;
 990       }
 991    }
 992
 993    if (value_needs_copying)
 994    {
 995       if (NULL == (value = strdup(value)))
 996       {
 997          free((char *)name);
 998          free(new_entry);
 999          return JB_ERR_MEMORY;
1000       }
1001    }
1002
1003    new_entry->name = name;
1004    new_entry->value = value;
1005    /* new_entry->next = NULL;  - implied by zalloc */
1006
1007    if (the_map->last)
1008    {
1009       the_map->last->next = new_entry;
1010       the_map->last = new_entry;
1011    }
1012    else
1013    {
1014       the_map->first = new_entry;
1015       the_map->last = new_entry;
1016    }
1017
1018    return JB_ERR_OK;
1019 }
1020
1021
1022 /*********************************************************************
1023  *
1024  * Function    :  lookup
1025  *
1026  * Description :  Look up an item with a given name in a map, and
1027  *                return its value
1028  *
1029  * Parameters  :
1030  *          1  :  the_map = map to look in
1031  *          2  :  name = name parameter to look for
1032  *
1033  * Returns     :  the value if found, else the empty string.
1034  *                Return value is alloced as part of the map, so
1035  *                it is freed when the map is destroyed.  Caller
1036  *                must not free or modify it.
1037  *
1038  *********************************************************************/
1039 const char *lookup(const struct map *the_map, const char *name)
1040 {
1041    const struct map_entry *cur_entry;
1042
1043    assert(the_map);
1044    assert(name);
1045
1046    for (cur_entry = the_map->first; cur_entry != NULL; cur_entry = cur_entry->next)
1047    {
1048       if (!strcmp(name, cur_entry->name))
1049       {
1050          return cur_entry->value;
1051       }
1052    }
1053    return "";
1054 }
1055
1056
1057 /*
1058   Local Variables:
1059   tab-width: 3
1060   end:
1061 */