actions.c

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