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