Rebuild with utf-8 encoding
[privoxy.git] / cgiedit.c
1 const char cgiedit_rcs[] = "$Id: cgiedit.c,v 1.75 2012/03/09 17:55:49 fabiankeil Exp $";
2 /*********************************************************************
3  *
4  * File        :  $Source: /cvsroot/ijbswa/current/cgiedit.c,v $
5  *
6  * Purpose     :  CGI-based actionsfile editor.
7  *
8  *                NOTE: The CGIs in this file use parameter names
9  *                such as "f" and "s" which are really *BAD* choices.
10  *                However, I'm trying to save bytes in the
11  *                edit-actions-list HTML page - the standard actions
12  *                file generated a 550kbyte page, which is ridiculous.
13  *
14  *                Stick to the short names in this file for consistency.
15  *
16  * Copyright   :  Written by and Copyright (C) 2001-2008 the SourceForge
17  *                Privoxy team. http://www.privoxy.org/
18  *
19  *                Based on the Internet Junkbuster originally written
20  *                by and Copyright (C) 1997 Anonymous Coders and
21  *                Junkbusters Corporation.  http://www.junkbusters.com
22  *
23  *                This program is free software; you can redistribute it
24  *                and/or modify it under the terms of the GNU General
25  *                Public License as published by the Free Software
26  *                Foundation; either version 2 of the License, or (at
27  *                your option) any later version.
28  *
29  *                This program is distributed in the hope that it will
30  *                be useful, but WITHOUT ANY WARRANTY; without even the
31  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
32  *                PARTICULAR PURPOSE.  See the GNU General Public
33  *                License for more details.
34  *
35  *                The GNU General Public License should be included with
36  *                this file.  If not, you can view it at
37  *                http://www.gnu.org/copyleft/gpl.html
38  *                or write to the Free Software Foundation, Inc., 59
39  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
40  *
41  **********************************************************************/
42
43
44 #include "config.h"
45
46 /*
47  * FIXME: Following includes copied from cgi.c - which are actually needed?
48  */
49
50 #include <stdio.h>
51 #include <stdlib.h>
52 #include <sys/types.h>
53 #include <ctype.h>
54 #include <string.h>
55 #include <assert.h>
56 #include <sys/stat.h>
57
58 #include "project.h"
59 #include "cgi.h"
60 #include "cgiedit.h"
61 #include "cgisimple.h"
62 #include "list.h"
63 #include "encode.h"
64 #include "actions.h"
65 #include "miscutil.h"
66 #include "errlog.h"
67 #include "loaders.h"
68 #ifdef FEATURE_TOGGLE
69 /* loadcfg.h is for global_toggle_state only */
70 #include "loadcfg.h"
71 #endif /* def FEATURE_TOGGLE */
72 #include "urlmatch.h"
73
74 const char cgiedit_h_rcs[] = CGIEDIT_H_VERSION;
75
76
77 #ifdef FEATURE_CGI_EDIT_ACTIONS
78
79 /**
80  * A line in an editable_file.
81  */
82 struct file_line
83 {
84    /** Next entry in the linked list */
85    struct file_line * next;
86
87    /** The raw data, to write out if this line is unmodified. */
88    char * raw;
89
90    /** Comments and/or whitespace to put before this line if it's modified
91        and then written out. */
92    char * prefix;
93
94    /** The actual data, as a string.  Line continuation and comment removal
95        are performed on the data read from file before it's stored here, so
96        it will be a single line of data.  */
97    char * unprocessed;
98
99    /** The type of data on this line.  One of the FILE_LINE_xxx constants. */
100    int type;
101
102    /** The actual data, processed into some sensible data type. */
103    union
104    {
105
106       /** An action specification. */
107       struct action_spec action[1];
108
109       /** A name=value pair. */
110       struct
111       {
112
113          /** The name in the name=value pair. */
114          char * name;
115
116          /** The value in the name=value pair, as a string. */
117          char * svalue;
118
119          /** The value in the name=value pair, as an integer. */
120          int ivalue;
121
122       } setting;
123
124       /* Add more data types here... e.g.
125
126
127       struct url_spec url[1];
128
129       struct
130       {
131          struct action_spec action[1];
132          const char * name;
133       } alias;
134
135       */
136
137    } data;
138
139 };
140
141 /** This file_line has not been processed yet. */
142 #define FILE_LINE_UNPROCESSED           1
143
144 /** This file_line is blank. Can only appear at the end of a file, due to
145     the way the parser works. */
146 #define FILE_LINE_BLANK                 2
147
148 /** This file_line says {{alias}}. */
149 #define FILE_LINE_ALIAS_HEADER          3
150
151 /** This file_line defines an alias. */
152 #define FILE_LINE_ALIAS_ENTRY           4
153
154 /** This file_line defines an {action}. */
155 #define FILE_LINE_ACTION                5
156
157 /** This file_line specifies a URL pattern. */
158 #define FILE_LINE_URL                   6
159
160 /** This file_line says {{settings}}. */
161 #define FILE_LINE_SETTINGS_HEADER       7
162
163 /** This file_line is in a {{settings}} block. */
164 #define FILE_LINE_SETTINGS_ENTRY        8
165
166 /** This file_line says {{description}}. */
167 #define FILE_LINE_DESCRIPTION_HEADER    9
168
169 /** This file_line is in a {{description}} block. */
170 #define FILE_LINE_DESCRIPTION_ENTRY    10
171
172 /*
173  * Number of file modification time mismatches
174  * before the CGI editor gets turned off.
175  */
176 #define ACCEPTABLE_TIMESTAMP_MISMATCHES 3
177
178 /**
179  * A configuration file, in a format that can be edited and written back to
180  * disk.
181  */
182 struct editable_file
183 {
184    struct file_line * lines;  /**< The contents of the file.  A linked list of lines. */
185    const char * filename;     /**< Full pathname - e.g. "/etc/privoxy/wibble.action". */
186    unsigned identifier;       /**< The file name's position in csp->config->actions_file[]. */
187    const char * version_str;  /**< Last modification time, as a string.  For CGI param. */
188                               /**< Can be used in URL without using url_param(). */
189    unsigned version;          /**< Last modification time - prevents chaos with
190                                    the browser's "back" button.  Note that this is a
191                                    time_t cast to an unsigned.  When comparing, always
192                                    cast the time_t to an unsigned, and *NOT* vice-versa.
193                                    This may lose the top few bits, but they're not
194                                    significant anyway. */
195    int newline;               /**< Newline convention - one of the NEWLINE_xxx constants.
196                                    Note that changing this after the file has been
197                                    read in will cause a mess. */
198    struct file_line * parse_error; /**< On parse error, this is the offending line. */
199    const char * parse_error_text;  /**< On parse error, this is the problem.
200                                         (Statically allocated) */
201 };
202
203 /**
204  * Information about the filter types.
205  * Used for macro replacement in cgi_edit_actions_for_url.
206  */
207 struct filter_type_info
208 {
209    const int multi_action_index; /**< The multi action index as defined in project.h */
210    const char *macro_name;       /**< Name of the macro that has to be replaced
211                                       with the prepared templates.
212                                       For example "content-filter-params" */
213    const char *type;             /**< Name of the filter type,
214                                       for example "server-header-filter". */
215    /* XXX: check if these two can be combined. */
216    const char *disable_all_option; /**< Name of the catch-all radio option that has
217                                         to be checked or unchecked for this filter type. */
218    const char *disable_all_param;  /**< Name of the parameter that causes all filters of
219                                         this type to be disabled. */
220    const char *abbr_type;        /**< Abbreviation of the filter type, usually the
221                                       first or second character capitalized */
222    const char *anchor;           /**< Anchor for the User Manual link,
223                                       for example "SERVER-HEADER-FILTER"  */
224 };
225
226 /* Accessed by index, keep the order in the way the FT_ macros are defined. */
227 static const struct filter_type_info filter_type_info[] =
228 {
229    {
230       ACTION_MULTI_FILTER,
231       "content-filter-params", "filter",
232       "filter-all", "filter_all",
233       "F", "FILTER"
234    },
235    {
236       ACTION_MULTI_CLIENT_HEADER_FILTER,
237       "client-header-filter-params", "client-header-filter",
238       "client-header-filter-all", "client_header_filter_all",
239       "C", "CLIENT-HEADER-FILTER"
240    },
241    {
242       ACTION_MULTI_SERVER_HEADER_FILTER,
243       "server-header-filter-params", "server-header-filter",
244       "server-header-filter-all", "server_header_filter_all",
245       "S", "SERVER-HEADER-FILTER"
246    },
247    {
248       ACTION_MULTI_CLIENT_HEADER_TAGGER,
249       "client-header-tagger-params", "client-header-tagger",
250       "client-header-tagger-all", "client_header_tagger_all",
251       "L", "CLIENT-HEADER-TAGGER"
252    },
253    {
254       ACTION_MULTI_SERVER_HEADER_TAGGER,
255       "server-header-tagger-params", "server-header-tagger",
256       "server-header-tagger-all", "server_header_tagger_all",
257       "E", "SERVER-HEADER-TAGGER"
258    },
259 };
260
261 /* FIXME: Following non-static functions should be prototyped in .h or made static */
262
263 /* Functions to read and write arbitrary config files */
264 jb_err edit_read_file(struct client_state *csp,
265                       const struct map *parameters,
266                       int require_version,
267                       struct editable_file **pfile);
268 jb_err edit_write_file(struct editable_file * file);
269 void   edit_free_file(struct editable_file * file);
270
271 /* Functions to read and write actions files */
272 jb_err edit_parse_actions_file(struct editable_file * file);
273 jb_err edit_read_actions_file(struct client_state *csp,
274                               struct http_response *rsp,
275                               const struct map *parameters,
276                               int require_version,
277                               struct editable_file **pfile);
278
279 /* Error handlers */
280 jb_err cgi_error_modified(struct client_state *csp,
281                           struct http_response *rsp,
282                           const char *filename);
283 jb_err cgi_error_parse(struct client_state *csp,
284                        struct http_response *rsp,
285                        struct editable_file *file);
286 jb_err cgi_error_file(struct client_state *csp,
287                       struct http_response *rsp,
288                       const char *filename);
289 jb_err cgi_error_file_read_only(struct client_state *csp,
290                                 struct http_response *rsp,
291                                 const char *filename);
292
293 /* Internal arbitrary config file support functions */
294 static jb_err edit_read_file_lines(FILE *fp, struct file_line ** pfile, int *newline);
295 static void edit_free_file_lines(struct file_line * first_line);
296
297 /* Internal actions file support functions */
298 static int match_actions_file_header_line(const char * line, const char * name);
299 static jb_err split_line_on_equals(const char * line, char ** pname, char ** pvalue);
300
301 /* Internal parameter parsing functions */
302 static jb_err get_url_spec_param(struct client_state *csp,
303                                  const struct map *parameters,
304                                  const char *name,
305                                  char **pvalue);
306
307
308 /* Internal actionsfile <==> HTML conversion functions */
309 static jb_err map_radio(struct map * exports,
310                         const char * optionname,
311                         const char * values,
312                         int value);
313 static jb_err actions_to_radio(struct map * exports,
314                                const struct action_spec *action);
315 static jb_err actions_from_radio(const struct map * parameters,
316                                  struct action_spec *action);
317
318
319 static jb_err map_copy_parameter_html(struct map *out,
320                                       const struct map *in,
321                                       const char *name);
322
323 static jb_err get_file_name_param(struct client_state *csp,
324                                            const struct map *parameters,
325                                            const char *param_name,
326                                            const char **pfilename);
327
328 /* Internal convenience functions */
329 static char *section_target(const unsigned sectionid);
330
331 /*********************************************************************
332  *
333  * Function    :  section_target
334  *
335  * Description :  Given an unsigned (section id) n, produce a dynamically
336  *                allocated string of the form #l<n>, for use in link
337  *                targets.
338  *
339  *                XXX: The hash should be moved into the templates
340  *                to make this function more generic and render
341  *                stringify() obsolete.
342  *
343  * Parameters  :
344  *          1  :  sectionid = start line number of section
345  *
346  * Returns     :  String with link target, or NULL if out of
347  *                memory
348  *
349  *********************************************************************/
350 static char *section_target(const unsigned sectionid)
351 {
352    char buf[30];
353
354    snprintf(buf, sizeof(buf), "#l%d", sectionid);
355    return(strdup(buf));
356
357 }
358
359
360 /*********************************************************************
361  *
362  * Function    :  stringify
363  *
364  * Description :  Convert a number into a dynamically allocated string.
365  *
366  * Parameters  :
367  *          1  :  number = The number to convert.
368  *
369  * Returns     :  String with link target, or NULL if out of memory
370  *
371  *********************************************************************/
372 static char *stringify(const unsigned number)
373 {
374    char buf[6];
375
376    snprintf(buf, sizeof(buf), "%i", number);
377    return strdup(buf);
378 }
379
380
381 /*********************************************************************
382  *
383  * Function    :  map_copy_parameter_html
384  *
385  * Description :  Copy a CGI parameter from one map to another, HTML
386  *                encoding it.
387  *
388  * Parameters  :
389  *          1  :  out = target map
390  *          2  :  in = source map
391  *          3  :  name = name of cgi parameter to copy
392  *
393  * Returns     :  JB_ERR_OK on success
394  *                JB_ERR_MEMORY on out-of-memory
395  *                JB_ERR_CGI_PARAMS if the parameter doesn't exist
396  *                                  in the source map
397  *
398  *********************************************************************/
399 static jb_err map_copy_parameter_html(struct map *out,
400                                       const struct map *in,
401                                       const char *name)
402 {
403    const char * value;
404    jb_err err;
405
406    assert(out);
407    assert(in);
408    assert(name);
409
410    value = lookup(in, name);
411    err = map(out, name, 1, html_encode(value), 0);
412
413    if (err)
414    {
415       /* Out of memory */
416       return err;
417    }
418    else if (*value == '\0')
419    {
420       return JB_ERR_CGI_PARAMS;
421    }
422    else
423    {
424       return JB_ERR_OK;
425    }
426 }
427
428
429 /*********************************************************************
430  *
431  * Function    :  cgi_edit_actions_url_form
432  *
433  * Description :  CGI function that displays a form for
434  *                edit-actions-url
435  *
436  * Parameters  :
437  *          1  :  csp = Current client state (buffers, headers, etc...)
438  *          2  :  rsp = http_response data structure for output
439  *          3  :  parameters = map of cgi parameters
440  *
441  * CGI Parameters
442  *           i : (action index) Identifies the file to edit
443  *           v : (version) File's last-modified time
444  *           p : (pattern) Line number of pattern to edit
445  *
446  * Returns     :  JB_ERR_OK on success
447  *                JB_ERR_MEMORY on out-of-memory
448  *                JB_ERR_CGI_PARAMS if the CGI parameters are not
449  *                                  specified or not valid.
450  *
451  *********************************************************************/
452 jb_err cgi_edit_actions_url_form(struct client_state *csp,
453                                  struct http_response *rsp,
454                                  const struct map *parameters)
455 {
456    struct map * exports;
457    unsigned patternid;
458    struct editable_file * file;
459    struct file_line * cur_line;
460    unsigned line_number;
461    unsigned section_start_line_number = 0;
462    jb_err err;
463
464    assert(csp);
465    assert(rsp);
466    assert(parameters);
467
468    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
469    {
470       return cgi_error_disabled(csp, rsp);
471    }
472
473    err = get_number_param(csp, parameters, "p", &patternid);
474    if (err)
475    {
476       return err;
477    }
478
479    err = edit_read_actions_file(csp, rsp, parameters, 1, &file);
480    if (err)
481    {
482       /* No filename specified, can't read file, modified, or out of memory. */
483       return (err == JB_ERR_FILE ? JB_ERR_OK : err);
484    }
485
486    cur_line = file->lines;
487
488    for (line_number = 1; (cur_line != NULL) && (line_number < patternid); line_number++)
489    {
490       if (cur_line->type == FILE_LINE_ACTION)
491       {
492          section_start_line_number = line_number;
493       }
494       cur_line = cur_line->next;
495    }
496
497    if ( (cur_line == NULL)
498      || (line_number != patternid)
499      || (patternid < 1U)
500      || (cur_line->type != FILE_LINE_URL))
501    {
502       /* Invalid "patternid" parameter */
503       edit_free_file(file);
504       return JB_ERR_CGI_PARAMS;
505    }
506
507    if (NULL == (exports = default_exports(csp, NULL)))
508    {
509       edit_free_file(file);
510       return JB_ERR_MEMORY;
511    }
512
513    err = map(exports, "f", 1, stringify(file->identifier), 0);
514    if (!err) err = map(exports, "v", 1, file->version_str, 1);
515    if (!err) err = map(exports, "p", 1, url_encode(lookup(parameters, "p")), 0);
516    if (!err) err = map(exports, "u", 1, html_encode(cur_line->unprocessed), 0);
517    if (!err) err = map(exports, "jumptarget", 1, section_target(section_start_line_number), 0);
518
519    edit_free_file(file);
520
521    if (err)
522    {
523       free_map(exports);
524       return err;
525    }
526
527    return template_fill_for_cgi(csp, "edit-actions-url-form", exports, rsp);
528 }
529
530
531 /*********************************************************************
532  *
533  * Function    :  cgi_edit_actions_add_url_form
534  *
535  * Description :  CGI function that displays a form for
536  *                edit-actions-url
537  *
538  * Parameters  :
539  *          1  :  csp = Current client state (buffers, headers, etc...)
540  *          2  :  rsp = http_response data structure for output
541  *          3  :  parameters = map of cgi parameters
542  *
543  * CGI Parameters :
544  *           f : (filename) Identifies the file to edit
545  *           v : (version) File's last-modified time
546  *           s : (section) Line number of section to edit
547  *
548  * Returns     :  JB_ERR_OK on success
549  *                JB_ERR_MEMORY on out-of-memory
550  *                JB_ERR_CGI_PARAMS if the CGI parameters are not
551  *                                  specified or not valid.
552  *
553  *********************************************************************/
554 jb_err cgi_edit_actions_add_url_form(struct client_state *csp,
555                                      struct http_response *rsp,
556                                      const struct map *parameters)
557 {
558    struct map *exports;
559    jb_err err;
560
561    assert(csp);
562    assert(rsp);
563    assert(parameters);
564
565    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
566    {
567       return cgi_error_disabled(csp, rsp);
568    }
569
570    if (NULL == (exports = default_exports(csp, NULL)))
571    {
572       return JB_ERR_MEMORY;
573    }
574
575    err = map_copy_parameter_html(exports, parameters, "f");
576    if (!err) err = map_copy_parameter_html(exports, parameters, "v");
577    if (!err) err = map_copy_parameter_html(exports, parameters, "s");
578
579    if (err)
580    {
581       free_map(exports);
582       return err;
583    }
584
585    return template_fill_for_cgi(csp, "edit-actions-add-url-form", exports, rsp);
586 }
587
588
589 /*********************************************************************
590  *
591  * Function    :  cgi_edit_actions_remove_url_form
592  *
593  * Description :  CGI function that displays a form for
594  *                edit-actions-url
595  *
596  * Parameters  :
597  *          1  :  csp = Current client state (buffers, headers, etc...)
598  *          2  :  rsp = http_response data structure for output
599  *          3  :  parameters = map of cgi parameters
600  *
601  * CGI Parameters :
602  *           f : (number)  The action file identifier.
603  *           v : (version) File's last-modified time
604  *           p : (pattern) Line number of pattern to edit
605  *
606  * Returns     :  JB_ERR_OK on success
607  *                JB_ERR_MEMORY on out-of-memory
608  *                JB_ERR_CGI_PARAMS if the CGI parameters are not
609  *                                  specified or not valid.
610  *
611  *********************************************************************/
612 jb_err cgi_edit_actions_remove_url_form(struct client_state *csp,
613                                      struct http_response *rsp,
614                                      const struct map *parameters)
615 {
616    struct map * exports;
617    unsigned patternid;
618    struct editable_file * file;
619    struct file_line * cur_line;
620    unsigned line_number;
621    unsigned section_start_line_number = 0;
622    jb_err err;
623
624    assert(csp);
625    assert(rsp);
626    assert(parameters);
627
628    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
629    {
630       return cgi_error_disabled(csp, rsp);
631    }
632
633    err = get_number_param(csp, parameters, "p", &patternid);
634    if (err)
635    {
636       return err;
637    }
638
639    err = edit_read_actions_file(csp, rsp, parameters, 1, &file);
640    if (err)
641    {
642       /* No filename specified, can't read file, modified, or out of memory. */
643       return (err == JB_ERR_FILE ? JB_ERR_OK : err);
644    }
645
646    cur_line = file->lines;
647
648    for (line_number = 1; (cur_line != NULL) && (line_number < patternid); line_number++)
649    {
650       if (cur_line->type == FILE_LINE_ACTION)
651       {
652          section_start_line_number = line_number;
653       }
654       cur_line = cur_line->next;
655    }
656
657    if ( (cur_line == NULL)
658      || (line_number != patternid)
659      || (patternid < 1U)
660      || (cur_line->type != FILE_LINE_URL))
661    {
662       /* Invalid "patternid" parameter */
663       edit_free_file(file);
664       return JB_ERR_CGI_PARAMS;
665    }
666
667    if (NULL == (exports = default_exports(csp, NULL)))
668    {
669       edit_free_file(file);
670       return JB_ERR_MEMORY;
671    }
672
673    err = map(exports, "f", 1, stringify(file->identifier), 0);
674    if (!err) err = map(exports, "v", 1, file->version_str, 1);
675    if (!err) err = map(exports, "p", 1, url_encode(lookup(parameters, "p")), 0);
676    if (!err) err = map(exports, "u", 1, html_encode(cur_line->unprocessed), 0);
677    if (!err) err = map(exports, "jumptarget", 1, section_target(section_start_line_number), 0);
678    if (!err) err = map(exports, "actions-file", 1, html_encode(file->filename), 0);
679
680    edit_free_file(file);
681
682    if (err)
683    {
684       free_map(exports);
685       return err;
686    }
687
688    return template_fill_for_cgi(csp, "edit-actions-remove-url-form", exports, rsp);
689 }
690
691
692 /*********************************************************************
693  *
694  * Function    :  edit_write_file
695  *
696  * Description :  Write a complete file to disk.
697  *
698  * Parameters  :
699  *          1  :  file = File to write.
700  *
701  * Returns     :  JB_ERR_OK     on success
702  *                JB_ERR_FILE   on error writing to file.
703  *                JB_ERR_MEMORY on out of memory
704  *
705  *********************************************************************/
706 jb_err edit_write_file(struct editable_file * file)
707 {
708    FILE * fp;
709    struct file_line * cur_line;
710    struct stat statbuf[1];
711    char version_buf[22]; /* 22 = ceil(log10(2^64)) + 2 = max number of
712                             digits in time_t, assuming this is a 64-bit
713                             machine, plus null terminator, plus one
714                             for paranoia */
715
716    assert(file);
717    assert(file->filename);
718
719    if (NULL == (fp = fopen(file->filename, "wb")))
720    {
721       return JB_ERR_FILE;
722    }
723
724    cur_line = file->lines;
725    while (cur_line != NULL)
726    {
727       if (cur_line->raw)
728       {
729          if (fputs(cur_line->raw, fp) < 0)
730          {
731             fclose(fp);
732             return JB_ERR_FILE;
733          }
734       }
735       else
736       {
737          if (cur_line->prefix)
738          {
739             if (fputs(cur_line->prefix, fp) < 0)
740             {
741                fclose(fp);
742                return JB_ERR_FILE;
743             }
744          }
745          if (cur_line->unprocessed)
746          {
747
748             if (NULL != strchr(cur_line->unprocessed, '#'))
749             {
750                /* Must quote '#' characters */
751                int numhash = 0;
752                size_t len;
753                char * src;
754                char * dest;
755                char * str;
756
757                /* Count number of # characters, so we know length of output string */
758                src = cur_line->unprocessed;
759                while (NULL != (src = strchr(src, '#')))
760                {
761                   numhash++;
762                   src++;
763                }
764                assert(numhash > 0);
765
766                /* Allocate new memory for string */
767                len = strlen(cur_line->unprocessed) + (size_t)numhash;
768                str = malloc_or_die(len + 1);
769
770                /* Copy string but quote hashes */
771                src  = cur_line->unprocessed;
772                dest = str;
773                while (*src)
774                {
775                   if (*src == '#')
776                   {
777                      *dest++ = '\\';
778                      numhash--;
779                      assert(numhash >= 0);
780                   }
781                   *dest++ = *src++;
782                }
783                *dest = '\0';
784
785                assert(numhash == 0);
786                assert(strlen(str) == len);
787                assert(str == dest - len);
788                assert(src - len <= cur_line->unprocessed);
789
790                if ((strlen(str) != len) || (numhash != 0))
791                {
792                   /*
793                    * Escaping didn't work as expected, go spread the news.
794                    * Only reached in non-debugging builds.
795                    */
796                   log_error(LOG_LEVEL_ERROR,
797                      "Looks like hash escaping failed. %s might be corrupted now.",
798                      file->filename);
799                }
800
801                if (fputs(str, fp) < 0)
802                {
803                   free(str);
804                   fclose(fp);
805                   return JB_ERR_FILE;
806                }
807
808                free(str);
809             }
810             else
811             {
812                /* Can write without quoting '#' characters. */
813                if (fputs(cur_line->unprocessed, fp) < 0)
814                {
815                   fclose(fp);
816                   return JB_ERR_FILE;
817                }
818             }
819             if (fputs(NEWLINE(file->newline), fp) < 0)
820             {
821                fclose(fp);
822                return JB_ERR_FILE;
823             }
824          }
825          else
826          {
827             /* FIXME: Write data from file->data->whatever */
828             assert(0);
829          }
830       }
831       cur_line = cur_line->next;
832    }
833
834    fclose(fp);
835
836
837    /* Update the version stamp in the file structure, since we just
838     * wrote to the file & changed it's date.
839     */
840    if (stat(file->filename, statbuf) < 0)
841    {
842       /* Error, probably file not found. */
843       return JB_ERR_FILE;
844    }
845    file->version = (unsigned)statbuf->st_mtime;
846
847    /* Correct file->version_str */
848    freez(file->version_str);
849    snprintf(version_buf, sizeof(version_buf), "%u", file->version);
850    version_buf[sizeof(version_buf)-1] = '\0';
851    file->version_str = strdup(version_buf);
852    if (version_buf == NULL)
853    {
854       return JB_ERR_MEMORY;
855    }
856
857    return JB_ERR_OK;
858 }
859
860
861 /*********************************************************************
862  *
863  * Function    :  edit_free_file
864  *
865  * Description :  Free a complete file in memory.
866  *
867  * Parameters  :
868  *          1  :  file = Data structure to free.
869  *
870  * Returns     :  N/A
871  *
872  *********************************************************************/
873 void edit_free_file(struct editable_file * file)
874 {
875    if (!file)
876    {
877       /* Silently ignore NULL pointer */
878       return;
879    }
880
881    edit_free_file_lines(file->lines);
882    freez(file->version_str);
883    file->version = 0;
884    file->parse_error_text = NULL; /* Statically allocated */
885    file->parse_error = NULL;
886
887    free(file);
888 }
889
890
891 /*********************************************************************
892  *
893  * Function    :  edit_free_file_lines
894  *
895  * Description :  Free an entire linked list of file lines.
896  *
897  * Parameters  :
898  *          1  :  first_line = Data structure to free.
899  *
900  * Returns     :  N/A
901  *
902  *********************************************************************/
903 static void edit_free_file_lines(struct file_line * first_line)
904 {
905    struct file_line * next_line;
906
907    while (first_line != NULL)
908    {
909       next_line = first_line->next;
910       first_line->next = NULL;
911       freez(first_line->raw);
912       freez(first_line->prefix);
913       freez(first_line->unprocessed);
914       switch(first_line->type)
915       {
916          case 0: /* special case if memory zeroed */
917          case FILE_LINE_UNPROCESSED:
918          case FILE_LINE_BLANK:
919          case FILE_LINE_ALIAS_HEADER:
920          case FILE_LINE_SETTINGS_HEADER:
921          case FILE_LINE_DESCRIPTION_HEADER:
922          case FILE_LINE_DESCRIPTION_ENTRY:
923          case FILE_LINE_ALIAS_ENTRY:
924          case FILE_LINE_URL:
925             /* No data is stored for these */
926             break;
927
928          case FILE_LINE_ACTION:
929             free_action(first_line->data.action);
930             break;
931
932          case FILE_LINE_SETTINGS_ENTRY:
933             freez(first_line->data.setting.name);
934             freez(first_line->data.setting.svalue);
935             break;
936          default:
937             /* Should never happen */
938             assert(0);
939             break;
940       }
941       first_line->type = 0; /* paranoia */
942       free(first_line);
943       first_line = next_line;
944    }
945 }
946
947
948 /*********************************************************************
949  *
950  * Function    :  match_actions_file_header_line
951  *
952  * Description :  Match an actions file {{header}} line
953  *
954  * Parameters  :
955  *          1  :  line = String from file
956  *          2  :  name = Header to match against
957  *
958  * Returns     :  0 iff they match.
959  *
960  *********************************************************************/
961 static int match_actions_file_header_line(const char * line, const char * name)
962 {
963    size_t len;
964
965    assert(line);
966    assert(name);
967
968    /* Look for "{{" */
969    if ((line[0] != '{') || (line[1] != '{'))
970    {
971       return 1;
972    }
973    line += 2;
974
975    /* Look for optional whitespace */
976    while ((*line == ' ') || (*line == '\t'))
977    {
978       line++;
979    }
980
981    /* Look for the specified name (case-insensitive) */
982    len = strlen(name);
983    if (0 != strncmpic(line, name, len))
984    {
985       return 1;
986    }
987    line += len;
988
989    /* Look for optional whitespace */
990    while ((*line == ' ') || (*line == '\t'))
991    {
992       line++;
993    }
994
995    /* Look for "}}" and end of string*/
996    if ((line[0] != '}') || (line[1] != '}') || (line[2] != '\0'))
997    {
998       return 1;
999    }
1000
1001    /* It matched!! */
1002    return 0;
1003 }
1004
1005
1006 /*********************************************************************
1007  *
1008  * Function    :  match_actions_file_header_line
1009  *
1010  * Description :  Match an actions file {{header}} line
1011  *
1012  * Parameters  :
1013  *          1  :  line = String from file.  Must not start with
1014  *                       whitespace (else infinite loop!)
1015  *          2  :  pname = Destination for name
1016  *          2  :  pvalue = Destination for value
1017  *
1018  * Returns     :  JB_ERR_OK     on success
1019  *                JB_ERR_MEMORY on out-of-memory
1020  *                JB_ERR_PARSE  if there's no "=" sign, or if there's
1021  *                              nothing before the "=" sign (but empty
1022  *                              values *after* the "=" sign are legal).
1023  *
1024  *********************************************************************/
1025 static jb_err split_line_on_equals(const char * line, char ** pname, char ** pvalue)
1026 {
1027    const char * name_end;
1028    const char * value_start;
1029    size_t name_len;
1030
1031    assert(line);
1032    assert(pname);
1033    assert(pvalue);
1034    assert(*line != ' ');
1035    assert(*line != '\t');
1036
1037    *pname = NULL;
1038    *pvalue = NULL;
1039
1040    value_start = strchr(line, '=');
1041    if ((value_start == NULL) || (value_start == line))
1042    {
1043       return JB_ERR_PARSE;
1044    }
1045
1046    name_end = value_start - 1;
1047
1048    /* Eat any whitespace before the '=' */
1049    while ((*name_end == ' ') || (*name_end == '\t'))
1050    {
1051       /*
1052        * we already know we must have at least 1 non-ws char
1053        * at start of buf - no need to check
1054        */
1055       name_end--;
1056    }
1057
1058    name_len = (size_t)(name_end - line) + 1; /* Length excluding \0 */
1059    *pname = malloc_or_die(name_len + 1);
1060    strncpy(*pname, line, name_len);
1061    (*pname)[name_len] = '\0';
1062
1063    /* Eat any the whitespace after the '=' */
1064    value_start++;
1065    while ((*value_start == ' ') || (*value_start == '\t'))
1066    {
1067       value_start++;
1068    }
1069
1070    if (NULL == (*pvalue = strdup(value_start)))
1071    {
1072       free(*pname);
1073       *pname = NULL;
1074       return JB_ERR_MEMORY;
1075    }
1076
1077    return JB_ERR_OK;
1078 }
1079
1080
1081 /*********************************************************************
1082  *
1083  * Function    :  edit_parse_actions_file
1084  *
1085  * Description :  Parse an actions file in memory.
1086  *
1087  *                Passed linked list must have the "data" member
1088  *                zeroed, and must contain valid "next" and
1089  *                "unprocessed" fields.  The "raw" and "prefix"
1090  *                fields are ignored, and "type" is just overwritten.
1091  *
1092  *                Note that on error the file may have been
1093  *                partially parsed.
1094  *
1095  * Parameters  :
1096  *          1  :  file = Actions file to be parsed in-place.
1097  *
1098  * Returns     :  JB_ERR_OK     on success
1099  *                JB_ERR_MEMORY on out-of-memory
1100  *                JB_ERR_PARSE  on error
1101  *
1102  *********************************************************************/
1103 jb_err edit_parse_actions_file(struct editable_file * file)
1104 {
1105    struct file_line * cur_line;
1106    size_t len;
1107    const char * text; /* Text from a line */
1108    char * name;  /* For lines of the form name=value */
1109    char * value; /* For lines of the form name=value */
1110    struct action_alias * alias_list = NULL;
1111    jb_err err = JB_ERR_OK;
1112
1113    /* alias_list contains the aliases defined in this file.
1114     * It might be better to use the "file_line.data" fields
1115     * in the relavent places instead.
1116     */
1117
1118    cur_line = file->lines;
1119
1120    /* A note about blank line support: Blank lines should only
1121     * ever occur as the last line in the file.  This function
1122     * is more forgiving than that - FILE_LINE_BLANK can occur
1123     * anywhere.
1124     */
1125
1126    /* Skip leading blanks.  Should only happen if file is
1127     * empty (which is valid, but pointless).
1128     */
1129    while ((cur_line != NULL)
1130        && (cur_line->unprocessed[0] == '\0'))
1131    {
1132       /* Blank line */
1133       cur_line->type = FILE_LINE_BLANK;
1134       cur_line = cur_line->next;
1135    }
1136
1137    if ((cur_line != NULL)
1138     && (cur_line->unprocessed[0] != '{'))
1139    {
1140       /* File doesn't start with a header */
1141       file->parse_error = cur_line;
1142       file->parse_error_text = "First (non-comment) line of the file must contain a header.";
1143       return JB_ERR_PARSE;
1144    }
1145
1146    if ((cur_line != NULL) && (0 ==
1147       match_actions_file_header_line(cur_line->unprocessed, "settings")))
1148    {
1149       cur_line->type = FILE_LINE_SETTINGS_HEADER;
1150
1151       cur_line = cur_line->next;
1152       while ((cur_line != NULL) && (cur_line->unprocessed[0] != '{'))
1153       {
1154          if (cur_line->unprocessed[0])
1155          {
1156             cur_line->type = FILE_LINE_SETTINGS_ENTRY;
1157
1158             err = split_line_on_equals(cur_line->unprocessed,
1159                      &cur_line->data.setting.name,
1160                      &cur_line->data.setting.svalue);
1161             if (err == JB_ERR_MEMORY)
1162             {
1163                return err;
1164             }
1165             else if (err != JB_ERR_OK)
1166             {
1167                /* Line does not contain a name=value pair */
1168                file->parse_error = cur_line;
1169                file->parse_error_text = "Expected a name=value pair on this {{description}} line, but couldn't find one.";
1170                return JB_ERR_PARSE;
1171             }
1172          }
1173          else
1174          {
1175             cur_line->type = FILE_LINE_BLANK;
1176          }
1177          cur_line = cur_line->next;
1178       }
1179    }
1180
1181    if ((cur_line != NULL) && (0 ==
1182       match_actions_file_header_line(cur_line->unprocessed, "description")))
1183    {
1184       cur_line->type = FILE_LINE_DESCRIPTION_HEADER;
1185
1186       cur_line = cur_line->next;
1187       while ((cur_line != NULL) && (cur_line->unprocessed[0] != '{'))
1188       {
1189          if (cur_line->unprocessed[0])
1190          {
1191             cur_line->type = FILE_LINE_DESCRIPTION_ENTRY;
1192          }
1193          else
1194          {
1195             cur_line->type = FILE_LINE_BLANK;
1196          }
1197          cur_line = cur_line->next;
1198       }
1199    }
1200
1201    if ((cur_line != NULL) && (0 ==
1202       match_actions_file_header_line(cur_line->unprocessed, "alias")))
1203    {
1204       cur_line->type = FILE_LINE_ALIAS_HEADER;
1205
1206       cur_line = cur_line->next;
1207       while ((cur_line != NULL) && (cur_line->unprocessed[0] != '{'))
1208       {
1209          if (cur_line->unprocessed[0])
1210          {
1211             /* define an alias */
1212             struct action_alias * new_alias;
1213
1214             cur_line->type = FILE_LINE_ALIAS_ENTRY;
1215
1216             err = split_line_on_equals(cur_line->unprocessed, &name, &value);
1217             if (err == JB_ERR_MEMORY)
1218             {
1219                return err;
1220             }
1221             else if (err != JB_ERR_OK)
1222             {
1223                /* Line does not contain a name=value pair */
1224                file->parse_error = cur_line;
1225                file->parse_error_text = "Expected a name=value pair on this {{alias}} line, but couldn't find one.";
1226                return JB_ERR_PARSE;
1227             }
1228
1229             if ((new_alias = zalloc(sizeof(*new_alias))) == NULL)
1230             {
1231                /* Out of memory */
1232                free(name);
1233                free(value);
1234                free_alias_list(alias_list);
1235                return JB_ERR_MEMORY;
1236             }
1237
1238             err = get_actions(value, alias_list, new_alias->action);
1239             if (err)
1240             {
1241                /* Invalid action or out of memory */
1242                free(name);
1243                free(value);
1244                free(new_alias);
1245                free_alias_list(alias_list);
1246                if (err == JB_ERR_MEMORY)
1247                {
1248                   return err;
1249                }
1250                else
1251                {
1252                   /* Line does not contain a name=value pair */
1253                   file->parse_error = cur_line;
1254                   file->parse_error_text = "This alias does not specify a valid set of actions.";
1255                   return JB_ERR_PARSE;
1256                }
1257             }
1258
1259             free(value);
1260
1261             new_alias->name = name;
1262
1263             /* add to list */
1264             new_alias->next = alias_list;
1265             alias_list = new_alias;
1266          }
1267          else
1268          {
1269             cur_line->type = FILE_LINE_BLANK;
1270          }
1271          cur_line = cur_line->next;
1272       }
1273    }
1274
1275    /* Header done, process the main part of the file */
1276    while (cur_line != NULL)
1277    {
1278       /* At this point, (cur_line->unprocessed[0] == '{') */
1279       assert(cur_line->unprocessed[0] == '{');
1280       text = cur_line->unprocessed + 1;
1281       len = strlen(text) - 1;
1282       if (text[len] != '}')
1283       {
1284          /* No closing } on header */
1285          free_alias_list(alias_list);
1286          file->parse_error = cur_line;
1287          file->parse_error_text = "Headers starting with '{' must have a "
1288             "closing bracket ('}').  Headers starting with two brackets ('{{') "
1289             "must close with two brackets ('}}').";
1290          return JB_ERR_PARSE;
1291       }
1292
1293       if (text[0] == '{')
1294       {
1295          /* An invalid {{ header.  */
1296          free_alias_list(alias_list);
1297          file->parse_error = cur_line;
1298          file->parse_error_text = "Unknown or unexpected two-bracket header.  "
1299             "Please remember that the system (two-bracket) headers must "
1300             "appear in the order {{settings}}, {{description}}, {{alias}}, "
1301             "and must appear before any actions (one-bracket) headers.  "
1302             "Also note that system headers may not be repeated.";
1303          return JB_ERR_PARSE;
1304       }
1305
1306       while ((*text == ' ') || (*text == '\t'))
1307       {
1308          text++;
1309          len--;
1310       }
1311       while ((len > (size_t)0)
1312            && ((text[len - 1] == ' ')
1313             || (text[len - 1] == '\t')))
1314       {
1315          len--;
1316       }
1317
1318       cur_line->type = FILE_LINE_ACTION;
1319
1320       /* Remove {} and make copy */
1321       value = malloc_or_die(len + 1);
1322       strncpy(value, text, len);
1323       value[len] = '\0';
1324
1325       /* Get actions */
1326       err = get_actions(value, alias_list, cur_line->data.action);
1327       if (err)
1328       {
1329          /* Invalid action or out of memory */
1330          free(value);
1331          free_alias_list(alias_list);
1332          if (err == JB_ERR_MEMORY)
1333          {
1334             return err;
1335          }
1336          else
1337          {
1338             /* Line does not contain a name=value pair */
1339             file->parse_error = cur_line;
1340             file->parse_error_text = "This header does not specify a valid set of actions.";
1341             return JB_ERR_PARSE;
1342          }
1343       }
1344
1345       /* Done with string - it was clobbered anyway */
1346       free(value);
1347
1348       /* Process next line */
1349       cur_line = cur_line->next;
1350
1351       /* Loop processing URL patterns */
1352       while ((cur_line != NULL) && (cur_line->unprocessed[0] != '{'))
1353       {
1354          if (cur_line->unprocessed[0])
1355          {
1356             /* Could parse URL here, but this isn't currently needed */
1357
1358             cur_line->type = FILE_LINE_URL;
1359          }
1360          else
1361          {
1362             cur_line->type = FILE_LINE_BLANK;
1363          }
1364          cur_line = cur_line->next;
1365       }
1366    } /* End main while(cur_line != NULL) loop */
1367
1368    free_alias_list(alias_list);
1369
1370    return JB_ERR_OK;
1371 }
1372
1373
1374 /*********************************************************************
1375  *
1376  * Function    :  edit_read_file_lines
1377  *
1378  * Description :  Read all the lines of a file into memory.
1379  *                Handles whitespace, comments and line continuation.
1380  *
1381  * Parameters  :
1382  *          1  :  fp = File to read from.  On return, this will be
1383  *                     at EOF but it will not have been closed.
1384  *          2  :  pfile = Destination for a linked list of file_lines.
1385  *                        Will be set to NULL on error.
1386  *          3  :  newline = How to handle newlines.
1387  *
1388  * Returns     :  JB_ERR_OK     on success
1389  *                JB_ERR_MEMORY on out-of-memory
1390  *
1391  *********************************************************************/
1392 jb_err edit_read_file_lines(FILE *fp, struct file_line ** pfile, int *newline)
1393 {
1394    struct file_line * first_line; /* Keep for return value or to free */
1395    struct file_line * cur_line;   /* Current line */
1396    struct file_line * prev_line;  /* Entry with prev_line->next = cur_line */
1397    jb_err rval;
1398
1399    assert(fp);
1400    assert(pfile);
1401
1402    *pfile = NULL;
1403
1404    cur_line = first_line = zalloc(sizeof(struct file_line));
1405    if (cur_line == NULL)
1406    {
1407       return JB_ERR_MEMORY;
1408    }
1409
1410    cur_line->type = FILE_LINE_UNPROCESSED;
1411
1412    rval = edit_read_line(fp, &cur_line->raw, &cur_line->prefix, &cur_line->unprocessed, newline, NULL);
1413    if (rval)
1414    {
1415       /* Out of memory or empty file. */
1416       /* Note that empty file is not an error we propagate up */
1417       free(cur_line);
1418       return ((rval == JB_ERR_FILE) ? JB_ERR_OK : rval);
1419    }
1420
1421    do
1422    {
1423       prev_line = cur_line;
1424       cur_line = prev_line->next = zalloc(sizeof(struct file_line));
1425       if (cur_line == NULL)
1426       {
1427          /* Out of memory */
1428          edit_free_file_lines(first_line);
1429          return JB_ERR_MEMORY;
1430       }
1431
1432       cur_line->type = FILE_LINE_UNPROCESSED;
1433
1434       rval = edit_read_line(fp, &cur_line->raw, &cur_line->prefix, &cur_line->unprocessed, newline, NULL);
1435       if ((rval != JB_ERR_OK) && (rval != JB_ERR_FILE))
1436       {
1437          /* Out of memory */
1438          edit_free_file_lines(first_line);
1439          return JB_ERR_MEMORY;
1440       }
1441
1442    }
1443    while (rval != JB_ERR_FILE);
1444
1445    /* EOF */
1446
1447    /* We allocated one too many - free it */
1448    prev_line->next = NULL;
1449    free(cur_line);
1450
1451    *pfile = first_line;
1452    return JB_ERR_OK;
1453 }
1454
1455
1456 /*********************************************************************
1457  *
1458  * Function    :  edit_read_file
1459  *
1460  * Description :  Read a complete file into memory.
1461  *                Handles CGI parameter parsing.  If requested, also
1462  *                checks the file's modification timestamp.
1463  *
1464  * Parameters  :
1465  *          1  :  csp = Current client state (buffers, headers, etc...)
1466  *          2  :  parameters = map of cgi parameters.
1467  *          3  :  require_version = true to check "ver" parameter.
1468  *          4  :  pfile = Destination for the file.  Will be set
1469  *                        to NULL on error.
1470  *
1471  * CGI Parameters :
1472  *           f :  The action file identifier.
1473  *         ver :  (Only if require_version is nonzero)
1474  *                Timestamp of the actions file.  If wrong, this
1475  *                function fails with JB_ERR_MODIFIED.
1476  *
1477  * Returns     :  JB_ERR_OK     on success
1478  *                JB_ERR_MEMORY on out-of-memory
1479  *                JB_ERR_CGI_PARAMS if "filename" was not specified
1480  *                                  or is not valid.
1481  *                JB_ERR_FILE   if the file cannot be opened or
1482  *                              contains no data
1483  *                JB_ERR_MODIFIED if version checking was requested and
1484  *                                failed - the file was modified outside
1485  *                                of this CGI editor instance.
1486  *
1487  *********************************************************************/
1488 jb_err edit_read_file(struct client_state *csp,
1489                       const struct map *parameters,
1490                       int require_version,
1491                       struct editable_file **pfile)
1492 {
1493    struct file_line * lines;
1494    FILE * fp;
1495    jb_err err;
1496    const char *filename = NULL;
1497    struct editable_file * file;
1498    unsigned version = 0;
1499    struct stat statbuf[1];
1500    char version_buf[22];
1501    int newline = NEWLINE_UNKNOWN;
1502    unsigned i;
1503
1504    assert(csp);
1505    assert(parameters);
1506    assert(pfile);
1507
1508    *pfile = NULL;
1509
1510    err = get_number_param(csp, parameters, "f", &i);
1511    if ((JB_ERR_OK == err) && (i < MAX_AF_FILES) && (NULL != csp->config->actions_file[i]))
1512    {
1513       filename = csp->config->actions_file[i];
1514    }
1515    else if (JB_ERR_CGI_PARAMS == err)
1516    {
1517       /*
1518        * Probably an old-school URL like
1519        * http://config.privoxy.org/edit-actions-list?f=default
1520        */
1521       get_file_name_param(csp, parameters, "f", &filename);
1522    }
1523
1524    if (NULL == filename || stat(filename, statbuf) < 0)
1525    {
1526       /* Error, probably file not found. */
1527       return JB_ERR_FILE;
1528    }
1529    version = (unsigned) statbuf->st_mtime;
1530
1531    if (require_version)
1532    {
1533       unsigned specified_version;
1534       err = get_number_param(csp, parameters, "v", &specified_version);
1535       if (err)
1536       {
1537          return err;
1538       }
1539
1540       if (version != specified_version)
1541       {
1542          return JB_ERR_MODIFIED;
1543       }
1544    }
1545
1546    if (NULL == (fp = fopen(filename,"rb")))
1547    {
1548       return JB_ERR_FILE;
1549    }
1550
1551    err = edit_read_file_lines(fp, &lines, &newline);
1552
1553    fclose(fp);
1554
1555    if (err)
1556    {
1557       return err;
1558    }
1559
1560    file = (struct editable_file *) zalloc(sizeof(*file));
1561    if (err)
1562    {
1563       edit_free_file_lines(lines);
1564       return err;
1565    }
1566
1567    file->lines = lines;
1568    file->newline = newline;
1569    file->filename = filename;
1570    file->version = version;
1571    file->identifier = i;
1572
1573    /* Correct file->version_str */
1574    freez(file->version_str);
1575    snprintf(version_buf, sizeof(version_buf), "%u", file->version);
1576    version_buf[sizeof(version_buf)-1] = '\0';
1577    file->version_str = strdup(version_buf);
1578    if (version_buf == NULL)
1579    {
1580       edit_free_file(file);
1581       return JB_ERR_MEMORY;
1582    }
1583
1584    *pfile = file;
1585    return JB_ERR_OK;
1586 }
1587
1588
1589 /*********************************************************************
1590  *
1591  * Function    :  edit_read_actions_file
1592  *
1593  * Description :  Read a complete actions file into memory.
1594  *                Handles CGI parameter parsing.  If requested, also
1595  *                checks the file's modification timestamp.
1596  *
1597  *                If this function detects an error in the categories
1598  *                JB_ERR_FILE, JB_ERR_MODIFIED, or JB_ERR_PARSE,
1599  *                then it handles it by filling in the specified
1600  *                response structure and returning JB_ERR_FILE.
1601  *
1602  * Parameters  :
1603  *          1  :  csp = Current client state (buffers, headers, etc...)
1604  *          2  :  rsp = HTTP response.  Only filled in on error.
1605  *          2  :  parameters = map of cgi parameters.
1606  *          3  :  require_version = true to check "ver" parameter.
1607  *          4  :  pfile = Destination for the file.  Will be set
1608  *                        to NULL on error.
1609  *
1610  * CGI Parameters :
1611  *           f :  The actions file identifier.
1612  *         ver :  (Only if require_version is nonzero)
1613  *                Timestamp of the actions file.  If wrong, this
1614  *                function fails with JB_ERR_MODIFIED.
1615  *
1616  * Returns     :  JB_ERR_OK     on success
1617  *                JB_ERR_MEMORY on out-of-memory
1618  *                JB_ERR_CGI_PARAMS if "filename" was not specified
1619  *                                  or is not valid.
1620  *                JB_ERR_FILE  if the file does not contain valid data,
1621  *                             or if file cannot be opened or
1622  *                             contains no data, or if version
1623  *                             checking was requested and failed.
1624  *
1625  *********************************************************************/
1626 jb_err edit_read_actions_file(struct client_state *csp,
1627                               struct http_response *rsp,
1628                               const struct map *parameters,
1629                               int require_version,
1630                               struct editable_file **pfile)
1631 {
1632    jb_err err;
1633    struct editable_file *file;
1634    static int acceptable_failures = ACCEPTABLE_TIMESTAMP_MISMATCHES - 1;
1635
1636    assert(csp);
1637    assert(parameters);
1638    assert(pfile);
1639
1640    *pfile = NULL;
1641
1642    err = edit_read_file(csp, parameters, require_version, &file);
1643    if (err)
1644    {
1645       /* Try to handle if possible */
1646       if (err == JB_ERR_FILE)
1647       {
1648          err = cgi_error_file(csp, rsp, lookup(parameters, "f"));
1649       }
1650       else if (err == JB_ERR_MODIFIED)
1651       {
1652          assert(require_version);
1653          err = cgi_error_modified(csp, rsp, lookup(parameters, "f"));
1654          log_error(LOG_LEVEL_ERROR,
1655             "Blocking CGI edit request due to modification time mismatch.");
1656          if (acceptable_failures > 0)
1657          {
1658             log_error(LOG_LEVEL_INFO,
1659                "The CGI editor will be turned off after another %d mismatche(s).",
1660                acceptable_failures);
1661             acceptable_failures--;
1662          }
1663          else
1664          {
1665             log_error(LOG_LEVEL_INFO,
1666                "Timestamp mismatch limit reached, turning CGI editor off. "
1667                "Reload the configuration file to re-enable it.");
1668             csp->config->feature_flags &= ~RUNTIME_FEATURE_CGI_EDIT_ACTIONS;
1669          }
1670       }
1671       if (err == JB_ERR_OK)
1672       {
1673          /*
1674           * Signal to higher-level CGI code that there was a problem but we
1675           * handled it, they should just return JB_ERR_OK.
1676           */
1677          err = JB_ERR_FILE;
1678       }
1679       return err;
1680    }
1681
1682    err = edit_parse_actions_file(file);
1683    if (err)
1684    {
1685       if (err == JB_ERR_PARSE)
1686       {
1687          err = cgi_error_parse(csp, rsp, file);
1688          if (err == JB_ERR_OK)
1689          {
1690             /*
1691              * Signal to higher-level CGI code that there was a problem but we
1692              * handled it, they should just return JB_ERR_OK.
1693              */
1694             err = JB_ERR_FILE;
1695          }
1696       }
1697       edit_free_file(file);
1698       return err;
1699    }
1700
1701    *pfile = file;
1702    return JB_ERR_OK;
1703 }
1704
1705
1706 /*********************************************************************
1707  *
1708  * Function    :  get_file_name_param
1709  *
1710  * Description :  Get the name of the file to edit from the parameters
1711  *                passed to a CGI function using the old syntax.
1712  *                This function handles security checks and only
1713  *                accepts files that Privoxy already knows.
1714  *
1715  * Parameters  :
1716  *          1  :  csp = Current client state (buffers, headers, etc...)
1717  *          2  :  parameters = map of cgi parameters
1718  *          3  :  param_name = The name of the parameter to read
1719  *          4  :  pfilename = pointer to the filename in
1720  *                csp->config->actions_file[] if found. Set to NULL on error.
1721  *
1722  * Returns     :  JB_ERR_OK         on success
1723  *                JB_ERR_MEMORY     on out-of-memory
1724  *                JB_ERR_CGI_PARAMS if "filename" was not specified
1725  *                                  or is not valid.
1726  *
1727  *********************************************************************/
1728 static jb_err get_file_name_param(struct client_state *csp,
1729                                   const struct map *parameters,
1730                                   const char *param_name,
1731                                   const char **pfilename)
1732 {
1733    const char *param;
1734    const char suffix[] = ".action";
1735    const char *s;
1736    char *name;
1737    char *fullpath;
1738    char ch;
1739    size_t len;
1740    size_t name_size;
1741    int i;
1742
1743    assert(csp);
1744    assert(parameters);
1745    assert(pfilename);
1746
1747    *pfilename = NULL;
1748
1749    param = lookup(parameters, param_name);
1750    if (!*param)
1751    {
1752       return JB_ERR_CGI_PARAMS;
1753    }
1754
1755    len = strlen(param);
1756    if (len >= FILENAME_MAX)
1757    {
1758       /* Too long. */
1759       return JB_ERR_CGI_PARAMS;
1760    }
1761
1762    /*
1763     * Check every character to see if it's legal.
1764     * Totally unnecessary but we do it anyway.
1765     */
1766    s = param;
1767    while ((ch = *s++) != '\0')
1768    {
1769       if ( ((ch < 'A') || (ch > 'Z'))
1770         && ((ch < 'a') || (ch > 'z'))
1771         && ((ch < '0') || (ch > '9'))
1772         && (ch != '-')
1773         && (ch != '_'))
1774       {
1775          /* Probable hack attempt. */
1776          return JB_ERR_CGI_PARAMS;
1777       }
1778    }
1779
1780    /* Append extension */
1781    name_size = len + strlen(suffix) + 1;
1782    name = malloc_or_die(name_size);
1783    strlcpy(name, param, name_size);
1784    strlcat(name, suffix, name_size);
1785
1786    /* Prepend path */
1787    fullpath = make_path(csp->config->confdir, name);
1788    free(name);
1789
1790    if (fullpath == NULL)
1791    {
1792       return JB_ERR_MEMORY;
1793    }
1794
1795    /* Check if the file is known */
1796    for (i = 0; i < MAX_AF_FILES; i++)
1797    {
1798       if (NULL != csp->config->actions_file[i] &&
1799           !strcmp(fullpath, csp->config->actions_file[i]))
1800       {
1801          /* Success */
1802          *pfilename = csp->config->actions_file[i];
1803          freez(fullpath);
1804
1805          return JB_ERR_OK;
1806       }
1807    }
1808    freez(fullpath);
1809
1810    return JB_ERR_CGI_PARAMS;
1811 }
1812
1813
1814 /*********************************************************************
1815  *
1816  * Function    :  get_url_spec_param
1817  *
1818  * Description :  Get a URL pattern from the parameters
1819  *                passed to a CGI function.  Removes leading/trailing
1820  *                spaces and validates it.
1821  *
1822  * Parameters  :
1823  *          1  :  csp = Current client state (buffers, headers, etc...)
1824  *          2  :  parameters = map of cgi parameters
1825  *          3  :  name = Name of CGI parameter to read
1826  *          4  :  pvalue = destination for value.  Will be malloc()'d.
1827  *                         Set to NULL on error.
1828  *
1829  * Returns     :  JB_ERR_OK         on success
1830  *                JB_ERR_MEMORY     on out-of-memory
1831  *                JB_ERR_CGI_PARAMS if the parameter was not specified
1832  *                                  or is not valid.
1833  *
1834  *********************************************************************/
1835 static jb_err get_url_spec_param(struct client_state *csp,
1836                                  const struct map *parameters,
1837                                  const char *name,
1838                                  char **pvalue)
1839 {
1840    const char *orig_param;
1841    char *param;
1842    char *s;
1843    struct url_spec compiled[1];
1844    jb_err err;
1845
1846    assert(csp);
1847    assert(parameters);
1848    assert(name);
1849    assert(pvalue);
1850
1851    *pvalue = NULL;
1852
1853    orig_param = lookup(parameters, name);
1854    if (!*orig_param)
1855    {
1856       return JB_ERR_CGI_PARAMS;
1857    }
1858
1859    /* Copy and trim whitespace */
1860    param = strdup(orig_param);
1861    if (param == NULL)
1862    {
1863       return JB_ERR_MEMORY;
1864    }
1865    chomp(param);
1866
1867    /* Must be non-empty, and can't allow 1st character to be '{' */
1868    if (param[0] == '\0' || param[0] == '{')
1869    {
1870       free(param);
1871       return JB_ERR_CGI_PARAMS;
1872    }
1873
1874    /* Check for embedded newlines */
1875    for (s = param; *s != '\0'; s++)
1876    {
1877       if ((*s == '\r') || (*s == '\n'))
1878       {
1879          free(param);
1880          return JB_ERR_CGI_PARAMS;
1881       }
1882    }
1883
1884    /* Check that regex is valid */
1885    s = strdup(param);
1886    if (s == NULL)
1887    {
1888       free(param);
1889       return JB_ERR_MEMORY;
1890    }
1891    err = create_url_spec(compiled, s);
1892    free(s);
1893    if (err)
1894    {
1895       free(param);
1896       return (err == JB_ERR_MEMORY) ? JB_ERR_MEMORY : JB_ERR_CGI_PARAMS;
1897    }
1898    free_url_spec(compiled);
1899
1900    if (param[strlen(param) - 1] == '\\')
1901    {
1902       /*
1903        * Must protect trailing '\\' from becoming line continuation character.
1904        * Two methods: 1) If it's a domain only, add a trailing '/'.
1905        * 2) For path, add the do-nothing PCRE expression (?:) to the end
1906        */
1907       if (strchr(param, '/') == NULL)
1908       {
1909          err = string_append(&param, "/");
1910       }
1911       else
1912       {
1913          err = string_append(&param, "(?:)");
1914       }
1915       if (err)
1916       {
1917          return err;
1918       }
1919
1920       /* Check that the modified regex is valid */
1921       s = strdup(param);
1922       if (s == NULL)
1923       {
1924          free(param);
1925          return JB_ERR_MEMORY;
1926       }
1927       err = create_url_spec(compiled, s);
1928       free(s);
1929       if (err)
1930       {
1931          free(param);
1932          return (err == JB_ERR_MEMORY) ? JB_ERR_MEMORY : JB_ERR_CGI_PARAMS;
1933       }
1934       free_url_spec(compiled);
1935    }
1936
1937    *pvalue = param;
1938    return JB_ERR_OK;
1939 }
1940
1941 /*********************************************************************
1942  *
1943  * Function    :  map_radio
1944  *
1945  * Description :  Map a set of radio button values.  E.g. if you have
1946  *                3 radio buttons, declare them as:
1947  *                  <option type="radio" name="xyz" @xyz-a@>
1948  *                  <option type="radio" name="xyz" @xyz-b@>
1949  *                  <option type="radio" name="xyz" @xyz-c@>
1950  *                Then map one of the @xyz-?@ variables to "checked"
1951  *                and all the others to empty by calling:
1952  *                map_radio(exports, "xyz", "abc", sel)
1953  *                Where 'sel' is 'a', 'b', or 'c'.
1954  *
1955  * Parameters  :
1956  *          1  :  exports = Exports map to modify.
1957  *          2  :  optionname = name for map
1958  *          3  :  values = null-terminated list of values;
1959  *          4  :  value = Selected value.
1960  *
1961  * CGI Parameters : None
1962  *
1963  * Returns     :  JB_ERR_OK     on success
1964  *                JB_ERR_MEMORY on out-of-memory
1965  *
1966  *********************************************************************/
1967 static jb_err map_radio(struct map * exports,
1968                         const char * optionname,
1969                         const char * values,
1970                         int value)
1971 {
1972    char * buf;
1973    char * p;
1974    char c;
1975    const size_t len = strlen(optionname);
1976    const size_t buf_size = len + 3;
1977
1978    assert(exports);
1979    assert(optionname);
1980    assert(values);
1981
1982    buf = malloc_or_die(buf_size);
1983
1984    strlcpy(buf, optionname, buf_size);
1985
1986    /* XXX: this looks ... interesting */
1987    p = buf + len;
1988    *p++ = '-';
1989    p[1] = '\0';
1990
1991    while ((c = *values++) != '\0')
1992    {
1993       if (c != value)
1994       {
1995          *p = c;
1996          if (map(exports, buf, 1, "", 1))
1997          {
1998             return JB_ERR_MEMORY;
1999          }
2000       }
2001    }
2002
2003    *p = (char)value;
2004    return map(exports, buf, 0, "checked", 1);
2005 }
2006
2007
2008 /*********************************************************************
2009  *
2010  * Function    :  cgi_error_modified
2011  *
2012  * Description :  CGI function that is called when a file is modified
2013  *                outside the CGI editor.
2014  *
2015  * Parameters  :
2016  *          1  :  csp = Current client state (buffers, headers, etc...)
2017  *          2  :  rsp = http_response data structure for output
2018  *          3  :  filename = The file that was modified.
2019  *
2020  * CGI Parameters : none
2021  *
2022  * Returns     :  JB_ERR_OK on success
2023  *                JB_ERR_MEMORY on out-of-memory error.
2024  *
2025  *********************************************************************/
2026 jb_err cgi_error_modified(struct client_state *csp,
2027                           struct http_response *rsp,
2028                           const char *filename)
2029 {
2030    struct map *exports;
2031    jb_err err;
2032
2033    assert(csp);
2034    assert(rsp);
2035    assert(filename);
2036
2037    if (NULL == (exports = default_exports(csp, NULL)))
2038    {
2039       return JB_ERR_MEMORY;
2040    }
2041
2042    err = map(exports, "f", 1, html_encode(filename), 0);
2043    if (err)
2044    {
2045       free_map(exports);
2046       return err;
2047    }
2048
2049    return template_fill_for_cgi(csp, "cgi-error-modified", exports, rsp);
2050 }
2051
2052
2053 /*********************************************************************
2054  *
2055  * Function    :  cgi_error_parse
2056  *
2057  * Description :  CGI function that is called when a file cannot
2058  *                be parsed by the CGI editor.
2059  *
2060  * Parameters  :
2061  *          1  :  csp = Current client state (buffers, headers, etc...)
2062  *          2  :  rsp = http_response data structure for output
2063  *          3  :  file = The file that was modified.
2064  *
2065  * CGI Parameters : none
2066  *
2067  * Returns     :  JB_ERR_OK on success
2068  *                JB_ERR_MEMORY on out-of-memory error.
2069  *
2070  *********************************************************************/
2071 jb_err cgi_error_parse(struct client_state *csp,
2072                        struct http_response *rsp,
2073                        struct editable_file *file)
2074 {
2075    struct map *exports;
2076    jb_err err;
2077    struct file_line *cur_line;
2078
2079    assert(csp);
2080    assert(rsp);
2081    assert(file);
2082
2083    if (NULL == (exports = default_exports(csp, NULL)))
2084    {
2085       return JB_ERR_MEMORY;
2086    }
2087
2088    err = map(exports, "f", 1, stringify(file->identifier), 0);
2089    if (!err) err = map(exports, "parse-error", 1, html_encode(file->parse_error_text), 0);
2090
2091    cur_line = file->parse_error;
2092    assert(cur_line);
2093
2094    if (!err) err = map(exports, "line-raw", 1, html_encode(cur_line->raw), 0);
2095    if (!err) err = map(exports, "line-data", 1, html_encode(cur_line->unprocessed), 0);
2096
2097    if (err)
2098    {
2099       free_map(exports);
2100       return err;
2101    }
2102
2103    return template_fill_for_cgi(csp, "cgi-error-parse", exports, rsp);
2104 }
2105
2106
2107 /*********************************************************************
2108  *
2109  * Function    :  cgi_error_file
2110  *
2111  * Description :  CGI function that is called when a file cannot be
2112  *                opened by the CGI editor.
2113  *
2114  * Parameters  :
2115  *          1  :  csp = Current client state (buffers, headers, etc...)
2116  *          2  :  rsp = http_response data structure for output
2117  *          3  :  filename = The file that was modified.
2118  *
2119  * CGI Parameters : none
2120  *
2121  * Returns     :  JB_ERR_OK on success
2122  *                JB_ERR_MEMORY on out-of-memory error.
2123  *
2124  *********************************************************************/
2125 jb_err cgi_error_file(struct client_state *csp,
2126                       struct http_response *rsp,
2127                       const char *filename)
2128 {
2129    struct map *exports;
2130    jb_err err;
2131
2132    assert(csp);
2133    assert(rsp);
2134    assert(filename);
2135
2136    if (NULL == (exports = default_exports(csp, NULL)))
2137    {
2138       return JB_ERR_MEMORY;
2139    }
2140
2141    err = map(exports, "f", 1, html_encode(filename), 0);
2142    if (err)
2143    {
2144       free_map(exports);
2145       return err;
2146    }
2147
2148    return template_fill_for_cgi(csp, "cgi-error-file", exports, rsp);
2149 }
2150
2151
2152 /*********************************************************************
2153  *
2154  * Function    :  cgi_error_file_read_only
2155  *
2156  * Description :  CGI function that is called when a file cannot be
2157  *                opened for writing by the CGI editor.
2158  *
2159  * Parameters  :
2160  *          1  :  csp = Current client state (buffers, headers, etc...)
2161  *          2  :  rsp = http_response data structure for output
2162  *          3  :  filename = The file that we can't write to
2163  *
2164  * CGI Parameters : none
2165  *
2166  * Returns     :  JB_ERR_OK on success
2167  *                JB_ERR_MEMORY on out-of-memory error.
2168  *
2169  *********************************************************************/
2170 jb_err cgi_error_file_read_only(struct client_state *csp,
2171                                 struct http_response *rsp,
2172                                 const char *filename)
2173 {
2174    struct map *exports;
2175    jb_err err;
2176
2177    assert(csp);
2178    assert(rsp);
2179    assert(filename);
2180
2181    if (NULL == (exports = default_exports(csp, NULL)))
2182    {
2183       return JB_ERR_MEMORY;
2184    }
2185
2186    err = map(exports, "f", 1, html_encode(filename), 0);
2187    if (err)
2188    {
2189       free_map(exports);
2190       return err;
2191    }
2192
2193    return template_fill_for_cgi(csp, "cgi-error-file-read-only", exports, rsp);
2194 }
2195
2196
2197 /*********************************************************************
2198  *
2199  * Function    :  cgi_edit_actions
2200  *
2201  * Description :  CGI function that allows the user to choose which
2202  *                actions file to edit.
2203  *
2204  * Parameters  :
2205  *          1  :  csp = Current client state (buffers, headers, etc...)
2206  *          2  :  rsp = http_response data structure for output
2207  *          3  :  parameters = map of cgi parameters
2208  *
2209  * CGI Parameters : None
2210  *
2211  * Returns     :  JB_ERR_OK on success
2212  *                JB_ERR_MEMORY on out-of-memory error
2213  *
2214  *********************************************************************/
2215 jb_err cgi_edit_actions(struct client_state *csp,
2216                         struct http_response *rsp,
2217                         const struct map *parameters)
2218 {
2219    (void)parameters;
2220
2221    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
2222    {
2223       return cgi_error_disabled(csp, rsp);
2224    }
2225
2226    /* FIXME: Incomplete */
2227
2228    return cgi_redirect(rsp, CGI_PREFIX "edit-actions-list?f=default");
2229
2230 }
2231
2232
2233 /*********************************************************************
2234  *
2235  * Function    :  cgi_edit_actions_list
2236  *
2237  * Description :  CGI function that edits the actions list.
2238  *                FIXME: This function shouldn't FATAL ever.
2239  *                FIXME: This function doesn't check the retval of map()
2240  * Parameters  :
2241  *          1  :  csp = Current client state (buffers, headers, etc...)
2242  *          2  :  rsp = http_response data structure for output
2243  *          3  :  parameters = map of cgi parameters
2244  *
2245  * CGI Parameters : filename
2246  *
2247  * Returns     :  JB_ERR_OK     on success
2248  *                JB_ERR_MEMORY on out-of-memory
2249  *                JB_ERR_FILE   if the file cannot be opened or
2250  *                              contains no data
2251  *                JB_ERR_CGI_PARAMS if "filename" was not specified
2252  *                                  or is not valid.
2253  *
2254  *********************************************************************/
2255 jb_err cgi_edit_actions_list(struct client_state *csp,
2256                              struct http_response *rsp,
2257                              const struct map *parameters)
2258 {
2259    char * section_template;
2260    char * url_template;
2261    char * sections;
2262    char * urls;
2263    char buf[150];
2264    char * s;
2265    struct map * exports;
2266    struct map * section_exports;
2267    struct map * url_exports;
2268    struct editable_file * file;
2269    struct file_line * cur_line;
2270    unsigned line_number = 0;
2271    unsigned prev_section_line_number = ((unsigned) (-1));
2272    int i, url_1_2;
2273    struct file_list * fl;
2274    struct url_actions * b;
2275    char * buttons = NULL;
2276    jb_err err;
2277
2278    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
2279    {
2280       return cgi_error_disabled(csp, rsp);
2281    }
2282
2283    if (NULL == (exports = default_exports(csp, NULL)))
2284    {
2285       return JB_ERR_MEMORY;
2286    }
2287
2288    /* Load actions file */
2289    err = edit_read_actions_file(csp, rsp, parameters, 0, &file);
2290    if (err)
2291    {
2292       /* No filename specified, can't read file, or out of memory. */
2293       free_map(exports);
2294       return (err == JB_ERR_FILE ? JB_ERR_OK : err);
2295    }
2296
2297    /* Find start of actions in file */
2298    cur_line = file->lines;
2299    line_number = 1;
2300    while ((cur_line != NULL) && (cur_line->type != FILE_LINE_ACTION))
2301    {
2302       cur_line = cur_line->next;
2303       line_number++;
2304    }
2305
2306    /*
2307     * Conventional actions files should have a match all block
2308     * at the start:
2309     * cur_line             = {...global actions...}
2310     * cur_line->next       = /
2311     * cur_line->next->next = {...actions...} or EOF
2312     */
2313    if ( (cur_line != NULL)
2314      && (cur_line->type == FILE_LINE_ACTION)
2315      && (cur_line->next != NULL)
2316      && (cur_line->next->type == FILE_LINE_URL)
2317      && (0 == strcmp(cur_line->next->unprocessed, "/"))
2318      && ( (cur_line->next->next == NULL)
2319        || (cur_line->next->next->type != FILE_LINE_URL)
2320       ) )
2321    {
2322       /*
2323        * Generate string with buttons to set actions for "/" to
2324        * any predefined set of actions (named standard.*, probably
2325        * residing in standard.action).
2326        */
2327
2328       err = template_load(csp, &section_template, "edit-actions-list-button", 0);
2329       if (err)
2330       {
2331          edit_free_file(file);
2332          free_map(exports);
2333          if (err == JB_ERR_FILE)
2334          {
2335             return cgi_error_no_template(csp, rsp, "edit-actions-list-button");
2336          }
2337          return err;
2338       }
2339
2340       err = template_fill(&section_template, exports);
2341       if (err)
2342       {
2343          edit_free_file(file);
2344          free_map(exports);
2345          return err;
2346       }
2347
2348       buttons = strdup("");
2349       for (i = 0; i < MAX_AF_FILES; i++)
2350       {
2351          if (((fl = csp->actions_list[i]) != NULL) && ((b = fl->f) != NULL))
2352          {
2353             for (b = b->next; NULL != b; b = b->next)
2354             {
2355                if (!strncmp(b->url->spec, "standard.", 9) && *(b->url->spec + 9) != '\0')
2356                {
2357                   if (err || (NULL == (section_exports = new_map())))
2358                   {
2359                      freez(buttons);
2360                      free(section_template);
2361                      edit_free_file(file);
2362                      free_map(exports);
2363                      return JB_ERR_MEMORY;
2364                   }
2365
2366                   err = map(section_exports, "button-name", 1, b->url->spec + 9, 1);
2367
2368                   if (err || (NULL == (s = strdup(section_template))))
2369                   {
2370                      free_map(section_exports);
2371                      freez(buttons);
2372                      free(section_template);
2373                      edit_free_file(file);
2374                      free_map(exports);
2375                      return JB_ERR_MEMORY;
2376                   }
2377
2378                   if (!err) err = template_fill(&s, section_exports);
2379                   free_map(section_exports);
2380                   if (!err) err = string_join(&buttons, s);
2381                }
2382             }
2383          }
2384       }
2385       freez(section_template);
2386       if (!err) err = map(exports, "all-urls-buttons", 1, buttons, 0);
2387
2388       /*
2389        * Conventional actions file, supply extra editing help.
2390        * (e.g. don't allow them to make it an unconventional one).
2391        */
2392       if (!err) err = map_conditional(exports, "all-urls-present", 1);
2393
2394       snprintf(buf, sizeof(buf), "%d", line_number);
2395       if (!err) err = map(exports, "all-urls-s", 1, buf, 1);
2396       snprintf(buf, sizeof(buf), "%d", line_number + 2);
2397       if (!err) err = map(exports, "all-urls-s-next", 1, buf, 1);
2398       if (!err) err = map(exports, "all-urls-actions", 1,
2399                           actions_to_html(csp, cur_line->data.action), 0);
2400
2401        /* Skip the 2 lines */
2402       cur_line = cur_line->next->next;
2403       line_number += 2;
2404
2405       /*
2406        * Note that prev_section_line_number is NOT set here.
2407        * This is deliberate and not a bug.  It stops a "Move up"
2408        * option appearing on the next section.  Clicking "Move
2409        * up" would make the actions file unconventional, which
2410        * we don't want, so we hide this option.
2411        */
2412    }
2413    else
2414    {
2415       /*
2416        * Non-standard actions file - does not begin with
2417        * the "All URLs" section.
2418        */
2419       if (!err) err = map_conditional(exports, "all-urls-present", 0);
2420    }
2421
2422    /* Set up global exports */
2423
2424    if (!err) err = map(exports, "actions-file", 1, html_encode(file->filename), 0);
2425    if (!err) err = map(exports, "f", 1, stringify(file->identifier), 0);
2426    if (!err) err = map(exports, "v", 1, file->version_str, 1);
2427
2428    /* Discourage private additions to default.action */
2429
2430    if (!err) err = map_conditional(exports, "default-action",
2431                                    (strstr("default.action", file->filename) != NULL));
2432    if (err)
2433    {
2434       edit_free_file(file);
2435       free_map(exports);
2436       return err;
2437    }
2438
2439    /* Should do all global exports above this point */
2440
2441    /* Load templates */
2442
2443    err = template_load(csp, &section_template, "edit-actions-list-section", 0);
2444    if (err)
2445    {
2446       edit_free_file(file);
2447       free_map(exports);
2448       if (err == JB_ERR_FILE)
2449       {
2450          return cgi_error_no_template(csp, rsp, "edit-actions-list-section");
2451       }
2452       return err;
2453    }
2454
2455    err = template_load(csp, &url_template, "edit-actions-list-url", 0);
2456    if (err)
2457    {
2458       free(section_template);
2459       edit_free_file(file);
2460       free_map(exports);
2461       if (err == JB_ERR_FILE)
2462       {
2463          return cgi_error_no_template(csp, rsp, "edit-actions-list-url");
2464       }
2465       return err;
2466    }
2467
2468    err = template_fill(&section_template, exports);
2469    if (err)
2470    {
2471       free(url_template);
2472       edit_free_file(file);
2473       free_map(exports);
2474       return err;
2475    }
2476
2477    err = template_fill(&url_template, exports);
2478    if (err)
2479    {
2480       free(section_template);
2481       edit_free_file(file);
2482       free_map(exports);
2483       return err;
2484    }
2485
2486    if (NULL == (sections = strdup("")))
2487    {
2488       free(section_template);
2489       free(url_template);
2490       edit_free_file(file);
2491       free_map(exports);
2492       return JB_ERR_MEMORY;
2493    }
2494
2495    while ((cur_line != NULL) && (cur_line->type == FILE_LINE_ACTION))
2496    {
2497       if (NULL == (section_exports = new_map()))
2498       {
2499          free(sections);
2500          free(section_template);
2501          free(url_template);
2502          edit_free_file(file);
2503          free_map(exports);
2504          return JB_ERR_MEMORY;
2505       }
2506
2507       snprintf(buf, sizeof(buf), "%d", line_number);
2508       err = map(section_exports, "s", 1, buf, 1);
2509       if (!err) err = map(section_exports, "actions", 1,
2510                           actions_to_html(csp, cur_line->data.action), 0);
2511
2512       if ((!err)
2513         && (cur_line->next != NULL)
2514         && (cur_line->next->type == FILE_LINE_URL))
2515       {
2516          /* This section contains at least one URL, don't allow delete */
2517          err = map_block_killer(section_exports, "empty-section");
2518       }
2519       else
2520       {
2521          if (!err) err = map_block_keep(section_exports, "empty-section");
2522       }
2523
2524       if (prev_section_line_number != ((unsigned)(-1)))
2525       {
2526          /* Not last section */
2527          snprintf(buf, sizeof(buf), "%d", prev_section_line_number);
2528          if (!err) err = map(section_exports, "s-prev", 1, buf, 1);
2529          if (!err) err = map_block_keep(section_exports, "s-prev-exists");
2530       }
2531       else
2532       {
2533          /* Last section */
2534          if (!err) err = map_block_killer(section_exports, "s-prev-exists");
2535       }
2536       prev_section_line_number = line_number;
2537
2538       if (err)
2539       {
2540          free(sections);
2541          free(section_template);
2542          free(url_template);
2543          edit_free_file(file);
2544          free_map(exports);
2545          free_map(section_exports);
2546          return err;
2547       }
2548
2549       /* Should do all section-specific exports above this point */
2550
2551       if (NULL == (urls = strdup("")))
2552       {
2553          free(sections);
2554          free(section_template);
2555          free(url_template);
2556          edit_free_file(file);
2557          free_map(exports);
2558          free_map(section_exports);
2559          return JB_ERR_MEMORY;
2560       }
2561
2562       url_1_2 = 2;
2563
2564       cur_line = cur_line->next;
2565       line_number++;
2566
2567       while ((cur_line != NULL) && (cur_line->type == FILE_LINE_URL))
2568       {
2569          if (NULL == (url_exports = new_map()))
2570          {
2571             free(urls);
2572             free(sections);
2573             free(section_template);
2574             free(url_template);
2575             edit_free_file(file);
2576             free_map(exports);
2577             free_map(section_exports);
2578             return JB_ERR_MEMORY;
2579          }
2580
2581          snprintf(buf, sizeof(buf), "%d", line_number);
2582          err = map(url_exports, "p", 1, buf, 1);
2583
2584          snprintf(buf, sizeof(buf), "%d", url_1_2);
2585          if (!err) err = map(url_exports, "url-1-2", 1, buf, 1);
2586
2587          if (!err) err = map(url_exports, "url-html", 1,
2588                              html_encode(cur_line->unprocessed), 0);
2589          if (!err) err = map(url_exports, "url", 1,
2590                              url_encode(cur_line->unprocessed), 0);
2591
2592          if (err)
2593          {
2594             free(urls);
2595             free(sections);
2596             free(section_template);
2597             free(url_template);
2598             edit_free_file(file);
2599             free_map(exports);
2600             free_map(section_exports);
2601             free_map(url_exports);
2602             return err;
2603          }
2604
2605          if (NULL == (s = strdup(url_template)))
2606          {
2607             free(urls);
2608             free(sections);
2609             free(section_template);
2610             free(url_template);
2611             edit_free_file(file);
2612             free_map(exports);
2613             free_map(section_exports);
2614             free_map(url_exports);
2615             return JB_ERR_MEMORY;
2616          }
2617
2618          err = template_fill(&s, section_exports);
2619          if (!err) err = template_fill(&s, url_exports);
2620          if (!err) err = string_append(&urls, s);
2621
2622          free_map(url_exports);
2623          freez(s);
2624
2625          if (err)
2626          {
2627             freez(urls);
2628             free(sections);
2629             free(section_template);
2630             free(url_template);
2631             edit_free_file(file);
2632             free_map(exports);
2633             free_map(section_exports);
2634             return err;
2635          }
2636
2637          url_1_2 = 3 - url_1_2;
2638
2639          cur_line = cur_line->next;
2640          line_number++;
2641       }
2642
2643       err = map(section_exports, "urls", 1, urls, 0);
2644
2645       /* Could also do section-specific exports here, but it wouldn't be as fast */
2646
2647       snprintf(buf, sizeof(buf), "%d", line_number);
2648       if (!err) err = map(section_exports, "s-next", 1, buf, 1);
2649
2650       if ((cur_line != NULL)
2651        && (cur_line->type == FILE_LINE_ACTION))
2652       {
2653          /* Not last section */
2654          if (!err) err = map_block_keep(section_exports, "s-next-exists");
2655       }
2656       else
2657       {
2658          /* Last section */
2659          if (!err) err = map_block_killer(section_exports, "s-next-exists");
2660       }
2661
2662       if (err)
2663       {
2664          free(sections);
2665          free(section_template);
2666          free(url_template);
2667          edit_free_file(file);
2668          free_map(exports);
2669          free_map(section_exports);
2670          return err;
2671       }
2672
2673       if (NULL == (s = strdup(section_template)))
2674       {
2675          free(sections);
2676          free(section_template);
2677          free(url_template);
2678          edit_free_file(file);
2679          free_map(exports);
2680          free_map(section_exports);
2681          return JB_ERR_MEMORY;
2682       }
2683
2684       err = template_fill(&s, section_exports);
2685       if (!err) err = string_append(&sections, s);
2686
2687       freez(s);
2688       free_map(section_exports);
2689
2690       if (err)
2691       {
2692          freez(sections);
2693          free(section_template);
2694          free(url_template);
2695          edit_free_file(file);
2696          free_map(exports);
2697          return err;
2698       }
2699    }
2700
2701    edit_free_file(file);
2702    free(section_template);
2703    free(url_template);
2704
2705    err = map(exports, "sections", 1, sections, 0);
2706    if (err)
2707    {
2708       free_map(exports);
2709       return err;
2710    }
2711
2712    /* Could also do global exports here, but it wouldn't be as fast */
2713
2714    return template_fill_for_cgi(csp, "edit-actions-list", exports, rsp);
2715 }
2716
2717
2718 /*********************************************************************
2719  *
2720  * Function    :  cgi_edit_actions_for_url
2721  *
2722  * Description :  CGI function that edits the Actions list.
2723  *
2724  * Parameters  :
2725  *          1  :  csp = Current client state (buffers, headers, etc...)
2726  *          2  :  rsp = http_response data structure for output
2727  *          3  :  parameters = map of cgi parameters
2728  *
2729  * CGI Parameters : None
2730  *
2731  * Returns     :  JB_ERR_OK     on success
2732  *                JB_ERR_MEMORY on out-of-memory
2733  *                JB_ERR_CGI_PARAMS if the CGI parameters are not
2734  *                                  specified or not valid.
2735  *
2736  *********************************************************************/
2737 jb_err cgi_edit_actions_for_url(struct client_state *csp,
2738                                 struct http_response *rsp,
2739                                 const struct map *parameters)
2740 {
2741    struct map * exports;
2742    unsigned sectionid;
2743    struct editable_file * file;
2744    struct file_line * cur_line;
2745    unsigned line_number;
2746    jb_err err;
2747    struct re_filterfile_spec *filter_group;
2748    int i, have_filters = 0;
2749
2750    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
2751    {
2752       return cgi_error_disabled(csp, rsp);
2753    }
2754
2755    err = get_number_param(csp, parameters, "s", &sectionid);
2756    if (err)
2757    {
2758       return err;
2759    }
2760
2761    err = edit_read_actions_file(csp, rsp, parameters, 1, &file);
2762    if (err)
2763    {
2764       /* No filename specified, can't read file, modified, or out of memory. */
2765       return (err == JB_ERR_FILE ? JB_ERR_OK : err);
2766    }
2767
2768    cur_line = file->lines;
2769
2770    for (line_number = 1; (cur_line != NULL) && (line_number < sectionid); line_number++)
2771    {
2772       cur_line = cur_line->next;
2773    }
2774
2775    if ( (cur_line == NULL)
2776      || (line_number != sectionid)
2777      || (sectionid < 1)
2778      || (cur_line->type != FILE_LINE_ACTION))
2779    {
2780       /* Invalid "sectionid" parameter */
2781       edit_free_file(file);
2782       return JB_ERR_CGI_PARAMS;
2783    }
2784
2785    if (NULL == (exports = default_exports(csp, NULL)))
2786    {
2787       edit_free_file(file);
2788       return JB_ERR_MEMORY;
2789    }
2790
2791    err = map(exports, "f", 1, stringify(file->identifier), 0);
2792    if (!err) err = map(exports, "v", 1, file->version_str, 1);
2793    if (!err) err = map(exports, "s", 1, url_encode(lookup(parameters, "s")), 0);
2794
2795    if (!err) err = actions_to_radio(exports, cur_line->data.action);
2796
2797    /*
2798     * XXX: Some browsers (at least IE6 and IE7) have an artificial URL
2799     * length limitation and ignore clicks on the Submit buttons if
2800     * the resulting GET URL would be longer than their limit.
2801     *
2802     * In Privoxy 3.0.5 beta the standard edit-actions-for-url template
2803     * reached this limit and action editing stopped working in these
2804     * browsers (BR #1570678).
2805     *
2806     * The config option split-large-forms works around this browser
2807     * bug (HTTP has no URL length limitation) by deviding the action
2808     * list form into multiple smaller ones. It means the URLs are shorter
2809     * and work in broken browsers as well, but the user can no longer change
2810     * all actions with one submit.
2811     *
2812     * A better solution would be to switch to POST requests,
2813     * but this will do for now.
2814     */
2815    if (!err && (csp->config->feature_flags & RUNTIME_FEATURE_SPLIT_LARGE_FORMS))
2816    {
2817       /* Generate multiple smaller form by killing the big one. */
2818       err = map_block_killer(exports, "one-form-only");
2819    }
2820    else
2821    {
2822       /* Default: Generate one large form by killing the smaller ones. */
2823       err = map_block_killer(exports, "multiple-forms");
2824    }
2825
2826    for (i = 0; i < MAX_AF_FILES; i++)
2827    {
2828       if ((csp->rlist[i] != NULL) && (csp->rlist[i]->f != NULL))
2829       {
2830          if (!err) err = map_conditional(exports, "any-filters-defined", 1);
2831          have_filters = 1;
2832          break;
2833       }
2834    }
2835
2836    if (err)
2837    {
2838       edit_free_file(file);
2839       free_map(exports);
2840       return err;
2841    }
2842
2843    if (0 == have_filters)
2844    {
2845       err = map(exports, "filter-params", 1, "", 1);
2846    }
2847    else
2848    {
2849       /*
2850        * List available filters and their settings.
2851        */
2852       char *filter_template;
2853       int filter_identifier = 0;
2854       char *prepared_templates[MAX_FILTER_TYPES];
2855
2856       for (i = 0; i < MAX_FILTER_TYPES; i++)
2857       {
2858          prepared_templates[i] = strdup("");
2859       }
2860
2861       err = template_load(csp, &filter_template, "edit-actions-for-url-filter", 0);
2862       if (err)
2863       {
2864          edit_free_file(file);
2865          free_map(exports);
2866          if (err == JB_ERR_FILE)
2867          {
2868             return cgi_error_no_template(csp, rsp, "edit-actions-for-url-filter");
2869          }
2870          return err;
2871       }
2872
2873       err = template_fill(&filter_template, exports);
2874
2875       for (i = 0; i < MAX_AF_FILES; i++)
2876       {
2877          if ((csp->rlist[i] != NULL) && (csp->rlist[i]->f != NULL))
2878          {
2879             filter_group = csp->rlist[i]->f;
2880             for (;(!err) && (filter_group != NULL); filter_group = filter_group->next)
2881             {
2882                char current_mode = 'x';
2883                char number[20];
2884                struct list_entry *filter_name;
2885                struct map *line_exports;
2886                const int type = filter_group->type;
2887                const int multi_action_index = filter_type_info[type].multi_action_index;
2888
2889                assert(type < MAX_FILTER_TYPES);
2890
2891                filter_name = cur_line->data.action->multi_add[multi_action_index]->first;
2892                while ((filter_name != NULL)
2893                    && (0 != strcmp(filter_group->name, filter_name->str)))
2894                {
2895                     filter_name = filter_name->next;
2896                }
2897
2898                if (filter_name != NULL)
2899                {
2900                   current_mode = 'y';
2901                }
2902                else
2903                {
2904                   filter_name = cur_line->data.action->multi_remove[multi_action_index]->first;
2905                   while ((filter_name != NULL)
2906                       && (0 != strcmp(filter_group->name, filter_name->str)))
2907                   {
2908                        filter_name = filter_name->next;
2909                   }
2910                   if (filter_name != NULL)
2911                   {
2912                      current_mode = 'n';
2913                   }
2914                }
2915
2916                /* Generate a unique serial number */
2917                snprintf(number, sizeof(number), "%x", filter_identifier++);
2918                number[sizeof(number) - 1] = '\0';
2919
2920                line_exports = new_map();
2921                if (line_exports == NULL)
2922                {
2923                   err = JB_ERR_MEMORY;
2924                }
2925                else
2926                {
2927                   char *filter_line;
2928
2929                   if (!err) err = map(line_exports, "index", 1, number, 1);
2930                   if (!err) err = map(line_exports, "name",  1, filter_group->name, 1);
2931                   if (!err) err = map(line_exports, "description",  1, filter_group->description, 1);
2932                   if (!err) err = map_radio(line_exports, "this-filter", "ynx", current_mode);
2933                   if (!err) err = map(line_exports, "filter-type", 1, filter_type_info[type].type, 1);
2934                   if (!err) err = map(line_exports, "abbr-filter-type", 1, filter_type_info[type].abbr_type, 1);
2935                   if (!err) err = map(line_exports, "anchor", 1, filter_type_info[type].anchor, 1);
2936
2937                   if (!err)
2938                   {
2939                      filter_line = strdup(filter_template);
2940                      if (filter_line == NULL) err = JB_ERR_MEMORY;
2941                   }
2942                   if (!err) err = template_fill(&filter_line, line_exports);
2943                   string_join(&prepared_templates[type], filter_line);
2944
2945                   free_map(line_exports);
2946                }
2947             }
2948          }
2949       }
2950       freez(filter_template);
2951
2952       /* Replace all filter macros with the aggregated templates */
2953       for (i = 0; i < MAX_FILTER_TYPES; i++)
2954       {
2955          if (err) break;
2956          err = map(exports, filter_type_info[i].macro_name, 1, prepared_templates[i], 0);
2957       }
2958
2959       if (err)
2960       {
2961          /* Free aggregated templates */
2962          for (i = 0; i < MAX_FILTER_TYPES; i++)
2963          {
2964             freez(prepared_templates[i]);
2965          }
2966       }
2967    }
2968
2969    /* Check or uncheck the "disable all of this type" radio buttons. */
2970    for (i = 0; i < MAX_FILTER_TYPES; i++)
2971    {
2972       const int a = filter_type_info[i].multi_action_index;
2973       const int disable_all = cur_line->data.action->multi_remove_all[a];
2974       if (err) break;
2975       err = map_radio(exports, filter_type_info[i].disable_all_option, "nx", (disable_all ? 'n' : 'x'));
2976    }
2977
2978    edit_free_file(file);
2979
2980    if (err)
2981    {
2982       free_map(exports);
2983       return err;
2984    }
2985
2986    return template_fill_for_cgi(csp, "edit-actions-for-url", exports, rsp);
2987 }
2988
2989
2990 /*********************************************************************
2991  *
2992  * Function    :  cgi_edit_actions_submit
2993  *
2994  * Description :  CGI function that actually edits the Actions list.
2995  *
2996  * Parameters  :
2997  *          1  :  csp = Current client state (buffers, headers, etc...)
2998  *          2  :  rsp = http_response data structure for output
2999  *          3  :  parameters = map of cgi parameters
3000  *
3001  * CGI Parameters : None
3002  *
3003  * Returns     :  JB_ERR_OK     on success
3004  *                JB_ERR_MEMORY on out-of-memory
3005  *                JB_ERR_CGI_PARAMS if the CGI parameters are not
3006  *                                  specified or not valid.
3007  *
3008  *********************************************************************/
3009 jb_err cgi_edit_actions_submit(struct client_state *csp,
3010                                struct http_response *rsp,
3011                                const struct map *parameters)
3012 {
3013    unsigned sectionid;
3014    char * actiontext;
3015    char * newtext;
3016    size_t newtext_size;
3017    size_t len;
3018    struct editable_file * file;
3019    struct file_line * cur_line;
3020    unsigned line_number;
3021    char target[1024];
3022    jb_err err;
3023    int filter_identifier;
3024    int i;
3025    const char * action_set_name;
3026    struct file_list * fl;
3027    struct url_actions * b;
3028
3029    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
3030    {
3031       return cgi_error_disabled(csp, rsp);
3032    }
3033
3034    err = get_number_param(csp, parameters, "s", &sectionid);
3035    if (err)
3036    {
3037       return err;
3038    }
3039
3040    err = edit_read_actions_file(csp, rsp, parameters, 1, &file);
3041    if (err)
3042    {
3043       /* No filename specified, can't read file, modified, or out of memory. */
3044       return (err == JB_ERR_FILE ? JB_ERR_OK : err);
3045    }
3046
3047    cur_line = file->lines;
3048
3049    for (line_number = 1; (cur_line != NULL) && (line_number < sectionid); line_number++)
3050    {
3051       cur_line = cur_line->next;
3052    }
3053
3054    if ( (cur_line == NULL)
3055      || (line_number != sectionid)
3056      || (sectionid < 1)
3057      || (cur_line->type != FILE_LINE_ACTION))
3058    {
3059       /* Invalid "sectionid" parameter */
3060       edit_free_file(file);
3061       return JB_ERR_CGI_PARAMS;
3062    }
3063
3064    get_string_param(parameters, "p", &action_set_name);
3065    if (action_set_name != NULL)
3066    {
3067       for (filter_identifier = 0; filter_identifier < MAX_AF_FILES; filter_identifier++)
3068       {
3069          if (((fl = csp->actions_list[filter_identifier]) != NULL) && ((b = fl->f) != NULL))
3070          {
3071             for (b = b->next; NULL != b; b = b->next)
3072             {
3073                if (!strncmp(b->url->spec, "standard.", 9) && !strcmp(b->url->spec + 9, action_set_name))
3074                {
3075                   copy_action(cur_line->data.action, b->action);
3076                   goto found;
3077                }
3078             }
3079          }
3080       }
3081       edit_free_file(file);
3082       return JB_ERR_CGI_PARAMS;
3083
3084       found: ;
3085    }
3086    else
3087    {
3088       err = actions_from_radio(parameters, cur_line->data.action);
3089    }
3090
3091    if (err)
3092    {
3093       /* Out of memory */
3094       edit_free_file(file);
3095       return err;
3096    }
3097
3098    /* Check the "disable all of this type" parameters. */
3099    for (i = 0; i < MAX_FILTER_TYPES; i++)
3100    {
3101       const int multi_action_index = filter_type_info[i].multi_action_index;
3102       const char ch = get_char_param(parameters, filter_type_info[i].disable_all_param);
3103
3104       if (ch == 'N')
3105       {
3106          list_remove_all(cur_line->data.action->multi_add[multi_action_index]);
3107          list_remove_all(cur_line->data.action->multi_remove[multi_action_index]);
3108          cur_line->data.action->multi_remove_all[multi_action_index] = 1;
3109       }
3110       else if (ch == 'X')
3111       {
3112          cur_line->data.action->multi_remove_all[multi_action_index] = 0;
3113       }
3114    }
3115
3116    for (filter_identifier = 0; !err; filter_identifier++)
3117    {
3118       char key_value[30];
3119       char key_name[30];
3120       char key_type[30];
3121       const char *name;
3122       char value; /*
3123                    * Filter state. Valid states are: 'Y' (active),
3124                    * 'N' (inactive) and 'X' (no change).
3125                    * XXX: bad name.
3126                    */
3127       char type;  /*
3128                    * Abbreviated filter type. Valid types are: 'F' (content filter),
3129                    * 'S' (server-header filter) and 'C' (client-header filter).
3130                    */
3131       int multi_action_index = 0;
3132
3133       /* Generate the keys */
3134       snprintf(key_value, sizeof(key_value), "filter_r%x", filter_identifier);
3135       key_value[sizeof(key_value) - 1] = '\0'; /* XXX: Why? */
3136       snprintf(key_name, sizeof(key_name), "filter_n%x", filter_identifier);
3137       key_name[sizeof(key_name) - 1] = '\0'; /* XXX: Why? */
3138       snprintf(key_type, sizeof(key_type), "filter_t%x", filter_identifier);
3139
3140       err = get_string_param(parameters, key_name, &name);
3141       if (err) break;
3142
3143       if (name == NULL)
3144       {
3145          /* End of list */
3146          break;
3147       }
3148
3149       type = get_char_param(parameters, key_type);
3150       switch (type)
3151       {
3152          case 'F':
3153             multi_action_index = ACTION_MULTI_FILTER;
3154             break;
3155          case 'S':
3156             multi_action_index = ACTION_MULTI_SERVER_HEADER_FILTER;
3157             break;
3158          case 'C':
3159             multi_action_index = ACTION_MULTI_CLIENT_HEADER_FILTER;
3160             break;
3161          case 'L':
3162             multi_action_index = ACTION_MULTI_CLIENT_HEADER_TAGGER;
3163             break;
3164          case 'E':
3165             multi_action_index = ACTION_MULTI_SERVER_HEADER_TAGGER;
3166             break;
3167          default:
3168             log_error(LOG_LEVEL_ERROR,
3169                "Unknown filter type: %c for filter %s. Filter ignored.", type, name);
3170             continue;
3171       }
3172       assert(multi_action_index);
3173
3174       value = get_char_param(parameters, key_value);
3175       if (value == 'Y')
3176       {
3177          list_remove_item(cur_line->data.action->multi_add[multi_action_index], name);
3178          if (!err) err = enlist(cur_line->data.action->multi_add[multi_action_index], name);
3179          list_remove_item(cur_line->data.action->multi_remove[multi_action_index], name);
3180       }
3181       else if (value == 'N')
3182       {
3183          list_remove_item(cur_line->data.action->multi_add[multi_action_index], name);
3184          if (!cur_line->data.action->multi_remove_all[multi_action_index])
3185          {
3186             list_remove_item(cur_line->data.action->multi_remove[multi_action_index], name);
3187             if (!err) err = enlist(cur_line->data.action->multi_remove[multi_action_index], name);
3188          }
3189       }
3190       else if (value == 'X')
3191       {
3192          list_remove_item(cur_line->data.action->multi_add[multi_action_index], name);
3193          list_remove_item(cur_line->data.action->multi_remove[multi_action_index], name);
3194       }
3195    }
3196
3197    if (err)
3198    {
3199       /* Out of memory */
3200       edit_free_file(file);
3201       return err;
3202    }
3203
3204    if (NULL == (actiontext = actions_to_text(cur_line->data.action)))
3205    {
3206       /* Out of memory */
3207       edit_free_file(file);
3208       return JB_ERR_MEMORY;
3209    }
3210
3211    len = strlen(actiontext);
3212    if (len == 0)
3213    {
3214       /*
3215        * Empty action - must special-case this.
3216        * Simply setting len to 1 is sufficient...
3217        */
3218       len = 1;
3219    }
3220
3221    newtext_size = len + 2;
3222    newtext = malloc_or_die(newtext_size);
3223    strlcpy(newtext, actiontext, newtext_size);
3224    free(actiontext);
3225    newtext[0]       = '{';
3226    newtext[len]     = '}';
3227    newtext[len + 1] = '\0';
3228
3229    freez(cur_line->raw);
3230    freez(cur_line->unprocessed);
3231    cur_line->unprocessed = newtext;
3232
3233    err = edit_write_file(file);
3234    if (err)
3235    {
3236       /* Error writing file */
3237       if (err == JB_ERR_FILE)
3238       {
3239          /* Read-only file. */
3240          err = cgi_error_file_read_only(csp, rsp, file->filename);
3241       }
3242       edit_free_file(file);
3243       return err;
3244    }
3245
3246    snprintf(target, sizeof(target), CGI_PREFIX "edit-actions-list?foo=%lu&f=%i#l%d",
3247             (long) time(NULL), file->identifier, sectionid);
3248
3249    edit_free_file(file);
3250
3251    return cgi_redirect(rsp, target);
3252 }
3253
3254
3255 /*********************************************************************
3256  *
3257  * Function    :  cgi_edit_actions_url
3258  *
3259  * Description :  CGI function that actually edits a URL pattern in
3260  *                an actions file.
3261  *
3262  * Parameters  :
3263  *          1  :  csp = Current client state (buffers, headers, etc...)
3264  *          2  :  rsp = http_response data structure for output
3265  *          3  :  parameters = map of cgi parameters
3266  *
3267  * CGI Parameters :
3268  *    filename : Identifies the file to edit
3269  *         ver : File's last-modified time
3270  *     section : Line number of section to edit
3271  *     pattern : Line number of pattern to edit
3272  *      newval : New value for pattern
3273  *
3274  * Returns     :  JB_ERR_OK     on success
3275  *                JB_ERR_MEMORY on out-of-memory
3276  *                JB_ERR_CGI_PARAMS if the CGI parameters are not
3277  *                                  specified or not valid.
3278  *
3279  *********************************************************************/
3280 jb_err cgi_edit_actions_url(struct client_state *csp,
3281                             struct http_response *rsp,
3282                             const struct map *parameters)
3283 {
3284    unsigned patternid;
3285    char * new_pattern;
3286    struct editable_file * file;
3287    struct file_line * cur_line;
3288    unsigned line_number;
3289    unsigned section_start_line_number = 0;
3290    char target[1024];
3291    jb_err err;
3292
3293    assert(csp);
3294    assert(rsp);
3295    assert(parameters);
3296
3297    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
3298    {
3299       return cgi_error_disabled(csp, rsp);
3300    }
3301
3302    err = get_number_param(csp, parameters, "p", &patternid);
3303    if (err)
3304    {
3305       return err;
3306    }
3307    if (patternid < 1U)
3308    {
3309       return JB_ERR_CGI_PARAMS;
3310    }
3311
3312    err = get_url_spec_param(csp, parameters, "u", &new_pattern);
3313    if (err)
3314    {
3315       return err;
3316    }
3317
3318    err = edit_read_actions_file(csp, rsp, parameters, 1, &file);
3319    if (err)
3320    {
3321       /* No filename specified, can't read file, modified, or out of memory. */
3322       free(new_pattern);
3323       return (err == JB_ERR_FILE ? JB_ERR_OK : err);
3324    }
3325
3326    line_number = 1;
3327    cur_line = file->lines;
3328
3329    while ((cur_line != NULL) && (line_number < patternid))
3330    {
3331       if (cur_line->type == FILE_LINE_ACTION)
3332       {
3333          section_start_line_number = line_number;
3334       }
3335       cur_line = cur_line->next;
3336       line_number++;
3337    }
3338
3339    if ((cur_line == NULL)
3340     || (cur_line->type != FILE_LINE_URL))
3341    {
3342       /* Invalid "patternid" parameter */
3343       free(new_pattern);
3344       edit_free_file(file);
3345       return JB_ERR_CGI_PARAMS;
3346    }
3347
3348    /* At this point, the line to edit is in cur_line */
3349
3350    freez(cur_line->raw);
3351    freez(cur_line->unprocessed);
3352    cur_line->unprocessed = new_pattern;
3353
3354    err = edit_write_file(file);
3355    if (err)
3356    {
3357       /* Error writing file */
3358       if (err == JB_ERR_FILE)
3359       {
3360          /* Read-only file. */
3361          err = cgi_error_file_read_only(csp, rsp, file->filename);
3362       }
3363       edit_free_file(file);
3364       return err;
3365    }
3366
3367    snprintf(target, sizeof(target), CGI_PREFIX "edit-actions-list?foo=%lu&f=%i#l%d",
3368             (long) time(NULL), file->identifier, section_start_line_number);
3369
3370    edit_free_file(file);
3371
3372    return cgi_redirect(rsp, target);
3373 }
3374
3375
3376 /*********************************************************************
3377  *
3378  * Function    :  cgi_edit_actions_add_url
3379  *
3380  * Description :  CGI function that actually adds a URL pattern to
3381  *                an actions file.
3382  *
3383  * Parameters  :
3384  *          1  :  csp = Current client state (buffers, headers, etc...)
3385  *          2  :  rsp = http_response data structure for output
3386  *          3  :  parameters = map of cgi parameters
3387  *
3388  * CGI Parameters :
3389  *    filename : Identifies the file to edit
3390  *         ver : File's last-modified time
3391  *     section : Line number of section to edit
3392  *      newval : New pattern
3393  *
3394  * Returns     :  JB_ERR_OK     on success
3395  *                JB_ERR_MEMORY on out-of-memory
3396  *                JB_ERR_CGI_PARAMS if the CGI parameters are not
3397  *                                  specified or not valid.
3398  *
3399  *********************************************************************/
3400 jb_err cgi_edit_actions_add_url(struct client_state *csp,
3401                                 struct http_response *rsp,
3402                                 const struct map *parameters)
3403 {
3404    unsigned sectionid;
3405    char * new_pattern;
3406    struct file_line * new_line;
3407    struct editable_file * file;
3408    struct file_line * cur_line;
3409    unsigned line_number;
3410    char target[1024];
3411    jb_err err;
3412
3413    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
3414    {
3415       return cgi_error_disabled(csp, rsp);
3416    }
3417
3418    err = get_number_param(csp, parameters, "s", &sectionid);
3419    if (err)
3420    {
3421       return err;
3422    }
3423    if (sectionid < 1U)
3424    {
3425       return JB_ERR_CGI_PARAMS;
3426    }
3427
3428    err = get_url_spec_param(csp, parameters, "u", &new_pattern);
3429    if (err)
3430    {
3431       return err;
3432    }
3433
3434    err = edit_read_actions_file(csp, rsp, parameters, 1, &file);
3435    if (err)
3436    {
3437       /* No filename specified, can't read file, modified, or out of memory. */
3438       free(new_pattern);
3439       return (err == JB_ERR_FILE ? JB_ERR_OK : err);
3440    }
3441
3442    line_number = 1;
3443    cur_line = file->lines;
3444
3445    while ((cur_line != NULL) && (line_number < sectionid))
3446    {
3447       cur_line = cur_line->next;
3448       line_number++;
3449    }
3450
3451    if ((cur_line == NULL)
3452     || (cur_line->type != FILE_LINE_ACTION))
3453    {
3454       /* Invalid "sectionid" parameter */
3455       free(new_pattern);
3456       edit_free_file(file);
3457       return JB_ERR_CGI_PARAMS;
3458    }
3459
3460    /* At this point, the section header is in cur_line - add after this. */
3461
3462    /* Allocate the new line */
3463    new_line = (struct file_line *)zalloc(sizeof(*new_line));
3464    if (new_line == NULL)
3465    {
3466       free(new_pattern);
3467       edit_free_file(file);
3468       return JB_ERR_MEMORY;
3469    }
3470
3471    /* Fill in the data members of the new line */
3472    new_line->raw = NULL;
3473    new_line->prefix = NULL;
3474    new_line->unprocessed = new_pattern;
3475    new_line->type = FILE_LINE_URL;
3476
3477    /* Link new_line into the list, after cur_line */
3478    new_line->next = cur_line->next;
3479    cur_line->next = new_line;
3480
3481    /* Done making changes, now commit */
3482
3483    err = edit_write_file(file);
3484    if (err)
3485    {
3486       /* Error writing file */
3487       if (err == JB_ERR_FILE)
3488       {
3489          /* Read-only file. */
3490          err = cgi_error_file_read_only(csp, rsp, file->filename);
3491       }
3492       edit_free_file(file);
3493       return err;
3494    }
3495
3496    snprintf(target, sizeof(target), CGI_PREFIX "edit-actions-list?foo=%lu&f=%i#l%d",
3497             (long) time(NULL), file->identifier, sectionid);
3498
3499    edit_free_file(file);
3500
3501    return cgi_redirect(rsp, target);
3502 }
3503
3504
3505 /*********************************************************************
3506  *
3507  * Function    :  cgi_edit_actions_remove_url
3508  *
3509  * Description :  CGI function that actually removes a URL pattern from
3510  *                the actions file.
3511  *
3512  * Parameters  :
3513  *          1  :  csp = Current client state (buffers, headers, etc...)
3514  *          2  :  rsp = http_response data structure for output
3515  *          3  :  parameters = map of cgi parameters
3516  *
3517  * CGI Parameters :
3518  *           f : (filename) Identifies the file to edit
3519  *           v : (version) File's last-modified time
3520  *           p : (pattern) Line number of pattern to remove
3521  *
3522  * Returns     :  JB_ERR_OK     on success
3523  *                JB_ERR_MEMORY on out-of-memory
3524  *                JB_ERR_CGI_PARAMS if the CGI parameters are not
3525  *                                  specified or not valid.
3526  *
3527  *********************************************************************/
3528 jb_err cgi_edit_actions_remove_url(struct client_state *csp,
3529                                    struct http_response *rsp,
3530                                    const struct map *parameters)
3531 {
3532    unsigned patternid;
3533    struct editable_file * file;
3534    struct file_line * cur_line;
3535    struct file_line * prev_line;
3536    unsigned line_number;
3537    unsigned section_start_line_number = 0;
3538    char target[1024];
3539    jb_err err;
3540
3541    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
3542    {
3543       return cgi_error_disabled(csp, rsp);
3544    }
3545
3546    err = get_number_param(csp, parameters, "p", &patternid);
3547    if (err)
3548    {
3549       return err;
3550    }
3551
3552    err = edit_read_actions_file(csp, rsp, parameters, 1, &file);
3553    if (err)
3554    {
3555       /* No filename specified, can't read file, modified, or out of memory. */
3556       return (err == JB_ERR_FILE ? JB_ERR_OK : err);
3557    }
3558
3559    line_number = 1;
3560    prev_line = NULL;
3561    cur_line = file->lines;
3562
3563    while ((cur_line != NULL) && (line_number < patternid))
3564    {
3565       if (cur_line->type == FILE_LINE_ACTION)
3566       {
3567          section_start_line_number = line_number;
3568       }
3569       prev_line = cur_line;
3570       cur_line = cur_line->next;
3571       line_number++;
3572    }
3573
3574    if ( (cur_line == NULL)
3575      || (prev_line == NULL)
3576      || (cur_line->type != FILE_LINE_URL))
3577    {
3578       /* Invalid "patternid" parameter */
3579       edit_free_file(file);
3580       return JB_ERR_CGI_PARAMS;
3581    }
3582
3583    /* At this point, the line to remove is in cur_line, and the previous
3584     * one is in prev_line
3585     */
3586
3587    /* Unlink cur_line */
3588    prev_line->next = cur_line->next;
3589    cur_line->next = NULL;
3590
3591    /* Free cur_line */
3592    edit_free_file_lines(cur_line);
3593
3594    err = edit_write_file(file);
3595    if (err)
3596    {
3597       /* Error writing file */
3598       if (err == JB_ERR_FILE)
3599       {
3600          /* Read-only file. */
3601          err = cgi_error_file_read_only(csp, rsp, file->filename);
3602       }
3603       edit_free_file(file);
3604       return err;
3605    }
3606
3607    snprintf(target, sizeof(target), CGI_PREFIX "edit-actions-list?foo=%lu&f=%i#l%d",
3608             (long) time(NULL), file->identifier, section_start_line_number);
3609
3610    edit_free_file(file);
3611
3612    return cgi_redirect(rsp, target);
3613 }
3614
3615
3616 /*********************************************************************
3617  *
3618  * Function    :  cgi_edit_actions_section_remove
3619  *
3620  * Description :  CGI function that actually removes a whole section from
3621  *                the actions file.  The section must be empty first
3622  *                (else JB_ERR_CGI_PARAMS).
3623  *
3624  * Parameters  :
3625  *          1  :  csp = Current client state (buffers, headers, etc...)
3626  *          2  :  rsp = http_response data structure for output
3627  *          3  :  parameters = map of cgi parameters
3628  *
3629  * CGI Parameters :
3630  *           f : (filename) Identifies the file to edit
3631  *           v : (version) File's last-modified time
3632  *           s : (section) Line number of section to edit
3633  *
3634  * Returns     :  JB_ERR_OK     on success
3635  *                JB_ERR_MEMORY on out-of-memory
3636  *                JB_ERR_CGI_PARAMS if the CGI parameters are not
3637  *                                  specified or not valid.
3638  *
3639  *********************************************************************/
3640 jb_err cgi_edit_actions_section_remove(struct client_state *csp,
3641                                        struct http_response *rsp,
3642                                        const struct map *parameters)
3643 {
3644    unsigned sectionid;
3645    struct editable_file * file;
3646    struct file_line * cur_line;
3647    struct file_line * prev_line;
3648    unsigned line_number;
3649    char target[1024];
3650    jb_err err;
3651
3652    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
3653    {
3654       return cgi_error_disabled(csp, rsp);
3655    }
3656
3657    err = get_number_param(csp, parameters, "s", &sectionid);
3658    if (err)
3659    {
3660       return err;
3661    }
3662
3663    err = edit_read_actions_file(csp, rsp, parameters, 1, &file);
3664    if (err)
3665    {
3666       /* No filename specified, can't read file, modified, or out of memory. */
3667       return (err == JB_ERR_FILE ? JB_ERR_OK : err);
3668    }
3669
3670    line_number = 1;
3671    cur_line = file->lines;
3672
3673    prev_line = NULL;
3674    while ((cur_line != NULL) && (line_number < sectionid))
3675    {
3676       prev_line = cur_line;
3677       cur_line = cur_line->next;
3678       line_number++;
3679    }
3680
3681    if ((cur_line == NULL)
3682     || (cur_line->type != FILE_LINE_ACTION))
3683    {
3684       /* Invalid "sectionid" parameter */
3685       edit_free_file(file);
3686       return JB_ERR_CGI_PARAMS;
3687    }
3688
3689    if ((cur_line->next != NULL)
3690     && (cur_line->next->type == FILE_LINE_URL))
3691    {
3692       /* Section not empty. */
3693       edit_free_file(file);
3694       return JB_ERR_CGI_PARAMS;
3695    }
3696
3697    /* At this point, the line to remove is in cur_line, and the previous
3698     * one is in prev_line
3699     */
3700
3701    /* Unlink cur_line */
3702    if (prev_line == NULL)
3703    {
3704       /* Removing the first line from the file */
3705       file->lines = cur_line->next;
3706    }
3707    else
3708    {
3709       prev_line->next = cur_line->next;
3710    }
3711    cur_line->next = NULL;
3712
3713    /* Free cur_line */
3714    edit_free_file_lines(cur_line);
3715
3716    err = edit_write_file(file);
3717    if (err)
3718    {
3719       /* Error writing file */
3720       if (err == JB_ERR_FILE)
3721       {
3722          /* Read-only file. */
3723          err = cgi_error_file_read_only(csp, rsp, file->filename);
3724       }
3725       edit_free_file(file);
3726       return err;
3727    }
3728
3729    snprintf(target, sizeof(target), CGI_PREFIX "edit-actions-list?foo=%lu&f=%i",
3730             (long) time(NULL), file->identifier);
3731
3732    edit_free_file(file);
3733
3734    return cgi_redirect(rsp, target);
3735 }
3736
3737
3738 /*********************************************************************
3739  *
3740  * Function    :  cgi_edit_actions_section_add
3741  *
3742  * Description :  CGI function that adds a new empty section to
3743  *                an actions file.
3744  *
3745  * Parameters  :
3746  *          1  :  csp = Current client state (buffers, headers, etc...)
3747  *          2  :  rsp = http_response data structure for output
3748  *          3  :  parameters = map of cgi parameters
3749  *
3750  * CGI Parameters :
3751  *           f : (filename) Identifies the file to edit
3752  *           v : (version) File's last-modified time
3753  *           s : (section) Line number of section to add after, 0 for
3754  *               start of file.
3755  *
3756  * Returns     :  JB_ERR_OK     on success
3757  *                JB_ERR_MEMORY on out-of-memory
3758  *                JB_ERR_CGI_PARAMS if the CGI parameters are not
3759  *                                  specified or not valid.
3760  *
3761  *********************************************************************/
3762 jb_err cgi_edit_actions_section_add(struct client_state *csp,
3763                                     struct http_response *rsp,
3764                                     const struct map *parameters)
3765 {
3766    unsigned sectionid;
3767    struct file_line * new_line;
3768    char * new_text;
3769    struct editable_file * file;
3770    struct file_line * cur_line;
3771    unsigned line_number;
3772    char target[1024];
3773    jb_err err;
3774
3775    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
3776    {
3777       return cgi_error_disabled(csp, rsp);
3778    }
3779
3780    err = get_number_param(csp, parameters, "s", &sectionid);
3781    if (err)
3782    {
3783       return err;
3784    }
3785
3786    err = edit_read_actions_file(csp, rsp, parameters, 1, &file);
3787    if (err)
3788    {
3789       /* No filename specified, can't read file, modified, or out of memory. */
3790       return (err == JB_ERR_FILE ? JB_ERR_OK : err);
3791    }
3792