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