actions.c

   1 const char actions_rcs[] = "$Id: actions.c,v 1.32.2.6 2006/01/29 23:10:56 david__schmidt Exp $";
   2 /*********************************************************************
   3  *
   4  * File        :  $Source: /cvsroot/ijbswa/current/Attic/actions.c,v $
   5  *
   6  * Purpose     :  Declares functions to work with actions files
   7  *                Functions declared include: FIXME
   8  *
   9  * Copyright   :  Written by and Copyright (C) 2001 the SourceForge
  10  *                Privoxy team. http://www.privoxy.org/
  11  *
  12  *                Based on the Internet Junkbuster originally written
  13  *                by and Copyright (C) 1997 Anonymous Coders and
  14  *                Junkbusters Corporation.  http://www.junkbusters.com
  15  *
  16  *                This program is free software; you can redistribute it
  17  *                and/or modify it under the terms of the GNU General
  18  *                Public License as published by the Free Software
  19  *                Foundation; either version 2 of the License, or (at
  20  *                your option) any later version.
  21  *
  22  *                This program is distributed in the hope that it will
  23  *                be useful, but WITHOUT ANY WARRANTY; without even the
  24  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
  25  *                PARTICULAR PURPOSE.  See the GNU General Public
  26  *                License for more details.
  27  *
  28  *                The GNU General Public License should be included with
  29  *                this file.  If not, you can view it at
  30  *                http://www.gnu.org/copyleft/gpl.html
  31  *                or write to the Free Software Foundation, Inc., 59
  32  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  33  *
  34  * Revisions   :
  35  *    $Log: actions.c,v $
  36  *    Revision 1.32.2.6  2006/01/29 23:10:56  david__schmidt
  37  *    Multiple filter file support
  38  *
  39  *    Revision 1.32.2.5  2005/06/09 01:18:41  david__schmidt
  40  *    Tweaks to conditionally include pthread.h if FEATURE_PTHREAD is enabled -
  41  *    this becomes important when jcc.h gets included later down the line.
  42  *
  43  *    Revision 1.32.2.4  2003/12/03 10:33:11  oes
  44  *    - Implemented Privoxy version requirement through
  45  *      for-privoxy-version= statement in {{settings}}
  46  *      block
  47  *    - Fix for unchecked out-of-memory condition
  48  *
  49  *    Revision 1.32.2.3  2003/02/28 12:52:10  oes
  50  *    Fixed memory leak reported by Dan Price in Bug #694713
  51  *
  52  *    Revision 1.32.2.2  2002/11/20 14:36:55  oes
  53  *    Extended unload_current_actions_file() to multiple AFs.
  54  *    Thanks to Oliver Stoeneberg for the hint.
  55  *
  56  *    Revision 1.32.2.1  2002/05/26 12:13:16  roro
  57  *    Change unsigned to unsigned long in actions_name struct.  This closes
  58  *    SourceForge Bug #539284.
  59  *
  60  *    Revision 1.32  2002/05/12 21:36:29  jongfoster
  61  *    Correcting function comments
  62  *
  63  *    Revision 1.31  2002/05/06 07:56:50  oes
  64  *    Made actions_to_html independent of FEATURE_CGI_EDIT_ACTIONS
  65  *
  66  *    Revision 1.30  2002/04/30 11:14:52  oes
  67  *    Made csp the first parameter in *action_to_html
  68  *
  69  *    Revision 1.29  2002/04/26 19:30:54  jongfoster
  70  *    - current_action_to_html(): Adding help link for the "-" form of
  71  *      one-string actions.
  72  *    - Some actions had "<br>-", some "<br> -" (note the space).
  73  *      Standardizing on no space.
  74  *    - Greatly simplifying some of the code by using string_join()
  75  *      where appropriate.
  76  *
  77  *    Revision 1.28  2002/04/26 12:53:15  oes
  78  *     - CGI AF editor now writes action lines split into
  79  *       single lines with line continuation
  80  *     - actions_to_html now embeds each action name in
  81  *       link to chapter
  82  *     - current_action_to_text is now called current_action_to_html
  83  *       and acts like actions_to_html
  84  *
  85  *    Revision 1.27  2002/04/24 02:10:31  oes
  86  *     - Jon's patch for multiple AFs:
  87  *       - split load_actions_file, add load_one_actions_file
  88  *       - make csp->actions_list files an array
  89  *       - remember file id with each action
  90  *     - Copy_action now frees dest action before copying
  91  *
  92  *    Revision 1.26  2002/03/26 22:29:54  swa
  93  *    we have a new homepage!
  94  *
  95  *    Revision 1.25  2002/03/24 13:25:43  swa
  96  *    name change related issues
  97  *
  98  *    Revision 1.24  2002/03/16 23:54:06  jongfoster
  99  *    Adding graceful termination feature, to help look for memory leaks.
 100  *    If you enable this (which, by design, has to be done by hand
 101  *    editing config.h) and then go to http://i.j.b/die, then the program
 102  *    will exit cleanly after the *next* request.  It should free all the
 103  *    memory that was used.
 104  *
 105  *    Revision 1.23  2002/03/07 03:46:16  oes
 106  *    Fixed compiler warnings
 107  *
 108  *    Revision 1.22  2002/01/21 00:27:02  jongfoster
 109  *    Allowing free_action(NULL).
 110  *    Moving the functions that #include actionlist.h to the end of the file,
 111  *    because the Visual C++ 97 debugger gets extremely confused if you try
 112  *    to debug any code that comes after them in the file.
 113  *
 114  *    Revision 1.21  2002/01/17 20:54:44  jongfoster
 115  *    Renaming free_url to free_url_spec, since it frees a struct url_spec.
 116  *
 117  *    Revision 1.20  2001/11/22 21:56:49  jongfoster
 118  *    Making action_spec->flags into an unsigned long rather than just an
 119  *    unsigned int.
 120  *    Fixing a bug in the display of -add-header and -wafer
 121  *
 122  *    Revision 1.19  2001/11/13 00:14:07  jongfoster
 123  *    Fixing stupid bug now I've figured out what || means.
 124  *    (It always returns 0 or 1, not one of it's paramaters.)
 125  *
 126  *    Revision 1.18  2001/11/07 00:06:06  steudten
 127  *    Add line number in error output for lineparsing for
 128  *    actionsfile.
 129  *
 130  *    Revision 1.17  2001/10/25 03:40:47  david__schmidt
 131  *    Change in porting tactics: OS/2's EMX porting layer doesn't allow multiple
 132  *    threads to call select() simultaneously.  So, it's time to do a real, live,
 133  *    native OS/2 port.  See defines for __EMX__ (the porting layer) vs. __OS2__
 134  *    (native). Both versions will work, but using __OS2__ offers multi-threading.
 135  *
 136  *    Revision 1.16  2001/10/23 21:30:30  jongfoster
 137  *    Adding error-checking to selected functions.
 138  *
 139  *    Revision 1.15  2001/10/14 21:58:22  jongfoster
 140  *    Adding support for the CGI-based editor:
 141  *    - Exported get_actions()
 142  *    - Added new function free_alias_list()
 143  *    - Added support for {{settings}} and {{description}} blocks
 144  *      in the actions file.  They are currently ignored.
 145  *    - Added restriction to only one {{alias}} block which must appear
 146  *      first in the file, to simplify the editor's rewriting rules.
 147  *    - Note that load_actions_file() is no longer used by the CGI-based
 148  *      editor, but some of the other routines in this file are.
 149  *
 150  *    Revision 1.14  2001/09/22 16:36:59  jongfoster
 151  *    Removing unused parameter fs from read_config_line()
 152  *
 153  *    Revision 1.13  2001/09/16 15:47:37  jongfoster
 154  *    First version of CGI-based edit interface.  This is very much a
 155  *    work-in-progress, and you can't actually use it to edit anything
 156  *    yet.  You must #define FEATURE_CGI_EDIT_ACTIONS for these changes
 157  *    to have any effect.
 158  *
 159  *    Revision 1.12  2001/09/16 13:21:27  jongfoster
 160  *    Changes to use new list functions.
 161  *
 162  *    Revision 1.11  2001/09/14 00:17:32  jongfoster
 163  *    Tidying up memory allocation. New function init_action().
 164  *
 165  *    Revision 1.10  2001/09/10 10:14:34  oes
 166  *    Removing unused variable
 167  *
 168  *    Revision 1.9  2001/07/30 22:08:36  jongfoster
 169  *    Tidying up #defines:
 170  *    - All feature #defines are now of the form FEATURE_xxx
 171  *    - Permanently turned off WIN_GUI_EDIT
 172  *    - Permanently turned on WEBDAV and SPLIT_PROXY_ARGS
 173  *
 174  *    Revision 1.8  2001/06/29 13:19:52  oes
 175  *    Removed logentry from cancelled commit
 176  *
 177  *    Revision 1.7  2001/06/09 10:55:28  jongfoster
 178  *    Changing BUFSIZ ==> BUFFER_SIZE
 179  *
 180  *    Revision 1.6  2001/06/07 23:04:34  jongfoster
 181  *    Made get_actions() static.
 182  *
 183  *    Revision 1.5  2001/06/03 19:11:48  oes
 184  *    adapted to new enlist_unique arg format
 185  *
 186  *    Revision 1.4  2001/06/01 20:03:42  jongfoster
 187  *    Better memory management - current_action->strings[] now
 188  *    contains copies of the strings, not the original.
 189  *
 190  *    Revision 1.3  2001/06/01 18:49:17  jongfoster
 191  *    Replaced "list_share" with "list" - the tiny memory gain was not
 192  *    worth the extra complexity.
 193  *
 194  *    Revision 1.2  2001/05/31 21:40:00  jongfoster
 195  *    Removing some commented out, obsolete blocks of code.
 196  *
 197  *    Revision 1.1  2001/05/31 21:16:46  jongfoster
 198  *    Moved functions to process the action list into this new file.
 199  *
 200  *
 201  *********************************************************************/
 202 \f
 203
 204 #include "config.h"
 205
 206 #include <stdio.h>
 207 #include <string.h>
 208 #include <assert.h>
 209 #include <stdlib.h>
 210
 211 #ifdef FEATURE_PTHREAD
 212 #include <pthread.h>
 213 #endif
 214
 215 #include "project.h"
 216 #include "jcc.h"
 217 #include "list.h"
 218 #include "actions.h"
 219 #include "miscutil.h"
 220 #include "errlog.h"
 221 #include "loaders.h"
 222 #include "encode.h"
 223 #include "urlmatch.h"
 224 #include "cgi.h"
 225 #include "ssplit.h"
 226
 227 const char actions_h_rcs[] = ACTIONS_H_VERSION;
 228
 229
 230 /*
 231  * We need the main list of options.
 232  *
 233  * First, we need a way to tell between boolean, string, and multi-string
 234  * options.  For string and multistring options, we also need to be
 235  * able to tell the difference between a "+" and a "-".  (For bools,
 236  * the "+"/"-" information is encoded in "add" and "mask").  So we use
 237  * an enumerated type (well, the preprocessor equivalent).  Here are
 238  * the values:
 239  */
 240 #define AV_NONE       0 /* +opt -opt */
 241 #define AV_ADD_STRING 1 /* +stropt{string} */
 242 #define AV_REM_STRING 2 /* -stropt */
 243 #define AV_ADD_MULTI  3 /* +multiopt{string} +multiopt{string2} */
 244 #define AV_REM_MULTI  4 /* -multiopt{string} -multiopt          */
 245
 246 /*
 247  * We need a structure to hold the name, flag changes,
 248  * type, and string index.
 249  */
 250 struct action_name
 251 {
 252    const char * name;
 253    unsigned long mask;   /* a bit set to "0" = remove action */
 254    unsigned long add;    /* a bit set to "1" = add action */
 255    int takes_value;      /* an AV_... constant */
 256    int index;            /* index into strings[] or multi[] */
 257 };
 258
 259 /*
 260  * And with those building blocks in place, here's the array.
 261  */
 262 static const struct action_name action_names[] =
 263 {
 264    /*
 265     * Well actually there's no data here - it's in actionlist.h
 266     * This keeps it together to make it easy to change.
 267     *
 268     * Here's the macros used to format it:
 269     */
 270 #define DEFINE_ACTION_MULTI(name,index)                   \
 271    { "+" name, ACTION_MASK_ALL, 0, AV_ADD_MULTI, index }, \
 272    { "-" name, ACTION_MASK_ALL, 0, AV_REM_MULTI, index },
 273 #define DEFINE_ACTION_STRING(name,flag,index)                 \
 274    { "+" name, ACTION_MASK_ALL, flag, AV_ADD_STRING, index }, \
 275    { "-" name, ~flag, 0, AV_REM_STRING, index },
 276 #define DEFINE_ACTION_BOOL(name,flag)   \
 277    { "+" name, ACTION_MASK_ALL, flag }, \
 278    { "-" name, ~flag, 0 },
 279 #define DEFINE_ACTION_ALIAS 1 /* Want aliases please */
 280
 281 #include "actionlist.h"
 282
 283 #undef DEFINE_ACTION_MULTI
 284 #undef DEFINE_ACTION_STRING
 285 #undef DEFINE_ACTION_BOOL
 286 #undef DEFINE_ACTION_ALIAS
 287
 288    { NULL, 0, 0 } /* End marker */
 289 };
 290
 291
 292 static int load_one_actions_file(struct client_state *csp, int fileid);
 293
 294
 295 /*********************************************************************
 296  *
 297  * Function    :  merge_actions
 298  *
 299  * Description :  Merge two actions together.
 300  *                Similar to "dest += src".
 301  *
 302  * Parameters  :
 303  *          1  :  dest = Actions to modify.
 304  *          2  :  src = Action to add.
 305  *
 306  * Returns     :  JB_ERR_OK or JB_ERR_MEMORY
 307  *
 308  *********************************************************************/
 309 jb_err merge_actions (struct action_spec *dest,
 310                       const struct action_spec *src)
 311 {
 312    int i;
 313    jb_err err;
 314
 315    dest->mask &= src->mask;
 316    dest->add  &= src->mask;
 317    dest->add  |= src->add;
 318
 319    for (i = 0; i < ACTION_STRING_COUNT; i++)
 320    {
 321       char * str = src->string[i];
 322       if (str)
 323       {
 324          freez(dest->string[i]);
 325          dest->string[i] = strdup(str);
 326          if (NULL == dest->string[i])
 327          {
 328             return JB_ERR_MEMORY;
 329          }
 330       }
 331    }
 332
 333    for (i = 0; i < ACTION_MULTI_COUNT; i++)
 334    {
 335       if (src->multi_remove_all[i])
 336       {
 337          /* Remove everything from dest */
 338          list_remove_all(dest->multi_remove[i]);
 339          dest->multi_remove_all[i] = 1;
 340
 341          err = list_duplicate(dest->multi_add[i], src->multi_add[i]);
 342       }
 343       else if (dest->multi_remove_all[i])
 344       {
 345          /*
 346           * dest already removes everything, so we only need to worry
 347           * about what we add.
 348           */
 349          list_remove_list(dest->multi_add[i], src->multi_remove[i]);
 350          err = list_append_list_unique(dest->multi_add[i], src->multi_add[i]);
 351       }
 352       else
 353       {
 354          /* No "remove all"s to worry about. */
 355          list_remove_list(dest->multi_add[i], src->multi_remove[i]);
 356          err = list_append_list_unique(dest->multi_remove[i], src->multi_remove[i]);
 357          if (!err) err = list_append_list_unique(dest->multi_add[i], src->multi_add[i]);
 358       }
 359
 360       if (err)
 361       {
 362          return err;
 363       }
 364    }
 365
 366    return JB_ERR_OK;
 367 }
 368
 369
 370 /*********************************************************************
 371  *
 372  * Function    :  copy_action
 373  *
 374  * Description :  Copy an action_specs.
 375  *                Similar to "dest = src".
 376  *
 377  * Parameters  :
 378  *          1  :  dest = Destination of copy.
 379  *          2  :  src = Source for copy.
 380  *
 381  * Returns     :  N/A
 382  *
 383  *********************************************************************/
 384 jb_err copy_action (struct action_spec *dest,
 385                     const struct action_spec *src)
 386 {
 387    int i;
 388    jb_err err = JB_ERR_OK;
 389
 390    free_action(dest);
 391    memset(dest, '\0', sizeof(*dest));
 392
 393    dest->mask = src->mask;
 394    dest->add  = src->add;
 395
 396    for (i = 0; i < ACTION_STRING_COUNT; i++)
 397    {
 398       char * str = src->string[i];
 399       if (str)
 400       {
 401          str = strdup(str);
 402          if (!str)
 403          {
 404             return JB_ERR_MEMORY;
 405          }
 406          dest->string[i] = str;
 407       }
 408    }
 409
 410    for (i = 0; i < ACTION_MULTI_COUNT; i++)
 411    {
 412       dest->multi_remove_all[i] = src->multi_remove_all[i];
 413       err = list_duplicate(dest->multi_remove[i], src->multi_remove[i]);
 414       if (err)
 415       {
 416          return err;
 417       }
 418       err = list_duplicate(dest->multi_add[i],    src->multi_add[i]);
 419       if (err)
 420       {
 421          return err;
 422       }
 423    }
 424    return err;
 425 }
 426
 427
 428 /*********************************************************************
 429  *
 430  * Function    :  free_action
 431  *
 432  * Description :  Destroy an action_spec.  Frees memory used by it,
 433  *                except for the memory used by the struct action_spec
 434  *                itself.
 435  *
 436  * Parameters  :
 437  *          1  :  src = Source to free.
 438  *
 439  * Returns     :  N/A
 440  *
 441  *********************************************************************/
 442 void free_action (struct action_spec *src)
 443 {
 444    int i;
 445
 446    if (src == NULL)
 447    {
 448       return;
 449    }
 450
 451    for (i = 0; i < ACTION_STRING_COUNT; i++)
 452    {
 453       freez(src->string[i]);
 454    }
 455
 456    for (i = 0; i < ACTION_MULTI_COUNT; i++)
 457    {
 458       destroy_list(src->multi_remove[i]);
 459       destroy_list(src->multi_add[i]);
 460    }
 461
 462    memset(src, '\0', sizeof(*src));
 463 }
 464
 465
 466 /*********************************************************************
 467  *
 468  * Function    :  get_action_token
 469  *
 470  * Description :  Parses a line for the first action.
 471  *                Modifies it's input array, doesn't allocate memory.
 472  *                e.g. given:
 473  *                *line="  +abc{def}  -ghi "
 474  *                Returns:
 475  *                *line="  -ghi "
 476  *                *name="+abc"
 477  *                *value="def"
 478  *
 479  * Parameters  :
 480  *          1  :  line = [in] The line containing the action.
 481  *                       [out] Start of next action on line, or
 482  *                       NULL if we reached the end of line before
 483  *                       we found an action.
 484  *          2  :  name = [out] Start of action name, null
 485  *                       terminated.  NULL on EOL
 486  *          3  :  value = [out] Start of action value, null
 487  *                        terminated.  NULL if none or EOL.
 488  *
 489  * Returns     :  JB_ERR_OK => Ok
 490  *                JB_ERR_PARSE => Mismatched {} (line was trashed anyway)
 491  *
 492  *********************************************************************/
 493 jb_err get_action_token(char **line, char **name, char **value)
 494 {
 495    char * str = *line;
 496    char ch;
 497
 498    /* set default returns */
 499    *line = NULL;
 500    *name = NULL;
 501    *value = NULL;
 502
 503    /* Eat any leading whitespace */
 504    while ((*str == ' ') || (*str == '\t'))
 505    {
 506       str++;
 507    }
 508
 509    if (*str == '\0')
 510    {
 511       return 0;
 512    }
 513
 514    if (*str == '{')
 515    {
 516       /* null name, just value is prohibited */
 517       return JB_ERR_PARSE;
 518    }
 519
 520    *name = str;
 521
 522    /* parse option */
 523    while (((ch = *str) != '\0') &&
 524           (ch != ' ') && (ch != '\t') && (ch != '{'))
 525    {
 526       if (ch == '}')
 527       {
 528          /* error, '}' without '{' */
 529          return JB_ERR_PARSE;
 530       }
 531       str++;
 532    }
 533    *str = '\0';
 534
 535    if (ch != '{')
 536    {
 537       /* no value */
 538       if (ch == '\0')
 539       {
 540          /* EOL - be careful not to run off buffer */
 541          *line = str;
 542       }
 543       else
 544       {
 545          /* More to parse next time. */
 546          *line = str + 1;
 547       }
 548       return JB_ERR_OK;
 549    }
 550
 551    str++;
 552    *value = str;
 553
 554    str = strchr(str, '}');
 555    if (str == NULL)
 556    {
 557       /* error */
 558       *value = NULL;
 559       return JB_ERR_PARSE;
 560    }
 561
 562    /* got value */
 563    *str = '\0';
 564    *line = str + 1;
 565
 566    chomp(*value);
 567
 568    return JB_ERR_OK;
 569 }
 570
 571
 572 /*********************************************************************
 573  *
 574  * Function    :  get_actions
 575  *
 576  * Description :  Parses a list of actions.
 577  *
 578  * Parameters  :
 579  *          1  :  line = The string containing the actions.
 580  *                       Will be written to by this function.
 581  *          2  :  alias_list = Custom alias list, or NULL for none.
 582  *          3  :  cur_action = Where to store the action.  Caller
 583  *                             allocates memory.
 584  *
 585  * Returns     :  JB_ERR_OK => Ok
 586  *                JB_ERR_PARSE => Parse error (line was trashed anyway)
 587  *                nonzero => Out of memory (line was trashed anyway)
 588  *
 589  *********************************************************************/
 590 jb_err get_actions(char *line,
 591                    struct action_alias * alias_list,
 592                    struct action_spec *cur_action)
 593 {
 594    jb_err err;
 595    init_action(cur_action);
 596    cur_action->mask = ACTION_MASK_ALL;
 597
 598    while (line)
 599    {
 600       char * option = NULL;
 601       char * value = NULL;
 602
 603       err = get_action_token(&line, &option, &value);
 604       if (err)
 605       {
 606          return err;
 607       }
 608
 609       if (option)
 610       {
 611          /* handle option in 'option' */
 612
 613          /* Check for standard action name */
 614          const struct action_name * action = action_names;
 615
 616          while ( (action->name != NULL) && (0 != strcmpic(action->name, option)) )
 617          {
 618             action++;
 619          }
 620          if (action->name != NULL)
 621          {
 622             /* Found it */
 623             cur_action->mask &= action->mask;
 624             cur_action->add  &= action->mask;
 625             cur_action->add  |= action->add;
 626
 627             switch (action->takes_value)
 628             {
 629             case AV_NONE:
 630                /* ignore any option. */
 631                break;
 632             case AV_ADD_STRING:
 633                {
 634                   /* add single string. */
 635
 636                   if ((value == NULL) || (*value == '\0'))
 637                   {
 638                      return JB_ERR_PARSE;
 639                   }
 640                   /* FIXME: should validate option string here */
 641                   freez (cur_action->string[action->index]);
 642                   cur_action->string[action->index] = strdup(value);
 643                   if (NULL == cur_action->string[action->index])
 644                   {
 645                      return JB_ERR_MEMORY;
 646                   }
 647                   break;
 648                }
 649             case AV_REM_STRING:
 650                {
 651                   /* remove single string. */
 652
 653                   freez (cur_action->string[action->index]);
 654                   break;
 655                }
 656             case AV_ADD_MULTI:
 657                {
 658                   /* append multi string. */
 659
 660                   struct list * remove_p = cur_action->multi_remove[action->index];
 661                   struct list * add_p    = cur_action->multi_add[action->index];
 662
 663                   if ((value == NULL) || (*value == '\0'))
 664                   {
 665                      return JB_ERR_PARSE;
 666                   }
 667
 668                   list_remove_item(remove_p, value);
 669                   err = enlist_unique(add_p, value, 0);
 670                   if (err)
 671                   {
 672                      return err;
 673                   }
 674                   break;
 675                }
 676             case AV_REM_MULTI:
 677                {
 678                   /* remove multi string. */
 679
 680                   struct list * remove_p = cur_action->multi_remove[action->index];
 681                   struct list * add_p    = cur_action->multi_add[action->index];
 682
 683                   if ( (value == NULL) || (*value == '\0')
 684                      || ((*value == '*') && (value[1] == '\0')) )
 685                   {
 686                      /*
 687                       * no option, or option == "*".
 688                       *
 689                       * Remove *ALL*.
 690                       */
 691                      list_remove_all(remove_p);
 692                      list_remove_all(add_p);
 693                      cur_action->multi_remove_all[action->index] = 1;
 694                   }
 695                   else
 696                   {
 697                      /* Valid option - remove only 1 option */
 698
 699                      if ( !cur_action->multi_remove_all[action->index] )
 700                      {
 701                         /* there isn't a catch-all in the remove list already */
 702                         err = enlist_unique(remove_p, value, 0);
 703                         if (err)
 704                         {
 705                            return err;
 706                         }
 707                      }
 708                      list_remove_item(add_p, value);
 709                   }
 710                   break;
 711                }
 712             default:
 713                /* Shouldn't get here unless there's memory corruption. */
 714                assert(0);
 715                return JB_ERR_PARSE;
 716             }
 717          }
 718          else
 719          {
 720             /* try user aliases. */
 721             const struct action_alias * alias = alias_list;
 722
 723             while ( (alias != NULL) && (0 != strcmpic(alias->name, option)) )
 724             {
 725                alias = alias->next;
 726             }
 727             if (alias != NULL)
 728             {
 729                /* Found it */
 730                merge_actions(cur_action, alias->action);
 731             }
 732             else
 733             {
 734                /* Bad action name */
 735                return JB_ERR_PARSE;
 736             }
 737          }
 738       }
 739    }
 740
 741    return JB_ERR_OK;
 742 }
 743
 744
 745 /*********************************************************************
 746  *
 747  * Function    :  init_current_action
 748  *
 749  * Description :  Zero out an action.
 750  *
 751  * Parameters  :
 752  *          1  :  dest = An uninitialized current_action_spec.
 753  *
 754  * Returns     :  N/A
 755  *
 756  *********************************************************************/
 757 void init_current_action (struct current_action_spec *dest)
 758 {
 759    memset(dest, '\0', sizeof(*dest));
 760
 761    dest->flags = ACTION_MOST_COMPATIBLE;
 762 }
 763
 764
 765 /*********************************************************************
 766  *
 767  * Function    :  init_action
 768  *
 769  * Description :  Zero out an action.
 770  *
 771  * Parameters  :
 772  *          1  :  dest = An uninitialized action_spec.
 773  *
 774  * Returns     :  N/A
 775  *
 776  *********************************************************************/
 777 void init_action (struct action_spec *dest)
 778 {
 779    memset(dest, '\0', sizeof(*dest));
 780 }
 781
 782
 783 /*********************************************************************
 784  *
 785  * Function    :  merge_current_action
 786  *
 787  * Description :  Merge two actions together.
 788  *                Similar to "dest += src".
 789  *                Differences between this and merge_actions()
 790  *                is that this one doesn't allocate memory for
 791  *                strings (so "src" better be in memory for at least
 792  *                as long as "dest" is, and you'd better free
 793  *                "dest" using "free_current_action").
 794  *                Also, there is no  mask or remove lists in dest.
 795  *                (If we're applying it to a URL, we don't need them)
 796  *
 797  * Parameters  :
 798  *          1  :  dest = Current actions, to modify.
 799  *          2  :  src = Action to add.
 800  *
 801  * Returns  0  :  no error
 802  *        !=0  :  error, probably JB_ERR_MEMORY.
 803  *
 804  *********************************************************************/
 805 jb_err merge_current_action (struct current_action_spec *dest,
 806                              const struct action_spec *src)
 807 {
 808    int i;
 809    jb_err err = JB_ERR_OK;
 810
 811    dest->flags  &= src->mask;
 812    dest->flags  |= src->add;
 813
 814    for (i = 0; i < ACTION_STRING_COUNT; i++)
 815    {
 816       char * str = src->string[i];
 817       if (str)
 818       {
 819          str = strdup(str);
 820          if (!str)
 821          {
 822             return JB_ERR_MEMORY;
 823          }
 824          freez(dest->string[i]);
 825          dest->string[i] = str;
 826       }
 827    }
 828
 829    for (i = 0; i < ACTION_MULTI_COUNT; i++)
 830    {
 831       if (src->multi_remove_all[i])
 832       {
 833          /* Remove everything from dest, then add src->multi_add */
 834          err = list_duplicate(dest->multi[i], src->multi_add[i]);
 835          if (err)
 836          {
 837             return err;
 838          }
 839       }
 840       else
 841       {
 842          list_remove_list(dest->multi[i], src->multi_remove[i]);
 843          err = list_append_list_unique(dest->multi[i], src->multi_add[i]);
 844          if (err)
 845          {
 846             return err;
 847          }
 848       }
 849    }
 850    return err;
 851 }
 852
 853
 854 /*********************************************************************
 855  *
 856  * Function    :  free_current_action
 857  *
 858  * Description :  Free memory used by a current_action_spec.
 859  *                Does not free the current_action_spec itself.
 860  *
 861  * Parameters  :
 862  *          1  :  src = Source to free.
 863  *
 864  * Returns     :  N/A
 865  *
 866  *********************************************************************/
 867 void free_current_action (struct current_action_spec *src)
 868 {
 869    int i;
 870
 871    for (i = 0; i < ACTION_STRING_COUNT; i++)
 872    {
 873       freez(src->string[i]);
 874    }
 875
 876    for (i = 0; i < ACTION_MULTI_COUNT; i++)
 877    {
 878       destroy_list(src->multi[i]);
 879    }
 880
 881    memset(src, '\0', sizeof(*src));
 882 }
 883
 884
 885 static struct file_list *current_actions_file[MAX_AF_FILES]  = {
 886    NULL, NULL, NULL, NULL, NULL,
 887    NULL, NULL, NULL, NULL, NULL
 888 };
 889
 890
 891 #ifdef FEATURE_GRACEFUL_TERMINATION
 892 /*********************************************************************
 893  *
 894  * Function    :  unload_current_actions_file
 895  *
 896  * Description :  Unloads current actions file - reset to state at
 897  *                beginning of program.
 898  *
 899  * Parameters  :  None
 900  *
 901  * Returns     :  N/A
 902  *
 903  *********************************************************************/
 904 void unload_current_actions_file(void)
 905 {
 906    int i;
 907
 908    for (i = 0; i < MAX_AF_FILES; i++)
 909    {
 910       if (current_actions_file[i])
 911       {
 912          current_actions_file[i]->unloader = unload_actions_file;
 913          current_actions_file[i] = NULL;
 914       }
 915    }
 916 }
 917 #endif /* FEATURE_GRACEFUL_TERMINATION */
 918
 919
 920 /*********************************************************************
 921  *
 922  * Function    :  unload_actions_file
 923  *
 924  * Description :  Unloads an actions module.
 925  *
 926  * Parameters  :
 927  *          1  :  file_data = the data structure associated with the
 928  *                            actions file.
 929  *
 930  * Returns     :  N/A
 931  *
 932  *********************************************************************/
 933 void unload_actions_file(void *file_data)
 934 {
 935    struct url_actions * next;
 936    struct url_actions * cur = (struct url_actions *)file_data;
 937    while (cur != NULL)
 938    {
 939       next = cur->next;
 940       free_url_spec(cur->url);
 941       free_action(cur->action);
 942       freez(cur);
 943       cur = next;
 944    }
 945
 946 }
 947
 948
 949 /*********************************************************************
 950  *
 951  * Function    :  free_alias_list
 952  *
 953  * Description :  Free memory used by a list of aliases.
 954  *
 955  * Parameters  :
 956  *          1  :  alias_list = Linked list to free.
 957  *
 958  * Returns     :  N/A
 959  *
 960  *********************************************************************/
 961 void free_alias_list(struct action_alias *alias_list)
 962 {
 963    while (alias_list != NULL)
 964    {
 965       struct action_alias * next = alias_list->next;
 966       alias_list->next = NULL;
 967       freez(alias_list->name);
 968       free_action(alias_list->action);
 969       free(alias_list);
 970       alias_list = next;
 971    }
 972 }
 973
 974
 975 /*********************************************************************
 976  *
 977  * Function    :  load_actions_file
 978  *
 979  * Description :  Read and parse all the action files and add to files
 980  *                list.
 981  *
 982  * Parameters  :
 983  *          1  :  csp = Current client state (buffers, headers, etc...)
 984  *
 985  * Returns     :  0 => Ok, everything else is an error.
 986  *
 987  *********************************************************************/
 988 int load_actions_file(struct client_state *csp)
 989 {
 990    int i;
 991    int result;
 992
 993    for (i = 0; i < MAX_AF_FILES; i++)
 994    {
 995       if (csp->config->actions_file[i])
 996       {
 997          result = load_one_actions_file(csp, i);
 998          if (result)
 999          {
1000             return result;
1001          }
1002       }
1003       else if (current_actions_file[i])
1004       {
1005          current_actions_file[i]->unloader = unload_actions_file;
1006          current_actions_file[i] = NULL;
1007       }
1008    }
1009
1010    return 0;
1011 }
1012
1013 /*********************************************************************
1014  *
1015  * Function    :  load_one_actions_file
1016  *
1017  * Description :  Read and parse a action file and add to files
1018  *                list.
1019  *
1020  * Parameters  :
1021  *          1  :  csp = Current client state (buffers, headers, etc...)
1022  *          2  :  fileid = File index to load.
1023  *
1024  * Returns     :  0 => Ok, everything else is an error.
1025  *
1026  *********************************************************************/
1027 static int load_one_actions_file(struct client_state *csp, int fileid)
1028 {
1029
1030    /*
1031     * Parser mode.
1032     * Note: Keep these in the order they occur in the file, they are
1033     * sometimes tested with <=
1034     */
1035 #define MODE_START_OF_FILE 1
1036 #define MODE_SETTINGS      2
1037 #define MODE_DESCRIPTION   3
1038 #define MODE_ALIAS         4
1039 #define MODE_ACTIONS       5
1040
1041    int mode = MODE_START_OF_FILE;
1042
1043    FILE *fp;
1044    struct url_actions *last_perm;
1045    struct url_actions *perm;
1046    char  buf[BUFFER_SIZE];
1047    struct file_list *fs;
1048    struct action_spec * cur_action = NULL;
1049    int cur_action_used = 0;
1050    struct action_alias * alias_list = NULL;
1051    unsigned long linenum = 0;
1052
1053    if (!check_file_changed(current_actions_file[fileid], csp->config->actions_file[fileid], &fs))
1054    {
1055       /* No need to load */
1056       csp->actions_list[fileid] = current_actions_file[fileid];
1057       return 0;
1058    }
1059    if (!fs)
1060    {
1061       log_error(LOG_LEVEL_FATAL, "can't load actions file '%s': error finding file: %E",
1062                 csp->config->actions_file[fileid]);
1063       return 1; /* never get here */
1064    }
1065
1066    fs->f = last_perm = (struct url_actions *)zalloc(sizeof(*last_perm));
1067    if (last_perm == NULL)
1068    {
1069       log_error(LOG_LEVEL_FATAL, "can't load actions file '%s': out of memory!",
1070                 csp->config->actions_file[fileid]);
1071       return 1; /* never get here */
1072    }
1073
1074    if ((fp = fopen(csp->config->actions_file[fileid], "r")) == NULL)
1075    {
1076       log_error(LOG_LEVEL_FATAL, "can't load actions file '%s': error opening file: %E",
1077                 csp->config->actions_file[fileid]);
1078       return 1; /* never get here */
1079    }
1080
1081    while (read_config_line(buf, sizeof(buf), fp, &linenum) != NULL)
1082    {
1083       if (*buf == '{')
1084       {
1085          /* It's a header block */
1086          if (buf[1] == '{')
1087          {
1088             /* It's {{settings}} or {{alias}} */
1089             int len = strlen(buf);
1090             char * start = buf + 2;
1091             char * end = buf + len - 1;
1092             if ((len < 5) || (*end-- != '}') || (*end-- != '}'))
1093             {
1094                /* too short */
1095                fclose(fp);
1096                log_error(LOG_LEVEL_FATAL,
1097                   "can't load actions file '%s': invalid line (%lu): %s",
1098                   csp->config->actions_file[fileid], linenum, buf);
1099                return 1; /* never get here */
1100             }
1101
1102             /* Trim leading and trailing whitespace. */
1103             end[1] = '\0';
1104             chomp(start);
1105
1106             if (*start == '\0')
1107             {
1108                /* too short */
1109                fclose(fp);
1110                log_error(LOG_LEVEL_FATAL,
1111                   "can't load actions file '%s': invalid line (%lu): {{ }}",
1112                   csp->config->actions_file[fileid], linenum);
1113                return 1; /* never get here */
1114             }
1115
1116             /*
1117              * An actionsfile can optionally contain the following blocks.
1118              * They *MUST* be in this order, to simplify processing:
1119              *
1120              * {{settings}}
1121              * name=value...
1122              *
1123              * {{description}}
1124              * ...free text, format TBD, but no line may start with a '{'...
1125              *
1126              * {{alias}}
1127              * name=actions...
1128              *
1129              * The actual actions must be *after* these special blocks.
1130              * None of these special blocks may be repeated.
1131              *
1132              */
1133             if (0 == strcmpic(start, "settings"))
1134             {
1135                /* it's a {{settings}} block */
1136                if (mode >= MODE_SETTINGS)
1137                {
1138                   /* {{settings}} must be first thing in file and must only
1139                    * appear once.
1140                    */
1141                   fclose(fp);
1142                   log_error(LOG_LEVEL_FATAL,
1143                      "can't load actions file '%s': line %lu: {{settings}} must only appear once, and it must be before anything else.",
1144                      csp->config->actions_file[fileid], linenum);
1145                }
1146                mode = MODE_SETTINGS;
1147             }
1148             else if (0 == strcmpic(start, "description"))
1149             {
1150                /* it's a {{description}} block */
1151                if (mode >= MODE_DESCRIPTION)
1152                {
1153                   /* {{description}} is a singleton and only {{settings}} may proceed it
1154                    */
1155                   fclose(fp);
1156                   log_error(LOG_LEVEL_FATAL,
1157                      "can't load actions file '%s': line %lu: {{description}} must only appear once, and only a {{settings}} block may be above it.",
1158                      csp->config->actions_file[fileid], linenum);
1159                }
1160                mode = MODE_DESCRIPTION;
1161             }
1162             else if (0 == strcmpic(start, "alias"))
1163             {
1164                /* it's an {{alias}} block */
1165                if (mode >= MODE_ALIAS)
1166                {
1167                   /* {{alias}} must be first thing in file, possibly after
1168                    * {{settings}} and {{description}}
1169                    *
1170                    * {{alias}} must only appear once.
1171                    *
1172                    * Note that these are new restrictions introduced in
1173                    * v2.9.10 in order to make actionsfile editing simpler.
1174                    * (Otherwise, reordering actionsfile entries without
1175                    * completely rewriting the file becomes non-trivial)
1176                    */
1177                   fclose(fp);
1178                   log_error(LOG_LEVEL_FATAL,
1179                      "can't load actions file '%s': line %lu: {{alias}} must only appear once, and it must be before all actions.",
1180                      csp->config->actions_file[fileid], linenum);
1181                }
1182                mode = MODE_ALIAS;
1183             }
1184             else
1185             {
1186                /* invalid {{something}} block */
1187                fclose(fp);
1188                log_error(LOG_LEVEL_FATAL,
1189                   "can't load actions file '%s': invalid line (%lu): {{%s}}",
1190                   csp->config->actions_file[fileid], linenum, start);
1191                return 1; /* never get here */
1192             }
1193          }
1194          else
1195          {
1196             /* It's an actions block */
1197
1198             char  actions_buf[BUFFER_SIZE];
1199             char * end;
1200
1201             /* set mode */
1202             mode    = MODE_ACTIONS;
1203
1204             /* free old action */
1205             if (cur_action)
1206             {
1207                if (!cur_action_used)
1208                {
1209                   free_action(cur_action);
1210                   free(cur_action);
1211                }
1212                cur_action = NULL;
1213             }
1214             cur_action_used = 0;
1215             cur_action = (struct action_spec *)zalloc(sizeof(*cur_action));
1216             if (cur_action == NULL)
1217             {
1218                fclose(fp);
1219                log_error(LOG_LEVEL_FATAL,
1220                   "can't load actions file '%s': out of memory",
1221                   csp->config->actions_file[fileid]);
1222                return 1; /* never get here */
1223             }
1224             init_action(cur_action);
1225
1226             /* trim { */
1227             strcpy(actions_buf, buf + 1);
1228
1229             /* check we have a trailing } and then trim it */
1230             end = actions_buf + strlen(actions_buf) - 1;
1231             if (*end != '}')
1232             {
1233                /* No closing } */
1234                fclose(fp);
1235                log_error(LOG_LEVEL_FATAL,
1236                   "can't load actions file '%s': invalid line (%lu): %s",
1237                   csp->config->actions_file[fileid], linenum, buf);
1238                return 1; /* never get here */
1239             }
1240             *end = '\0';
1241
1242             /* trim any whitespace immediately inside {} */
1243             chomp(actions_buf);
1244
1245             if (get_actions(actions_buf, alias_list, cur_action))
1246             {
1247                /* error */
1248                fclose(fp);
1249                log_error(LOG_LEVEL_FATAL,
1250                   "can't load actions file '%s': invalid line (%lu): %s",
1251                   csp->config->actions_file[fileid], linenum, buf);
1252                return 1; /* never get here */
1253             }
1254          }
1255       }
1256       else if (mode == MODE_SETTINGS)
1257       {
1258          /*
1259           * Part of the {{settings}} block.
1260           * For now only serves to check if the file's minimum Privoxy
1261           * version requirement is met, but we may want to read & check
1262           * permissions when we go multi-user.
1263           */
1264          if (!strncmp(buf, "for-privoxy-version=", 20))
1265          {
1266             char *version_string, *fields[3];
1267             int num_fields;
1268
1269             if ((version_string = strdup(buf + 20)) == NULL)
1270             {
1271                fclose(fp);
1272                log_error(LOG_LEVEL_FATAL,
1273                          "can't load actions file '%s': out of memory!",
1274                          csp->config->actions_file[fileid]);
1275                return 1; /* never get here */
1276             }
1277
1278             num_fields = ssplit(version_string, ".", fields, 3, TRUE, FALSE);
1279
1280             if (num_fields < 1 || atoi(fields[0]) == 0)
1281             {
1282                log_error(LOG_LEVEL_ERROR,
1283                  "While loading actions file '%s': invalid line (%lu): %s",
1284                   csp->config->actions_file[fileid], linenum, buf);
1285             }
1286             else if (                      atoi(fields[0]) > VERSION_MAJOR
1287                      || (num_fields > 1 && atoi(fields[1]) > VERSION_MINOR)
1288                      || (num_fields > 2 && atoi(fields[2]) > VERSION_POINT))
1289             {
1290                fclose(fp);
1291                log_error(LOG_LEVEL_FATAL,
1292                          "Actions file '%s', line %lu requires newer Privoxy version: %s",
1293                          csp->config->actions_file[fileid], linenum, buf );
1294                return 1; /* never get here */
1295             }
1296             free(version_string);
1297          }
1298       }
1299       else if (mode == MODE_DESCRIPTION)
1300       {
1301          /*
1302           * Part of the {{description}} block.
1303           * Ignore for now.
1304           */
1305       }
1306       else if (mode == MODE_ALIAS)
1307       {
1308          /*
1309           * define an alias
1310           */
1311          char  actions_buf[BUFFER_SIZE];
1312          struct action_alias * new_alias;
1313
1314          char * start = strchr(buf, '=');
1315          char * end = start;
1316
1317          if ((start == NULL) || (start == buf))
1318          {
1319             log_error(LOG_LEVEL_FATAL,
1320                "can't load actions file '%s': invalid alias line (%lu): %s",
1321                csp->config->actions_file[fileid], linenum, buf);
1322             return 1; /* never get here */
1323          }
1324
1325          if ((new_alias = zalloc(sizeof(*new_alias))) == NULL)
1326          {
1327             fclose(fp);
1328             log_error(LOG_LEVEL_FATAL,
1329                "can't load actions file '%s': out of memory!",
1330                csp->config->actions_file[fileid]);
1331             return 1; /* never get here */
1332          }
1333
1334          /* Eat any the whitespace before the '=' */
1335          end--;
1336          while ((*end == ' ') || (*end == '\t'))
1337          {
1338             /*
1339              * we already know we must have at least 1 non-ws char
1340              * at start of buf - no need to check
1341              */
1342             end--;
1343          }
1344          end[1] = '\0';
1345
1346          /* Eat any the whitespace after the '=' */
1347          start++;
1348          while ((*start == ' ') || (*start == '\t'))
1349          {
1350             start++;
1351          }
1352          if (*start == '\0')
1353          {
1354             log_error(LOG_LEVEL_FATAL,
1355                "can't load actions file '%s': invalid alias line (%lu): %s",
1356                csp->config->actions_file[fileid], linenum, buf);
1357             return 1; /* never get here */
1358          }
1359
1360          if ((new_alias->name = strdup(buf)) == NULL)
1361          {
1362             fclose(fp);
1363             log_error(LOG_LEVEL_FATAL,
1364                "can't load actions file '%s': out of memory!",
1365                csp->config->actions_file[fileid]);
1366             return 1; /* never get here */
1367          }
1368
1369          strcpy(actions_buf, start);
1370
1371          if (get_actions(actions_buf, alias_list, new_alias->action))
1372          {
1373             /* error */
1374             fclose(fp);
1375             log_error(LOG_LEVEL_FATAL,
1376                "can't load actions file '%s': invalid alias line (%lu): %s = %s",
1377                csp->config->actions_file[fileid], linenum, buf, start);
1378             return 1; /* never get here */
1379          }
1380
1381          /* add to list */
1382          new_alias->next = alias_list;
1383          alias_list = new_alias;
1384       }
1385       else if (mode == MODE_ACTIONS)
1386       {
1387          /* it's a URL pattern */
1388
1389          /* allocate a new node */
1390          if ((perm = zalloc(sizeof(*perm))) == NULL)
1391          {
1392             fclose(fp);
1393             log_error(LOG_LEVEL_FATAL,
1394                "can't load actions file '%s': out of memory!",
1395                csp->config->actions_file[fileid]);
1396             return 1; /* never get here */
1397          }
1398
1399          /* Save flags */
1400          copy_action (perm->action, cur_action);
1401
1402          /* Save the URL pattern */
1403          if (create_url_spec(perm->url, buf))
1404          {
1405             fclose(fp);
1406             log_error(LOG_LEVEL_FATAL,
1407                "can't load actions file '%s': line %lu: cannot create URL pattern from: %s",
1408                csp->config->actions_file[fileid], linenum, buf);
1409             return 1; /* never get here */
1410          }
1411
1412          /* add it to the list */
1413          last_perm->next = perm;
1414          last_perm = perm;
1415       }
1416       else if (mode == MODE_START_OF_FILE)
1417       {
1418          /* oops - please have a {} line as 1st line in file. */
1419          fclose(fp);
1420          log_error(LOG_LEVEL_FATAL,
1421             "can't load actions file '%s': first needed line (%lu) is invalid: %s",
1422             csp->config->actions_file[fileid], linenum, buf);
1423          return 1; /* never get here */
1424       }
1425       else
1426       {
1427          /* How did we get here? This is impossible! */
1428          fclose(fp);
1429          log_error(LOG_LEVEL_FATAL,
1430             "can't load actions file '%s': INTERNAL ERROR - mode = %d",
1431             csp->config->actions_file[fileid], mode);
1432          return 1; /* never get here */
1433       }
1434    }
1435
1436    fclose(fp);
1437
1438    free_action(cur_action);
1439    freez(cur_action);
1440
1441    free_alias_list(alias_list);
1442
1443    /* the old one is now obsolete */
1444    if (current_actions_file[fileid])
1445    {
1446       current_actions_file[fileid]->unloader = unload_actions_file;
1447    }
1448
1449    fs->next    = files->next;
1450    files->next = fs;
1451    current_actions_file[fileid] = fs;
1452
1453    csp->actions_list[fileid] = fs;
1454
1455    return(0);
1456
1457 }
1458
1459
1460 /*********************************************************************
1461  *
1462  * Function    :  actions_to_text
1463  *
1464  * Description :  Converts a actionsfile entry from the internal
1465  *                structurt into a text line.  The output is split
1466  *                into one line for each action with line continuation.
1467  *
1468  * Parameters  :
1469  *          1  :  action = The action to format.
1470  *
1471  * Returns     :  A string.  Caller must free it.
1472  *                NULL on out-of-memory error.
1473  *
1474  *********************************************************************/
1475 char * actions_to_text(struct action_spec *action)
1476 {
1477    unsigned mask = action->mask;
1478    unsigned add  = action->add;
1479    char * result = strdup("");
1480    struct list_entry * lst;
1481
1482    /* sanity - prevents "-feature +feature" */
1483    mask |= add;
1484
1485
1486 #define DEFINE_ACTION_BOOL(__name, __bit)          \
1487    if (!(mask & __bit))                            \
1488    {                                               \
1489       string_append(&result, " -" __name " \\\n"); \
1490    }                                               \
1491    else if (add & __bit)                           \
1492    {                                               \
1493       string_append(&result, " +" __name " \\\n"); \
1494    }
1495
1496 #define DEFINE_ACTION_STRING(__name, __bit, __index)   \
1497    if (!(mask & __bit))                                \
1498    {                                                   \
1499       string_append(&result, " -" __name " \\\n");     \
1500    }                                                   \
1501    else if (add & __bit)                               \
1502    {                                                   \
1503       string_append(&result, " +" __name "{");         \
1504       string_append(&result, action->string[__index]); \
1505       string_append(&result, "} \\\n");                \
1506    }
1507
1508 #define DEFINE_ACTION_MULTI(__name, __index)         \
1509    if (action->multi_remove_all[__index])            \
1510    {                                                 \
1511       string_append(&result, " -" __name " \\\n");   \
1512    }                                                 \
1513    else                                              \
1514    {                                                 \
1515       lst = action->multi_remove[__index]->first;    \
1516       while (lst)                                    \
1517       {                                              \
1518          string_append(&result, " -" __name "{");    \
1519          string_append(&result, lst->str);           \
1520          string_append(&result, "} \\\n");           \
1521          lst = lst->next;                            \
1522       }                                              \
1523    }                                                 \
1524    lst = action->multi_add[__index]->first;          \
1525    while (lst)                                       \
1526    {                                                 \
1527       string_append(&result, " +" __name "{");       \
1528       string_append(&result, lst->str);              \
1529       string_append(&result, "} \\\n");              \
1530       lst = lst->next;                               \
1531    }
1532
1533 #define DEFINE_ACTION_ALIAS 0 /* No aliases for output */
1534
1535 #include "actionlist.h"
1536
1537 #undef DEFINE_ACTION_MULTI
1538 #undef DEFINE_ACTION_STRING
1539 #undef DEFINE_ACTION_BOOL
1540 #undef DEFINE_ACTION_ALIAS
1541
1542    return result;
1543 }
1544
1545
1546 /*********************************************************************
1547  *
1548  * Function    :  actions_to_html
1549  *
1550  * Description :  Converts a actionsfile entry from numeric form
1551  *                ("mask" and "add") to a <br>-seperated HTML string
1552  *                in which each action is linked to its chapter in
1553  *                the user manual.
1554  *
1555  * Parameters  :
1556  *          1  :  csp    = Client state (for config)
1557  *          2  :  action = Action spec to be converted
1558  *
1559  * Returns     :  A string.  Caller must free it.
1560  *                NULL on out-of-memory error.
1561  *
1562  *********************************************************************/
1563 char * actions_to_html(struct client_state *csp,
1564                        struct action_spec *action)
1565 {
1566    unsigned mask = action->mask;
1567    unsigned add  = action->add;
1568    char * result = strdup("");
1569    struct list_entry * lst;
1570
1571    /* sanity - prevents "-feature +feature" */
1572    mask |= add;
1573
1574
1575 #define DEFINE_ACTION_BOOL(__name, __bit)       \
1576    if (!(mask & __bit))                         \
1577    {                                            \
1578       string_append(&result, "\n<br>-");        \
1579       string_join(&result, add_help_link(__name, csp->config)); \
1580    }                                            \
1581    else if (add & __bit)                        \
1582    {                                            \
1583       string_append(&result, "\n<br>+");        \
1584       string_join(&result, add_help_link(__name, csp->config)); \
1585    }
1586
1587 #define DEFINE_ACTION_STRING(__name, __bit, __index) \
1588    if (!(mask & __bit))                              \
1589    {                                                 \
1590       string_append(&result, "\n<br>-");             \
1591       string_join(&result, add_help_link(__name, csp->config)); \
1592    }                                                 \
1593    else if (add & __bit)                             \
1594    {                                                 \
1595       string_append(&result, "\n<br>+");             \
1596       string_join(&result, add_help_link(__name, csp->config)); \
1597       string_append(&result, "{");                   \
1598       string_join(&result, html_encode(action->string[__index])); \
1599       string_append(&result, "}");                   \
1600    }
1601
1602 #define DEFINE_ACTION_MULTI(__name, __index)          \
1603    if (action->multi_remove_all[__index])             \
1604    {                                                  \
1605       string_append(&result, "\n<br>-");              \
1606       string_join(&result, add_help_link(__name, csp->config)); \
1607    }                                                  \
1608    else                                               \
1609    {                                                  \
1610       lst = action->multi_remove[__index]->first;     \
1611       while (lst)                                     \
1612       {                                               \
1613          string_append(&result, "\n<br>-");           \
1614          string_join(&result, add_help_link(__name, csp->config)); \
1615          string_append(&result, "{");                 \
1616          string_join(&result, html_encode(lst->str)); \
1617          string_append(&result, "}");                 \
1618          lst = lst->next;                             \
1619       }                                               \
1620    }                                                  \
1621    lst = action->multi_add[__index]->first;           \
1622    while (lst)                                        \
1623    {                                                  \
1624       string_append(&result, "\n<br>+");              \
1625       string_join(&result, add_help_link(__name, csp->config)); \
1626       string_append(&result, "{");                    \
1627       string_join(&result, html_encode(lst->str));    \
1628       string_append(&result, "}");                    \
1629       lst = lst->next;                                \
1630    }
1631
1632 #define DEFINE_ACTION_ALIAS 0 /* No aliases for output */
1633
1634 #include "actionlist.h"
1635
1636 #undef DEFINE_ACTION_MULTI
1637 #undef DEFINE_ACTION_STRING
1638 #undef DEFINE_ACTION_BOOL
1639 #undef DEFINE_ACTION_ALIAS
1640
1641    /* trim leading <br> */
1642    if (result && *result)
1643    {
1644       char * s = result;
1645       result = strdup(result + 5);
1646       free(s);
1647    }
1648
1649    return result;
1650 }
1651
1652
1653 /*********************************************************************
1654  *
1655  * Function    :  current_actions_to_html
1656  *
1657  * Description :  Converts a curren action spec to a <br> seperated HTML
1658  *                text in which each action is linked to its chapter in
1659  *                the user manual.
1660  *
1661  * Parameters  :
1662  *          1  :  csp    = Client state (for config)
1663  *          2  :  action = Current action spec to be converted
1664  *
1665  * Returns     :  A string.  Caller must free it.
1666  *                NULL on out-of-memory error.
1667  *
1668  *********************************************************************/
1669 char *current_action_to_html(struct client_state *csp,
1670                              struct current_action_spec *action)
1671 {
1672    unsigned long flags  = action->flags;
1673    char * result = strdup("");
1674    struct list_entry * lst;
1675
1676 #define DEFINE_ACTION_BOOL(__name, __bit)  \
1677    if (flags & __bit)                      \
1678    {                                       \
1679       string_append(&result, "\n<br>+");   \
1680       string_join(&result, add_help_link(__name, csp->config)); \
1681    }                                       \
1682    else                                    \
1683    {                                       \
1684       string_append(&result, "\n<br>-");   \
1685       string_join(&result, add_help_link(__name, csp->config)); \
1686    }
1687
1688 #define DEFINE_ACTION_STRING(__name, __bit, __index)   \
1689    if (flags & __bit)                                  \
1690    {                                                   \
1691       string_append(&result, "\n<br>+");               \
1692       string_join(&result, add_help_link(__name, csp->config)); \
1693       string_append(&result, "{");                     \
1694       string_join(&result, html_encode(action->string[__index])); \
1695       string_append(&result, "}");                     \
1696    }                                                   \
1697    else                                                \
1698    {                                                   \
1699       string_append(&result, "\n<br>-");               \
1700       string_join(&result, add_help_link(__name, csp->config)); \
1701    }
1702
1703 #define DEFINE_ACTION_MULTI(__name, __index)           \
1704    lst = action->multi[__index]->first;                \
1705    if (lst == NULL)                                    \
1706    {                                                   \
1707       string_append(&result, "\n<br>-");              \
1708       string_join(&result, add_help_link(__name, csp->config)); \
1709    }                                                   \
1710    else                                                \
1711    {                                                   \
1712       while (lst)                                      \
1713       {                                                \
1714          string_append(&result, "\n<br>+");            \
1715          string_join(&result, add_help_link(__name, csp->config)); \
1716          string_append(&result, "{");                  \
1717          string_join(&result, html_encode(lst->str));  \
1718          string_append(&result, "}");                  \
1719          lst = lst->next;                              \
1720       }                                                \
1721    }
1722
1723 #define DEFINE_ACTION_ALIAS 0 /* No aliases for output */
1724
1725 #include "actionlist.h"
1726
1727 #undef DEFINE_ACTION_MULTI
1728 #undef DEFINE_ACTION_STRING
1729 #undef DEFINE_ACTION_BOOL
1730 #undef DEFINE_ACTION_ALIAS
1731
1732    return result;
1733 }