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