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