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