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