cgiedit.c

   1 const char cgiedit_rcs[] = "$Id: cgiedit.c,v 1.44 2006/12/09 13:49:16 fabiankeil 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  *                Privoxy team. http://www.privoxy.org/
  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.44  2006/12/09 13:49:16  fabiankeil
  46  *    Fix configure option --disable-toggle.
  47  *    Thanks to Peter Thoenen for reporting this.
  48  *
  49  *    Revision 1.43  2006/07/18 14:48:45  david__schmidt
  50  *    Reorganizing the repository: swapping out what was HEAD (the old 3.1 branch)
  51  *    with what was really the latest development (the v_3_0_branch branch)
  52  *
  53  *    Revision 1.41.2.12  2006/01/30 15:16:25  david__schmidt
  54  *    Remove a little residual debugging info
  55  *
  56  *    Revision 1.41.2.11  2006/01/29 23:10:56  david__schmidt
  57  *    Multiple filter file support
  58  *
  59  *    Revision 1.41.2.10  2005/07/04 03:13:43  david__schmidt
  60  *    Undo some damaging memory leak patches
  61  *
  62  *    Revision 1.41.2.9  2005/07/04 00:31:04  david__schmidt
  63  *    Removing a double free
  64  *
  65  *    Revision 1.41.2.8  2005/05/07 21:50:54  david__schmidt
  66  *    A few memory leaks plugged (mostly on error paths)
  67  *
  68  *    Revision 1.41.2.7  2004/02/17 13:30:23  oes
  69  *    Moved cgi_error_disabled() from cgiedit.c to
  70  *    cgi.c to re-enable build with --disable-editor.
  71  *    Fixes Bug #892744. Thanks to Matthew Fischer
  72  *    for spotting.
  73  *
  74  *    Revision 1.41.2.6  2003/12/18 08:13:48  oes
  75  *    One line lost in last commit
  76  *
  77  *    Revision 1.41.2.5  2003/12/17 16:33:47  oes
  78  *     - All edit functions that redirect back to the list page
  79  *       now use cgi_redirect
  80  *     - All redirects now contain useless parameter "foo", whose
  81  *       value are raw seconds since epoch, in order to force
  82  *       Opera and Konqueror to properly reload the list. Closes
  83  *       bug #859993
  84  *
  85  *    Revision 1.41.2.4  2003/03/11 11:53:59  oes
  86  *    Cosmetic: Renamed cryptic variable
  87  *
  88  *    Revision 1.41.2.3  2002/11/12 15:01:41  oes
  89  *    Fix: Don't free uninitialized struct editable_file
  90  *
  91  *    Revision 1.41.2.2  2002/08/05 20:02:59  oes
  92  *    Bugfix: "Insert new section at top" did not work properly if first non-comment line in file was of type FILE_LINE_ACTION
  93  *
  94  *    Revision 1.41.2.1  2002/08/02 12:43:14  oes
  95  *    Fixed bug #588514: first_time now set on a per-string basis in actions_from_radio; javascriptify now called on copies
  96  *
  97  *    Revision 1.41  2002/05/21 19:09:45  oes
  98  *     - Made Add/Edit/Remove URL Submit and Cancel
  99  *       buttons jump back to relevant section in eal
 100  *     - Bugfix: remove-url-form needs p export
 101  *
 102  *    Revision 1.40  2002/05/19 11:34:35  jongfoster
 103  *    Handling read-only actions files better - report the actual
 104  *    error, not "Out of memory"!
 105  *
 106  *    Bug report:
 107  *    http://sourceforge.net/tracker/index.php?func=detail
 108  *    &aid=557905&group_id=11118&atid=111118
 109  *
 110  *    Revision 1.39  2002/05/12 21:39:15  jongfoster
 111  *    - Adding Doxygen-style comments to structures and #defines.
 112  *    - Correcting function comments
 113  *
 114  *    Revision 1.38  2002/05/03 23:00:38  jongfoster
 115  *    Support for templates for "standard actions" buttons.
 116  *    See bug #549871
 117  *
 118  *    Revision 1.37  2002/04/30 11:14:52  oes
 119  *    Made csp the first parameter in *action_to_html
 120  *
 121  *    Revision 1.36  2002/04/26 21:53:30  jongfoster
 122  *    Fixing a memory leak.  (Near, but not caused by, my earlier commit).
 123  *
 124  *    Revision 1.35  2002/04/26 21:50:02  jongfoster
 125  *    Honouring default exports in edit-actions-for-url-filter template.
 126  *
 127  *    Revision 1.34  2002/04/26 12:54:17  oes
 128  *    Adaptions to changes in actions.c
 129  *
 130  *    Revision 1.33  2002/04/24 02:17:47  oes
 131  *     - Moved get_char_param, get_string_param and get_number_param to cgi.c
 132  *     - Comments
 133  *     - Activated Jon's code for editing multiple AFs
 134  *     - cgi_edit_list_actions now provides context-sensitive
 135  *       help, looks up all action sets from standard.action and
 136  *       makes buttons for them in the catchall section
 137  *     - cgi_edit_action_submit now honors a p parameter, looks up
 138  *       the corresponding action set, and sets the catchall pattern's
 139  *       actions accordingly.
 140  *
 141  *    Revision 1.32  2002/04/19 16:55:31  jongfoster
 142  *    Fixing newline problems.  If we do our own text file newline
 143  *    mangling, we don't want the library to do any, so we need to
 144  *    open the files in *binary* mode.
 145  *
 146  *    Revision 1.31  2002/04/18 19:21:08  jongfoster
 147  *    Added code to detect "conventional" action files, that start
 148  *    with a set of actions for all URLs (the pattern "/").
 149  *    These are special-cased in the "edit-actions-list" CGI, so
 150  *    that a special UI can be written for them.
 151  *
 152  *    Revision 1.30  2002/04/10 13:38:35  oes
 153  *    load_template signature changed
 154  *
 155  *    Revision 1.29  2002/04/08 16:59:08  oes
 156  *    Fixed comment
 157  *
 158  *    Revision 1.28  2002/03/27 12:30:29  oes
 159  *    Deleted unsused variable
 160  *
 161  *    Revision 1.27  2002/03/26 23:06:04  jongfoster
 162  *    Removing duplicate @ifs on the toggle page
 163  *
 164  *    Revision 1.26  2002/03/26 22:59:17  jongfoster
 165  *    Fixing /toggle to display status consistently.
 166  *
 167  *    Revision 1.25  2002/03/26 22:29:54  swa
 168  *    we have a new homepage!
 169  *
 170  *    Revision 1.24  2002/03/24 15:23:33  jongfoster
 171  *    Name changes
 172  *
 173  *    Revision 1.23  2002/03/24 13:32:41  swa
 174  *    name change related issues
 175  *
 176  *    Revision 1.22  2002/03/24 13:25:43  swa
 177  *    name change related issues
 178  *
 179  *    Revision 1.21  2002/03/22 18:02:48  jongfoster
 180  *    Fixing remote toggle
 181  *
 182  *    Revision 1.20  2002/03/16 20:28:34  oes
 183  *    Added descriptions to the filters so users will know what they select in the cgi editor
 184  *
 185  *    Revision 1.19  2002/03/16 18:38:14  jongfoster
 186  *    Stopping stupid or malicious users from breaking the actions
 187  *    file using the web-based editor.
 188  *
 189  *    Revision 1.18  2002/03/16 14:57:44  jongfoster
 190  *    Full support for enabling/disabling modular filters.
 191  *
 192  *    Revision 1.17  2002/03/16 14:26:42  jongfoster
 193  *    First version of modular filters support - READ ONLY!
 194  *    Fixing a double-free bug in the out-of-memory handling in map_radio().
 195  *
 196  *    Revision 1.16  2002/03/07 03:46:17  oes
 197  *    Fixed compiler warnings
 198  *
 199  *    Revision 1.15  2002/03/06 22:54:35  jongfoster
 200  *    Automated function-comment nitpicking.
 201  *
 202  *    Revision 1.14  2002/03/05 00:24:51  jongfoster
 203  *    Patch to always edit the current actions file.
 204  *
 205  *    Revision 1.13  2002/03/04 02:07:59  david__schmidt
 206  *    Enable web editing of actions file on OS/2 (it had been broken all this time!)
 207  *
 208  *    Revision 1.12  2002/03/03 09:18:03  joergs
 209  *    Made jumbjuster work on AmigaOS again.
 210  *
 211  *    Revision 1.11  2002/01/23 01:03:31  jongfoster
 212  *    Fixing gcc [CygWin] compiler warnings
 213  *
 214  *    Revision 1.10  2002/01/23 00:22:59  jongfoster
 215  *    Adding new function cgi_edit_actions_section_swap(), to reorder
 216  *    the actions file.
 217  *
 218  *    Adding get_url_spec_param() to get a validated URL pattern.
 219  *
 220  *    Moving edit_read_line() out of this file and into loaders.c.
 221  *
 222  *    Adding missing html_encode() to many CGI functions.
 223  *
 224  *    Moving the functions that #include actionlist.h to the end of the file,
 225  *    because the Visual C++ 97 debugger gets extremely confused if you try
 226  *    to debug any code that comes after them in the file.
 227  *
 228  *    Major optimizations in cgi_edit_actions_list() to reduce the size of
 229  *    the generated HTML (down 40% from 550k to 304k), with major side-effects
 230  *    throughout the editor and templates.  In particular, the length of the
 231  *    URLs throughout the editor has been drastically reduced, by cutting
 232  *    paramater names down to 1 character and CGI names down to 3-4
 233  *    characters, by removing all non-essential CGI paramaters even at the
 234  *    expense of having to re-read the actions file for the most trivial
 235  *    page, and by using relative rather than absolute URLs.  This means
 236  *    that this (typical example):
 237  *
 238  *    <a href="http://ijbswa.sourceforge.net/config/edit-actions-url-form?
 239  *    filename=ijb&amp;ver=1011487572&amp;section=12&amp;pattern=13
 240  *    &amp;oldval=www.oesterhelt.org%2Fdeanimate-demo">
 241  *
 242  *    is now this:
 243  *
 244  *    <a href="eau?f=ijb&amp;v=1011487572&amp;p=13">
 245  *
 246  *    Revision 1.9  2002/01/17 20:56:22  jongfoster
 247  *    Replacing hard references to the URL of the config interface
 248  *    with #defines from project.h
 249  *
 250  *    Revision 1.8  2001/11/30 23:35:51  jongfoster
 251  *    Renaming actionsfile to ijb.action
 252  *
 253  *    Revision 1.7  2001/11/13 00:28:24  jongfoster
 254  *    - Renaming parameters from edit-actions-for-url so that they only
 255  *      contain legal JavaScript characters.  If we wanted to write
 256  *      JavaScript that worked with Netscape 4, this is nessacery.
 257  *      (Note that at the moment the JavaScript doesn't actually work
 258  *      with Netscape 4, but now this is purely a template issue, not
 259  *      one affecting code).
 260  *    - Adding new CGIs for use by non-JavaScript browsers:
 261  *        edit-actions-url-form
 262  *        edit-actions-add-url-form
 263  *        edit-actions-remove-url-form
 264  *    - Fixing || bug.
 265  *
 266  *    Revision 1.6  2001/10/29 03:48:09  david__schmidt
 267  *    OS/2 native needed a snprintf() routine.  Added one to miscutil, brackedted
 268  *    by and __OS2__ ifdef.
 269  *
 270  *    Revision 1.5  2001/10/25 03:40:48  david__schmidt
 271  *    Change in porting tactics: OS/2's EMX porting layer doesn't allow multiple
 272  *    threads to call select() simultaneously.  So, it's time to do a real, live,
 273  *    native OS/2 port.  See defines for __EMX__ (the porting layer) vs. __OS2__
 274  *    (native). Both versions will work, but using __OS2__ offers multi-threading.
 275  *
 276  *    Revision 1.4  2001/10/23 21:48:19  jongfoster
 277  *    Cleaning up error handling in CGI functions - they now send back
 278  *    a HTML error page and should never cause a FATAL error.  (Fixes one
 279  *    potential source of "denial of service" attacks).
 280  *
 281  *    CGI actions file editor that works and is actually useful.
 282  *
 283  *    Ability to toggle JunkBuster remotely using a CGI call.
 284  *
 285  *    You can turn off both the above features in the main configuration
 286  *    file, e.g. if you are running a multi-user proxy.
 287  *
 288  *    Revision 1.3  2001/10/14 22:12:49  jongfoster
 289  *    New version of CGI-based actionsfile editor.
 290  *    Major changes, including:
 291  *    - Completely new file parser and file output routines
 292  *    - edit-actions CGI renamed edit-actions-for-url
 293  *    - All CGIs now need a filename parameter, except for...
 294  *    - New CGI edit-actions which doesn't need a filename,
 295  *      to allow you to start the editor up.
 296  *    - edit-actions-submit now works, and now automatically
 297  *      redirects you back to the main edit-actions-list handler.
 298  *
 299  *    Revision 1.2  2001/09/16 17:05:14  jongfoster
 300  *    Removing unused #include showarg.h
 301  *
 302  *    Revision 1.1  2001/09/16 15:47:37  jongfoster
 303  *    First version of CGI-based edit interface.  This is very much a
 304  *    work-in-progress, and you can't actually use it to edit anything
 305  *    yet.  You must #define FEATURE_CGI_EDIT_ACTIONS for these changes
 306  *    to have any effect.
 307  *
 308  *
 309  **********************************************************************/
 310 \f
 311
 312 #include "config.h"
 313
 314 /*
 315  * FIXME: Following includes copied from cgi.c - which are actually needed?
 316  */
 317
 318 #include <stdio.h>
 319 #include <stdlib.h>
 320 #include <sys/types.h>
 321 #include <ctype.h>
 322 #include <string.h>
 323 #include <assert.h>
 324 #include <sys/stat.h>
 325
 326 #ifdef _WIN32
 327 #define snprintf _snprintf
 328 #endif /* def _WIN32 */
 329
 330 #include "project.h"
 331 #include "cgi.h"
 332 #include "cgiedit.h"
 333 #include "cgisimple.h"
 334 #include "list.h"
 335 #include "encode.h"
 336 #include "actions.h"
 337 #include "miscutil.h"
 338 #include "errlog.h"
 339 #include "loaders.h"
 340 #ifdef FEATURE_TOGGLE
 341 /* loadcfg.h is for global_toggle_state only */
 342 #include "loadcfg.h"
 343 #endif /* def FEATURE_TOGGLE */
 344 #include "urlmatch.h"
 345
 346 const char cgiedit_h_rcs[] = CGIEDIT_H_VERSION;
 347
 348
 349 #ifdef FEATURE_CGI_EDIT_ACTIONS
 350
 351 /**
 352  * A line in an editable_file.
 353  */
 354 struct file_line
 355 {
 356    /** Next entry in the linked list */
 357    struct file_line * next;
 358
 359    /** The raw data, to write out if this line is unmodified. */
 360    char * raw;
 361
 362    /** Comments and/or whitespace to put before this line if it's modified
 363        and then written out. */
 364    char * prefix;
 365
 366    /** The actual data, as a string.  Line continuation and comment removal
 367        are performed on the data read from file before it's stored here, so
 368        it will be a single line of data.  */
 369    char * unprocessed;
 370
 371    /** The type of data on this line.  One of the FILE_LINE_xxx constants. */
 372    int type;
 373
 374    /** The actual data, processed into some sensible data type. */
 375    union
 376    {
 377
 378       /** An action specification. */
 379       struct action_spec action[1];
 380
 381       /** A name=value pair. */
 382       struct
 383       {
 384
 385          /** The name in the name=value pair. */
 386          char * name;
 387
 388          /** The value in the name=value pair, as a string. */
 389          char * svalue;
 390
 391          /** The value in the name=value pair, as an integer. */
 392          int ivalue;
 393
 394       } setting;
 395
 396       /* Add more data types here... e.g.
 397
 398
 399       struct url_spec url[1];
 400
 401       struct
 402       {
 403          struct action_spec action[1];
 404          const char * name;
 405       } alias;
 406
 407       */
 408
 409    } data;
 410
 411 };
 412
 413 /** This file_line has not been processed yet. */
 414 #define FILE_LINE_UNPROCESSED           1
 415
 416 /** This file_line is blank. Can only appear at the end of a file, due to
 417     the way the parser works. */
 418 #define FILE_LINE_BLANK                 2
 419
 420 /** This file_line says {{alias}}. */
 421 #define FILE_LINE_ALIAS_HEADER          3
 422
 423 /** This file_line defines an alias. */
 424 #define FILE_LINE_ALIAS_ENTRY           4
 425
 426 /** This file_line defines an {action}. */
 427 #define FILE_LINE_ACTION                5
 428
 429 /** This file_line specifies a URL pattern. */
 430 #define FILE_LINE_URL                   6
 431
 432 /** This file_line says {{settings}}. */
 433 #define FILE_LINE_SETTINGS_HEADER       7
 434
 435 /** This file_line is in a {{settings}} block. */
 436 #define FILE_LINE_SETTINGS_ENTRY        8
 437
 438 /** This file_line says {{description}}. */
 439 #define FILE_LINE_DESCRIPTION_HEADER    9
 440
 441 /** This file_line is in a {{description}} block. */
 442 #define FILE_LINE_DESCRIPTION_ENTRY    10
 443
 444
 445 /**
 446  * A configuration file, in a format that can be edited and written back to
 447  * disk.
 448  */
 449 struct editable_file
 450 {
 451    struct file_line * lines;  /**< The contents of the file.  A linked list of lines. */
 452    const char * filename;     /**< Full pathname - e.g. "/etc/privoxy/wibble.action". */
 453    const char * identifier;   /**< Filename stub - e.g. "wibble".  Use for CGI param. */
 454                               /**< Pre-encoded with url_encode() for ease of use. */
 455    const char * version_str;  /**< Last modification time, as a string.  For CGI param. */
 456                               /**< Can be used in URL without using url_param(). */
 457    unsigned version;          /**< Last modification time - prevents chaos with
 458                                    the browser's "back" button.  Note that this is a
 459                                    time_t cast to an unsigned.  When comparing, always
 460                                    cast the time_t to an unsigned, and *NOT* vice-versa.
 461                                    This may lose the top few bits, but they're not
 462                                    significant anyway. */
 463    int newline;               /**< Newline convention - one of the NEWLINE_xxx constants.
 464                                    Note that changing this after the file has been
 465                                    read in will cause a mess. */
 466    struct file_line * parse_error; /**< On parse error, this is the offending line. */
 467    const char * parse_error_text;  /**< On parse error, this is the problem.
 468                                         (Statically allocated) */
 469 };
 470
 471 /* FIXME: Following non-static functions should be prototyped in .h or made static */
 472
 473 /* Functions to read and write arbitrary config files */
 474 jb_err edit_read_file(struct client_state *csp,
 475                       const struct map *parameters,
 476                       int require_version,
 477                       const char *suffix,
 478                       struct editable_file **pfile);
 479 jb_err edit_write_file(struct editable_file * file);
 480 void   edit_free_file(struct editable_file * file);
 481
 482 /* Functions to read and write actions files */
 483 jb_err edit_parse_actions_file(struct editable_file * file);
 484 jb_err edit_read_actions_file(struct client_state *csp,
 485                               struct http_response *rsp,
 486                               const struct map *parameters,
 487                               int require_version,
 488                               struct editable_file **pfile);
 489
 490 /* Error handlers */
 491 jb_err cgi_error_modified(struct client_state *csp,
 492                           struct http_response *rsp,
 493                           const char *filename);
 494 jb_err cgi_error_parse(struct client_state *csp,
 495                        struct http_response *rsp,
 496                        struct editable_file *file);
 497 jb_err cgi_error_file(struct client_state *csp,
 498                       struct http_response *rsp,
 499                       const char *filename);
 500 jb_err cgi_error_file_read_only(struct client_state *csp,
 501                                 struct http_response *rsp,
 502                                 const char *filename);
 503
 504 /* Internal arbitrary config file support functions */
 505 static jb_err edit_read_file_lines(FILE *fp, struct file_line ** pfile, int *newline);
 506 static void edit_free_file_lines(struct file_line * first_line);
 507
 508 /* Internal actions file support functions */
 509 static int match_actions_file_header_line(const char * line, const char * name);
 510 static jb_err split_line_on_equals(const char * line, char ** pname, char ** pvalue);
 511
 512 /* Internal parameter parsing functions */
 513 static jb_err get_file_name_param(struct client_state *csp,
 514                                   const struct map *parameters,
 515                                   const char *param_name,
 516                                   const char *suffix,
 517                                   char **pfilename,
 518                                   const char **pparam);
 519
 520 static jb_err get_url_spec_param(struct client_state *csp,
 521                                  const struct map *parameters,
 522                                  const char *name,
 523                                  char **pvalue);
 524
 525
 526 /* Internal actionsfile <==> HTML conversion functions */
 527 static jb_err map_radio(struct map * exports,
 528                         const char * optionname,
 529                         const char * values,
 530                         int value);
 531 static jb_err actions_to_radio(struct map * exports,
 532                                const struct action_spec *action);
 533 static jb_err actions_from_radio(const struct map * parameters,
 534                                  struct action_spec *action);
 535
 536
 537 static jb_err map_copy_parameter_html(struct map *out,
 538                                       const struct map *in,
 539                                       const char *name);
 540 #if 0 /* unused function */
 541 static jb_err map_copy_parameter_url(struct map *out,
 542                                      const struct map *in,
 543                                      const char *name);
 544 #endif /* unused function */
 545
 546 /* Internal convenience functions */
 547 static char *section_target(const unsigned sectionid);
 548
 549 /*********************************************************************
 550  *
 551  * Function    :  section_target
 552  *
 553  * Description :  Given an unsigned (section id) n, produce a dynamically
 554  *                allocated string of the form #l<n>, for use in link
 555  *                targets.
 556  *
 557  * Parameters  :
 558  *          1  :  sectionid = start line number of section
 559  *
 560  * Returns     :  String with link target, or NULL if out of
 561  *                memory
 562  *
 563  *********************************************************************/
 564 static char *section_target(const unsigned sectionid)
 565 {
 566    char buf[30];
 567
 568    snprintf(buf, 30, "#l%d", sectionid);
 569    return(strdup(buf));
 570
 571 }
 572
 573
 574 /*********************************************************************
 575  *
 576  * Function    :  map_copy_parameter_html
 577  *
 578  * Description :  Copy a CGI parameter from one map to another, HTML
 579  *                encoding it.
 580  *
 581  * Parameters  :
 582  *          1  :  out = target map
 583  *          2  :  in = source map
 584  *          3  :  name = name of cgi parameter to copy
 585  *
 586  * Returns     :  JB_ERR_OK on success
 587  *                JB_ERR_MEMORY on out-of-memory
 588  *                JB_ERR_CGI_PARAMS if the parameter doesn't exist
 589  *                                  in the source map
 590  *
 591  *********************************************************************/
 592 static jb_err map_copy_parameter_html(struct map *out,
 593                                       const struct map *in,
 594                                       const char *name)
 595 {
 596    const char * value;
 597    jb_err err;
 598
 599    assert(out);
 600    assert(in);
 601    assert(name);
 602
 603    value = lookup(in, name);
 604    err = map(out, name, 1, html_encode(value), 0);
 605
 606    if (err)
 607    {
 608       /* Out of memory */
 609       return err;
 610    }
 611    else if (*value == '\0')
 612    {
 613       return JB_ERR_CGI_PARAMS;
 614    }
 615    else
 616    {
 617       return JB_ERR_OK;
 618    }
 619 }
 620
 621
 622 #if 0 /* unused function */
 623 /*********************************************************************
 624  *
 625  * Function    :  map_copy_parameter_url
 626  *
 627  * Description :  Copy a CGI parameter from one map to another, URL
 628  *                encoding it.
 629  *
 630  * Parameters  :
 631  *          1  :  out = target map
 632  *          2  :  in = source map
 633  *          3  :  name = name of cgi parameter to copy
 634  *
 635  * Returns     :  JB_ERR_OK on success
 636  *                JB_ERR_MEMORY on out-of-memory
 637  *                JB_ERR_CGI_PARAMS if the parameter doesn't exist
 638  *                                  in the source map
 639  *
 640  *********************************************************************/
 641 static jb_err map_copy_parameter_url(struct map *out,
 642                                      const struct map *in,
 643                                      const char *name)
 644 {
 645    const char * value;
 646    jb_err err;
 647
 648    assert(out);
 649    assert(in);
 650    assert(name);
 651
 652    value = lookup(in, name);
 653    err = map(out, name, 1, url_encode(value), 0);
 654
 655    if (err)
 656    {
 657       /* Out of memory */
 658       return err;
 659    }
 660    else if (*value == '\0')
 661    {
 662       return JB_ERR_CGI_PARAMS;
 663    }
 664    else
 665    {
 666       return JB_ERR_OK;
 667    }
 668 }
 669 #endif /* 0 - unused function */
 670
 671 /*********************************************************************
 672  *
 673  * Function    :  cgi_edit_actions_url_form
 674  *
 675  * Description :  CGI function that displays a form for
 676  *                edit-actions-url
 677  *
 678  * Parameters  :
 679  *          1  :  csp = Current client state (buffers, headers, etc...)
 680  *          2  :  rsp = http_response data structure for output
 681  *          3  :  parameters = map of cgi parameters
 682  *
 683  * CGI Parameters
 684  *           f : (filename) Identifies the file to edit
 685  *           v : (version) File's last-modified time
 686  *           p : (pattern) Line number of pattern to edit
 687  *
 688  * Returns     :  JB_ERR_OK on success
 689  *                JB_ERR_MEMORY on out-of-memory
 690  *                JB_ERR_CGI_PARAMS if the CGI parameters are not
 691  *                                  specified or not valid.
 692  *
 693  *********************************************************************/
 694 jb_err cgi_edit_actions_url_form(struct client_state *csp,
 695                                  struct http_response *rsp,
 696                                  const struct map *parameters)
 697 {
 698    struct map * exports;
 699    unsigned patternid;
 700    struct editable_file * file;
 701    struct file_line * cur_line;
 702    unsigned line_number;
 703    unsigned section_start_line_number = 0;
 704    jb_err err;
 705
 706    assert(csp);
 707    assert(rsp);
 708    assert(parameters);
 709
 710    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
 711    {
 712       return cgi_error_disabled(csp, rsp);
 713    }
 714
 715    err = get_number_param(csp, parameters, "p", &patternid);
 716    if (err)
 717    {
 718       return err;
 719    }
 720
 721    err = edit_read_actions_file(csp, rsp, parameters, 1, &file);
 722    if (err)
 723    {
 724       /* No filename specified, can't read file, modified, or out of memory. */
 725       return (err == JB_ERR_FILE ? JB_ERR_OK : err);
 726    }
 727
 728    cur_line = file->lines;
 729
 730    for (line_number = 1; (cur_line != NULL) && (line_number < patternid); line_number++)
 731    {
 732       if (cur_line->type == FILE_LINE_ACTION)
 733       {
 734          section_start_line_number = line_number;
 735       }
 736       cur_line = cur_line->next;
 737    }
 738
 739    if ( (cur_line == NULL)
 740      || (line_number != patternid)
 741      || (patternid < 1)
 742      || (cur_line->type != FILE_LINE_URL))
 743    {
 744       /* Invalid "patternid" parameter */
 745       edit_free_file(file);
 746       return JB_ERR_CGI_PARAMS;
 747    }
 748
 749    if (NULL == (exports = default_exports(csp, NULL)))
 750    {
 751       edit_free_file(file);
 752       return JB_ERR_MEMORY;
 753    }
 754
 755    err = map(exports, "f", 1, file->identifier, 1);
 756    if (!err) err = map(exports, "v", 1, file->version_str, 1);
 757    if (!err) err = map(exports, "p", 1, url_encode(lookup(parameters, "p")), 0);
 758    if (!err) err = map(exports, "u", 1, html_encode(cur_line->unprocessed), 0);
 759    if (!err) err = map(exports, "jumptarget", 1, section_target(section_start_line_number), 0);
 760
 761    edit_free_file(file);
 762
 763    if (err)
 764    {
 765       free_map(exports);
 766       return err;
 767    }
 768
 769    return template_fill_for_cgi(csp, "edit-actions-url-form", exports, rsp);
 770 }
 771
 772
 773 /*********************************************************************
 774  *
 775  * Function    :  cgi_edit_actions_add_url_form
 776  *
 777  * Description :  CGI function that displays a form for
 778  *                edit-actions-url
 779  *
 780  * Parameters  :
 781  *          1  :  csp = Current client state (buffers, headers, etc...)
 782  *          2  :  rsp = http_response data structure for output
 783  *          3  :  parameters = map of cgi parameters
 784  *
 785  * CGI Parameters :
 786  *           f : (filename) Identifies the file to edit
 787  *           v : (version) File's last-modified time
 788  *           s : (section) Line number of section to edit
 789  *
 790  * Returns     :  JB_ERR_OK on success
 791  *                JB_ERR_MEMORY on out-of-memory
 792  *                JB_ERR_CGI_PARAMS if the CGI parameters are not
 793  *                                  specified or not valid.
 794  *
 795  *********************************************************************/
 796 jb_err cgi_edit_actions_add_url_form(struct client_state *csp,
 797                                      struct http_response *rsp,
 798                                      const struct map *parameters)
 799 {
 800    struct map *exports;
 801    jb_err err;
 802
 803    assert(csp);
 804    assert(rsp);
 805    assert(parameters);
 806
 807    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
 808    {
 809       return cgi_error_disabled(csp, rsp);
 810    }
 811
 812    if (NULL == (exports = default_exports(csp, NULL)))
 813    {
 814       return JB_ERR_MEMORY;
 815    }
 816
 817    err = map_copy_parameter_html(exports, parameters, "f");
 818    if (!err) err = map_copy_parameter_html(exports, parameters, "v");
 819    if (!err) err = map_copy_parameter_html(exports, parameters, "s");
 820
 821    if (err)
 822    {
 823       free_map(exports);
 824       return err;
 825    }
 826
 827    return template_fill_for_cgi(csp, "edit-actions-add-url-form", exports, rsp);
 828 }
 829
 830
 831 /*********************************************************************
 832  *
 833  * Function    :  cgi_edit_actions_remove_url_form
 834  *
 835  * Description :  CGI function that displays a form for
 836  *                edit-actions-url
 837  *
 838  * Parameters  :
 839  *          1  :  csp = Current client state (buffers, headers, etc...)
 840  *          2  :  rsp = http_response data structure for output
 841  *          3  :  parameters = map of cgi parameters
 842  *
 843  * CGI Parameters :
 844  *           f : (filename) Identifies the file to edit
 845  *           v : (version) File's last-modified time
 846  *           p : (pattern) Line number of pattern to edit
 847  *
 848  * Returns     :  JB_ERR_OK on success
 849  *                JB_ERR_MEMORY on out-of-memory
 850  *                JB_ERR_CGI_PARAMS if the CGI parameters are not
 851  *                                  specified or not valid.
 852  *
 853  *********************************************************************/
 854 jb_err cgi_edit_actions_remove_url_form(struct client_state *csp,
 855                                      struct http_response *rsp,
 856                                      const struct map *parameters)
 857 {
 858    struct map * exports;
 859    unsigned patternid;
 860    struct editable_file * file;
 861    struct file_line * cur_line;
 862    unsigned line_number;
 863    unsigned section_start_line_number = 0;
 864    jb_err err;
 865
 866    assert(csp);
 867    assert(rsp);
 868    assert(parameters);
 869
 870    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
 871    {
 872       return cgi_error_disabled(csp, rsp);
 873    }
 874
 875    err = get_number_param(csp, parameters, "p", &patternid);
 876    if (err)
 877    {
 878       return err;
 879    }
 880
 881    err = edit_read_actions_file(csp, rsp, parameters, 1, &file);
 882    if (err)
 883    {
 884       /* No filename specified, can't read file, modified, or out of memory. */
 885       return (err == JB_ERR_FILE ? JB_ERR_OK : err);
 886    }
 887
 888    cur_line = file->lines;
 889
 890    for (line_number = 1; (cur_line != NULL) && (line_number < patternid); line_number++)
 891    {
 892       if (cur_line->type == FILE_LINE_ACTION)
 893       {
 894          section_start_line_number = line_number;
 895       }
 896       cur_line = cur_line->next;
 897    }
 898
 899    if ( (cur_line == NULL)
 900      || (line_number != patternid)
 901      || (patternid < 1)
 902      || (cur_line->type != FILE_LINE_URL))
 903    {
 904       /* Invalid "patternid" parameter */
 905       edit_free_file(file);
 906       return JB_ERR_CGI_PARAMS;
 907    }
 908
 909    if (NULL == (exports = default_exports(csp, NULL)))
 910    {
 911       edit_free_file(file);
 912       return JB_ERR_MEMORY;
 913    }
 914
 915    err = map(exports, "f", 1, file->identifier, 1);
 916    if (!err) err = map(exports, "v", 1, file->version_str, 1);
 917    if (!err) err = map(exports, "p", 1, url_encode(lookup(parameters, "p")), 0);
 918    if (!err) err = map(exports, "u", 1, html_encode(cur_line->unprocessed), 0);
 919    if (!err) err = map(exports, "jumptarget", 1, section_target(section_start_line_number), 0);
 920
 921    edit_free_file(file);
 922
 923    if (err)
 924    {
 925       free_map(exports);
 926       return err;
 927    }
 928
 929    return template_fill_for_cgi(csp, "edit-actions-remove-url-form", exports, rsp);
 930 }
 931
 932
 933 /*********************************************************************
 934  *
 935  * Function    :  edit_write_file
 936  *
 937  * Description :  Write a complete file to disk.
 938  *
 939  * Parameters  :
 940  *          1  :  file = File to write.
 941  *
 942  * Returns     :  JB_ERR_OK     on success
 943  *                JB_ERR_FILE   on error writing to file.
 944  *                JB_ERR_MEMORY on out of memory
 945  *
 946  *********************************************************************/
 947 jb_err edit_write_file(struct editable_file * file)
 948 {
 949    FILE * fp;
 950    struct file_line * cur_line;
 951    struct stat statbuf[1];
 952    char version_buf[22]; /* 22 = ceil(log10(2^64)) + 2 = max number of
 953                             digits in time_t, assuming this is a 64-bit
 954                             machine, plus null terminator, plus one
 955                             for paranoia */
 956
 957    assert(file);
 958    assert(file->filename);
 959
 960    if (NULL == (fp = fopen(file->filename, "wb")))
 961    {
 962       return JB_ERR_FILE;
 963    }
 964
 965    cur_line = file->lines;
 966    while (cur_line != NULL)
 967    {
 968       if (cur_line->raw)
 969       {
 970          if (fputs(cur_line->raw, fp) < 0)
 971          {
 972             fclose(fp);
 973             return JB_ERR_FILE;
 974          }
 975       }
 976       else
 977       {
 978          if (cur_line->prefix)
 979          {
 980             if (fputs(cur_line->prefix, fp) < 0)
 981             {
 982                fclose(fp);
 983                return JB_ERR_FILE;
 984             }
 985          }
 986          if (cur_line->unprocessed)
 987          {
 988
 989             if (NULL != strchr(cur_line->unprocessed, '#'))
 990             {
 991                /* Must quote '#' characters */
 992                int numhash = 0;
 993                int len;
 994                char * src;
 995                char * dest;
 996                char * str;
 997
 998                /* Count number of # characters, so we know length of output string */
 999                src = cur_line->unprocessed;
1000                while (NULL != (src = strchr(src, '#')))
1001                {
1002                   numhash++;
1003                   src++;
1004                }
1005                assert(numhash > 0);
1006
1007                /* Allocate new memory for string */
1008                len = strlen(cur_line->unprocessed);
1009                if (NULL == (str = malloc((size_t) len + 1 + numhash)))
1010                {
1011                   /* Uh oh, just trashed file! */
1012                   fclose(fp);
1013                   return JB_ERR_MEMORY;
1014                }
1015
1016                /* Loop through string from end */
1017                src  = cur_line->unprocessed + len;
1018                dest = str + len + numhash;
1019                for ( ; len >= 0; len--)
1020                {
1021                   if ((*dest-- = *src--) == '#')
1022                   {
1023                      *dest-- = '\\';
1024                      numhash--;
1025                      assert(numhash >= 0);
1026                   }
1027                }
1028                assert(numhash == 0);
1029                assert(src  + 1 == cur_line->unprocessed);
1030                assert(dest + 1 == str);
1031
1032                if (fputs(str, fp) < 0)
1033                {
1034                   free(str);
1035                   fclose(fp);
1036                   return JB_ERR_FILE;
1037                }
1038
1039                free(str);
1040             }
1041             else
1042             {
1043                /* Can write without quoting '#' characters. */
1044                if (fputs(cur_line->unprocessed, fp) < 0)
1045                {
1046                   fclose(fp);
1047                   return JB_ERR_FILE;
1048                }
1049             }
1050             if (fputs(NEWLINE(file->newline), fp) < 0)
1051             {
1052                fclose(fp);
1053                return JB_ERR_FILE;
1054             }
1055          }
1056          else
1057          {
1058             /* FIXME: Write data from file->data->whatever */
1059             assert(0);
1060          }
1061       }
1062       cur_line = cur_line->next;
1063    }
1064
1065    fclose(fp);
1066
1067
1068    /* Update the version stamp in the file structure, since we just
1069     * wrote to the file & changed it's date.
1070     */
1071    if (stat(file->filename, statbuf) < 0)
1072    {
1073       /* Error, probably file not found. */
1074       return JB_ERR_FILE;
1075    }
1076    file->version = (unsigned)statbuf->st_mtime;
1077
1078    /* Correct file->version_str */
1079    freez(file->version_str);
1080    snprintf(version_buf, 22, "%u", file->version);
1081    version_buf[21] = '\0';
1082    file->version_str = strdup(version_buf);
1083    if (version_buf == NULL)
1084    {
1085       return JB_ERR_MEMORY;
1086    }
1087
1088    return JB_ERR_OK;
1089 }
1090
1091
1092 /*********************************************************************
1093  *
1094  * Function    :  edit_free_file
1095  *
1096  * Description :  Free a complete file in memory.
1097  *
1098  * Parameters  :
1099  *          1  :  file = Data structure to free.
1100  *
1101  * Returns     :  N/A
1102  *
1103  *********************************************************************/
1104 void edit_free_file(struct editable_file * file)
1105 {
1106    if (!file)
1107    {
1108       /* Silently ignore NULL pointer */
1109       return;
1110    }
1111
1112    edit_free_file_lines(file->lines);
1113    freez(file->filename);
1114    freez(file->identifier);
1115    freez(file->version_str);
1116    file->version = 0;
1117    file->parse_error_text = NULL; /* Statically allocated */
1118    file->parse_error = NULL;
1119
1120    free(file);
1121 }
1122
1123
1124 /*********************************************************************
1125  *
1126  * Function    :  edit_free_file_lines
1127  *
1128  * Description :  Free an entire linked list of file lines.
1129  *
1130  * Parameters  :
1131  *          1  :  first_line = Data structure to free.
1132  *
1133  * Returns     :  N/A
1134  *
1135  *********************************************************************/
1136 static void edit_free_file_lines(struct file_line * first_line)
1137 {
1138    struct file_line * next_line;
1139
1140    while (first_line != NULL)
1141    {
1142       next_line = first_line->next;
1143       first_line->next = NULL;
1144       freez(first_line->raw);
1145       freez(first_line->prefix);
1146       freez(first_line->unprocessed);
1147       switch(first_line->type)
1148       {
1149          case 0: /* special case if memory zeroed */
1150          case FILE_LINE_UNPROCESSED:
1151          case FILE_LINE_BLANK:
1152          case FILE_LINE_ALIAS_HEADER:
1153          case FILE_LINE_SETTINGS_HEADER:
1154          case FILE_LINE_DESCRIPTION_HEADER:
1155          case FILE_LINE_DESCRIPTION_ENTRY:
1156          case FILE_LINE_ALIAS_ENTRY:
1157          case FILE_LINE_URL:
1158             /* No data is stored for these */
1159             break;
1160
1161          case FILE_LINE_ACTION:
1162             free_action(first_line->data.action);
1163             break;
1164
1165          case FILE_LINE_SETTINGS_ENTRY:
1166             freez(first_line->data.setting.name);
1167             freez(first_line->data.setting.svalue);
1168             break;
1169          default:
1170             /* Should never happen */
1171             assert(0);
1172             break;
1173       }
1174       first_line->type = 0; /* paranoia */
1175       free(first_line);
1176       first_line = next_line;
1177    }
1178 }
1179
1180
1181 /*********************************************************************
1182  *
1183  * Function    :  match_actions_file_header_line
1184  *
1185  * Description :  Match an actions file {{header}} line
1186  *
1187  * Parameters  :
1188  *          1  :  line = String from file
1189  *          2  :  name = Header to match against
1190  *
1191  * Returns     :  0 iff they match.
1192  *
1193  *********************************************************************/
1194 static int match_actions_file_header_line(const char * line, const char * name)
1195 {
1196    size_t len;
1197
1198    assert(line);
1199    assert(name);
1200
1201    /* Look for "{{" */
1202    if ((line[0] != '{') || (line[1] != '{'))
1203    {
1204       return 1;
1205    }
1206    line += 2;
1207
1208    /* Look for optional whitespace */
1209    while ( (*line == ' ') || (*line == '\t') )
1210    {
1211       line++;
1212    }
1213
1214    /* Look for the specified name (case-insensitive) */
1215    len = strlen(name);
1216    if (0 != strncmpic(line, name, len))
1217    {
1218       return 1;
1219    }
1220    line += len;
1221
1222    /* Look for optional whitespace */
1223    while ( (*line == ' ') || (*line == '\t') )
1224    {
1225       line++;
1226    }
1227
1228    /* Look for "}}" and end of string*/
1229    if ((line[0] != '}') || (line[1] != '}') || (line[2] != '\0'))
1230    {
1231       return 1;
1232    }
1233
1234    /* It matched!! */
1235    return 0;
1236 }
1237
1238
1239 /*********************************************************************
1240  *
1241  * Function    :  match_actions_file_header_line
1242  *
1243  * Description :  Match an actions file {{header}} line
1244  *
1245  * Parameters  :
1246  *          1  :  line = String from file.  Must not start with
1247  *                       whitespace (else infinite loop!)
1248  *          2  :  pname = Destination for name
1249  *          2  :  pvalue = Destination for value
1250  *
1251  * Returns     :  JB_ERR_OK     on success
1252  *                JB_ERR_MEMORY on out-of-memory
1253  *                JB_ERR_PARSE  if there's no "=" sign, or if there's
1254  *                              nothing before the "=" sign (but empty
1255  *                              values *after* the "=" sign are legal).
1256  *
1257  *********************************************************************/
1258 static jb_err split_line_on_equals(const char * line, char ** pname, char ** pvalue)
1259 {
1260    const char * name_end;
1261    const char * value_start;
1262    size_t name_len;
1263
1264    assert(line);
1265    assert(pname);
1266    assert(pvalue);
1267    assert(*line != ' ');
1268    assert(*line != '\t');
1269
1270    *pname = NULL;
1271    *pvalue = NULL;
1272
1273    value_start = strchr(line, '=');
1274    if ((value_start == NULL) || (value_start == line))
1275    {
1276       return JB_ERR_PARSE;
1277    }
1278
1279    name_end = value_start - 1;
1280
1281    /* Eat any whitespace before the '=' */
1282    while ((*name_end == ' ') || (*name_end == '\t'))
1283    {
1284       /*
1285        * we already know we must have at least 1 non-ws char
1286        * at start of buf - no need to check
1287        */
1288       name_end--;
1289    }
1290
1291    name_len = name_end - line + 1; /* Length excluding \0 */
1292    if (NULL == (*pname = (char *) malloc(name_len + 1)))
1293    {
1294       return JB_ERR_MEMORY;
1295    }
1296    strncpy(*pname, line, name_len);
1297    (*pname)[name_len] = '\0';
1298
1299    /* Eat any the whitespace after the '=' */
1300    value_start++;
1301    while ((*value_start == ' ') || (*value_start == '\t'))
1302    {
1303       value_start++;
1304    }
1305
1306    if (NULL == (*pvalue = strdup(value_start)))
1307    {
1308       free(*pname);
1309       *pname = NULL;
1310       return JB_ERR_MEMORY;
1311    }
1312
1313    return JB_ERR_OK;
1314 }
1315
1316
1317 /*********************************************************************
1318  *
1319  * Function    :  edit_parse_actions_file
1320  *
1321  * Description :  Parse an actions file in memory.
1322  *
1323  *                Passed linked list must have the "data" member
1324  *                zeroed, and must contain valid "next" and
1325  *                "unprocessed" fields.  The "raw" and "prefix"
1326  *                fields are ignored, and "type" is just overwritten.
1327  *
1328  *                Note that on error the file may have been
1329  *                partially parsed.
1330  *
1331  * Parameters  :
1332  *          1  :  file = Actions file to be parsed in-place.
1333  *
1334  * Returns     :  JB_ERR_OK     on success
1335  *                JB_ERR_MEMORY on out-of-memory
1336  *                JB_ERR_PARSE  on error
1337  *
1338  *********************************************************************/
1339 jb_err edit_parse_actions_file(struct editable_file * file)
1340 {
1341    struct file_line * cur_line;
1342    size_t len;
1343    const char * text; /* Text from a line */
1344    char * name;  /* For lines of the form name=value */
1345    char * value; /* For lines of the form name=value */
1346    struct action_alias * alias_list = NULL;
1347    jb_err err = JB_ERR_OK;
1348
1349    /* alias_list contains the aliases defined in this file.
1350     * It might be better to use the "file_line.data" fields
1351     * in the relavent places instead.
1352     */
1353
1354    cur_line = file->lines;
1355
1356    /* A note about blank line support: Blank lines should only
1357     * ever occur as the last line in the file.  This function
1358     * is more forgiving than that - FILE_LINE_BLANK can occur
1359     * anywhere.
1360     */
1361
1362    /* Skip leading blanks.  Should only happen if file is
1363     * empty (which is valid, but pointless).
1364     */
1365    while ( (cur_line != NULL)
1366         && (cur_line->unprocessed[0] == '\0') )
1367    {
1368       /* Blank line */
1369       cur_line->type = FILE_LINE_BLANK;
1370       cur_line = cur_line->next;
1371    }
1372
1373    if ( (cur_line != NULL)
1374      && (cur_line->unprocessed[0] != '{') )
1375    {
1376       /* File doesn't start with a header */
1377       file->parse_error = cur_line;
1378       file->parse_error_text = "First (non-comment) line of the file must contain a header.";
1379       return JB_ERR_PARSE;
1380    }
1381
1382    if ( (cur_line != NULL) && (0 ==
1383       match_actions_file_header_line(cur_line->unprocessed, "settings") ) )
1384    {
1385       cur_line->type = FILE_LINE_SETTINGS_HEADER;
1386
1387       cur_line = cur_line->next;
1388       while ((cur_line != NULL) && (cur_line->unprocessed[0] != '{'))
1389       {
1390          if (cur_line->unprocessed[0])
1391          {
1392             cur_line->type = FILE_LINE_SETTINGS_ENTRY;
1393
1394             err = split_line_on_equals(cur_line->unprocessed,
1395                      &cur_line->data.setting.name,
1396                      &cur_line->data.setting.svalue);
1397             if (err == JB_ERR_MEMORY)
1398             {
1399                return err;
1400             }
1401             else if (err != JB_ERR_OK)
1402             {
1403                /* Line does not contain a name=value pair */
1404                file->parse_error = cur_line;
1405                file->parse_error_text = "Expected a name=value pair on this {{description}} line, but couldn't find one.";
1406                return JB_ERR_PARSE;
1407             }
1408          }
1409          else
1410          {
1411             cur_line->type = FILE_LINE_BLANK;
1412          }
1413          cur_line = cur_line->next;
1414       }
1415    }
1416
1417    if ( (cur_line != NULL) && (0 ==
1418       match_actions_file_header_line(cur_line->unprocessed, "description") ) )
1419    {
1420       cur_line->type = FILE_LINE_DESCRIPTION_HEADER;
1421
1422       cur_line = cur_line->next;
1423       while ((cur_line != NULL) && (cur_line->unprocessed[0] != '{'))
1424       {
1425          if (cur_line->unprocessed[0])
1426          {
1427             cur_line->type = FILE_LINE_DESCRIPTION_ENTRY;
1428          }
1429          else
1430          {
1431             cur_line->type = FILE_LINE_BLANK;
1432          }
1433          cur_line = cur_line->next;
1434       }
1435    }
1436
1437    if ( (cur_line != NULL) && (0 ==
1438       match_actions_file_header_line(cur_line->unprocessed, "alias") ) )
1439    {
1440       cur_line->type = FILE_LINE_ALIAS_HEADER;
1441
1442       cur_line = cur_line->next;
1443       while ((cur_line != NULL) && (cur_line->unprocessed[0] != '{'))
1444       {
1445          if (cur_line->unprocessed[0])
1446          {
1447             /* define an alias */
1448             struct action_alias * new_alias;
1449
1450             cur_line->type = FILE_LINE_ALIAS_ENTRY;
1451
1452             err = split_line_on_equals(cur_line->unprocessed, &name, &value);
1453             if (err == JB_ERR_MEMORY)
1454             {
1455                return err;
1456             }
1457             else if (err != JB_ERR_OK)
1458             {
1459                /* Line does not contain a name=value pair */
1460                file->parse_error = cur_line;
1461                file->parse_error_text = "Expected a name=value pair on this {{alias}} line, but couldn't find one.";
1462                return JB_ERR_PARSE;
1463             }
1464
1465             if ((new_alias = zalloc(sizeof(*new_alias))) == NULL)
1466             {
1467                /* Out of memory */
1468                free(name);
1469                free(value);
1470                free_alias_list(alias_list);
1471                return JB_ERR_MEMORY;
1472             }
1473
1474             err = get_actions(value, alias_list, new_alias->action);
1475             if (err)
1476             {
1477                /* Invalid action or out of memory */
1478                free(name);
1479                free(value);
1480                free(new_alias);
1481                free_alias_list(alias_list);
1482                if (err == JB_ERR_MEMORY)
1483                {
1484                   return err;
1485                }
1486                else
1487                {
1488                   /* Line does not contain a name=value pair */
1489                   file->parse_error = cur_line;
1490                   file->parse_error_text = "This alias does not specify a valid set of actions.";
1491                   return JB_ERR_PARSE;
1492                }
1493             }
1494
1495             free(value);
1496
1497             new_alias->name = name;
1498
1499             /* add to list */
1500             new_alias->next = alias_list;
1501             alias_list = new_alias;
1502          }
1503          else
1504          {
1505             cur_line->type = FILE_LINE_BLANK;
1506          }
1507          cur_line = cur_line->next;
1508       }
1509    }
1510
1511    /* Header done, process the main part of the file */
1512    while (cur_line != NULL)
1513    {
1514       /* At this point, (cur_line->unprocessed[0] == '{') */
1515       assert(cur_line->unprocessed[0] == '{');
1516       text = cur_line->unprocessed + 1;
1517       len = strlen(text) - 1;
1518       if (text[len] != '}')
1519       {
1520          /* No closing } on header */
1521          free_alias_list(alias_list);
1522          file->parse_error = cur_line;
1523          file->parse_error_text = "Headers starting with '{' must have a "
1524             "closing bracket ('}').  Headers starting with two brackets ('{{') "
1525             "must close with two brackets ('}}').";
1526          return JB_ERR_PARSE;
1527       }
1528
1529       if (text[0] == '{')
1530       {
1531          /* An invalid {{ header.  */
1532          free_alias_list(alias_list);
1533          file->parse_error = cur_line;
1534          file->parse_error_text = "Unknown or unexpected two-bracket header.  "
1535             "Please remember that the system (two-bracket) headers must "
1536             "appear in the order {{settings}}, {{description}}, {{alias}}, "
1537             "and must appear before any actions (one-bracket) headers.  "
1538             "Also note that system headers may not be repeated.";
1539          return JB_ERR_PARSE;
1540       }
1541
1542       while ( (*text == ' ') || (*text == '\t') )
1543       {
1544          text++;
1545          len--;
1546       }
1547       while ( (len > 0)
1548            && ( (text[len - 1] == ' ')
1549              || (text[len - 1] == '\t') ) )
1550       {
1551          len--;
1552       }
1553
1554       cur_line->type = FILE_LINE_ACTION;
1555
1556       /* Remove {} and make copy */
1557       if (NULL == (value = (char *) malloc(len + 1)))
1558       {
1559          /* Out of memory */
1560          free_alias_list(alias_list);
1561          return JB_ERR_MEMORY;
1562       }
1563       strncpy(value, text, len);
1564       value[len] = '\0';
1565
1566       /* Get actions */
1567       err = get_actions(value, alias_list, cur_line->data.action);
1568       if (err)
1569       {
1570          /* Invalid action or out of memory */
1571          free(value);
1572          free_alias_list(alias_list);
1573          if (err == JB_ERR_MEMORY)
1574          {
1575             return err;
1576          }
1577          else
1578          {
1579             /* Line does not contain a name=value pair */
1580             file->parse_error = cur_line;
1581             file->parse_error_text = "This header does not specify a valid set of actions.";
1582             return JB_ERR_PARSE;
1583          }
1584       }
1585
1586       /* Done with string - it was clobbered anyway */
1587       free(value);
1588
1589       /* Process next line */
1590       cur_line = cur_line->next;
1591
1592       /* Loop processing URL patterns */
1593       while ((cur_line != NULL) && (cur_line->unprocessed[0] != '{'))
1594       {
1595          if (cur_line->unprocessed[0])
1596          {
1597             /* Could parse URL here, but this isn't currently needed */
1598
1599             cur_line->type = FILE_LINE_URL;
1600          }
1601          else
1602          {
1603             cur_line->type = FILE_LINE_BLANK;
1604          }
1605          cur_line = cur_line->next;
1606       }
1607    } /* End main while(cur_line != NULL) loop */
1608
1609    free_alias_list(alias_list);
1610
1611    return JB_ERR_OK;
1612 }
1613
1614
1615 /*********************************************************************
1616  *
1617  * Function    :  edit_read_file_lines
1618  *
1619  * Description :  Read all the lines of a file into memory.
1620  *                Handles whitespace, comments and line continuation.
1621  *
1622  * Parameters  :
1623  *          1  :  fp = File to read from.  On return, this will be
1624  *                     at EOF but it will not have been closed.
1625  *          2  :  pfile = Destination for a linked list of file_lines.
1626  *                        Will be set to NULL on error.
1627  *          3  :  newline = How to handle newlines.
1628  *
1629  * Returns     :  JB_ERR_OK     on success
1630  *                JB_ERR_MEMORY on out-of-memory
1631  *
1632  *********************************************************************/
1633 jb_err edit_read_file_lines(FILE *fp, struct file_line ** pfile, int *newline)
1634 {
1635    struct file_line * first_line; /* Keep for return value or to free */
1636    struct file_line * cur_line;   /* Current line */
1637    struct file_line * prev_line;  /* Entry with prev_line->next = cur_line */
1638    jb_err rval;
1639
1640    assert(fp);
1641    assert(pfile);
1642
1643    *pfile = NULL;
1644
1645    cur_line = first_line = zalloc(sizeof(struct file_line));
1646    if (cur_line == NULL)
1647    {
1648       return JB_ERR_MEMORY;
1649    }
1650
1651    cur_line->type = FILE_LINE_UNPROCESSED;
1652
1653    rval = edit_read_line(fp, &cur_line->raw, &cur_line->prefix, &cur_line->unprocessed, newline, NULL);
1654    if (rval)
1655    {
1656       /* Out of memory or empty file. */
1657       /* Note that empty file is not an error we propogate up */
1658       free(cur_line);
1659       return ((rval == JB_ERR_FILE) ? JB_ERR_OK : rval);
1660    }
1661
1662    do
1663    {
1664       prev_line = cur_line;
1665       cur_line = prev_line->next = zalloc(sizeof(struct file_line));
1666       if (cur_line == NULL)
1667       {
1668          /* Out of memory */
1669          edit_free_file_lines(first_line);
1670          return JB_ERR_MEMORY;
1671       }
1672
1673       cur_line->type = FILE_LINE_UNPROCESSED;
1674
1675       rval = edit_read_line(fp, &cur_line->raw, &cur_line->prefix, &cur_line->unprocessed, newline, NULL);
1676       if ((rval != JB_ERR_OK) && (rval != JB_ERR_FILE))
1677       {
1678          /* Out of memory */
1679          edit_free_file_lines(first_line);
1680          return JB_ERR_MEMORY;
1681       }
1682
1683    }
1684    while (rval != JB_ERR_FILE);
1685
1686    /* EOF */
1687
1688    /* We allocated one too many - free it */
1689    prev_line->next = NULL;
1690    free(cur_line);
1691
1692    *pfile = first_line;
1693    return JB_ERR_OK;
1694 }
1695
1696
1697 /*********************************************************************
1698  *
1699  * Function    :  edit_read_file
1700  *
1701  * Description :  Read a complete file into memory.
1702  *                Handles CGI parameter parsing.  If requested, also
1703  *                checks the file's modification timestamp.
1704  *
1705  * Parameters  :
1706  *          1  :  csp = Current client state (buffers, headers, etc...)
1707  *          2  :  parameters = map of cgi parameters.
1708  *          3  :  require_version = true to check "ver" parameter.
1709  *          4  :  suffix = File extension, e.g. ".action".
1710  *          5  :  pfile = Destination for the file.  Will be set
1711  *                        to NULL on error.
1712  *
1713  * CGI Parameters :
1714  *    filename :  The name of the file to read, without the
1715  *                path or ".action" extension.
1716  *         ver :  (Only if require_version is nonzero)
1717  *                Timestamp of the actions file.  If wrong, this
1718  *                function fails with JB_ERR_MODIFIED.
1719  *
1720  * Returns     :  JB_ERR_OK     on success
1721  *                JB_ERR_MEMORY on out-of-memory
1722  *                JB_ERR_CGI_PARAMS if "filename" was not specified
1723  *                                  or is not valid.
1724  *                JB_ERR_FILE   if the file cannot be opened or
1725  *                              contains no data
1726  *                JB_ERR_MODIFIED if version checking was requested and
1727  *                                failed - the file was modified outside
1728  *                                of this CGI editor instance.
1729  *
1730  *********************************************************************/
1731 jb_err edit_read_file(struct client_state *csp,
1732                       const struct map *parameters,
1733                       int require_version,
1734                       const char *suffix,
1735                       struct editable_file **pfile)
1736 {
1737    struct file_line * lines;
1738    FILE * fp;
1739    jb_err err;
1740    char * filename;
1741    const char * identifier;
1742    struct editable_file * file;
1743    unsigned version = 0;
1744    struct stat statbuf[1];
1745    char version_buf[22];
1746    int newline = NEWLINE_UNKNOWN;
1747
1748    assert(csp);
1749    assert(parameters);
1750    assert(pfile);
1751
1752    *pfile = NULL;
1753
1754    err = get_file_name_param(csp, parameters, "f", suffix,
1755                              &filename, &identifier);
1756    if (err)
1757    {
1758       return err;
1759    }
1760
1761    if (stat(filename, statbuf) < 0)
1762    {
1763       /* Error, probably file not found. */
1764       free(filename);
1765       return JB_ERR_FILE;
1766    }
1767    version = (unsigned) statbuf->st_mtime;
1768
1769    if (require_version)
1770    {
1771       unsigned specified_version;
1772       err = get_number_param(csp, parameters, "v", &specified_version);
1773       if (err)
1774       {
1775          free(filename);
1776          return err;
1777       }
1778
1779       if (version != specified_version)
1780       {
1781          return JB_ERR_MODIFIED;
1782       }
1783    }
1784
1785    if (NULL == (fp = fopen(filename,"rb")))
1786    {
1787       free(filename);
1788       return JB_ERR_FILE;
1789    }
1790
1791    err = edit_read_file_lines(fp, &lines, &newline);
1792
1793    fclose(fp);
1794
1795    if (err)
1796    {
1797       free(filename);
1798       return err;
1799    }
1800
1801    file = (struct editable_file *) zalloc(sizeof(*file));
1802    if (err)
1803    {
1804       free(filename);
1805       edit_free_file_lines(lines);
1806       return err;
1807    }
1808
1809    file->lines = lines;
1810    file->newline = newline;
1811    file->filename = filename;
1812    file->version = version;
1813    file->identifier = url_encode(identifier);
1814
1815    if (file->identifier == NULL)
1816    {
1817       edit_free_file(file);
1818       return JB_ERR_MEMORY;
1819    }
1820
1821    /* Correct file->version_str */
1822    freez(file->version_str);
1823    snprintf(version_buf, 22, "%u", file->version);
1824    version_buf[21] = '\0';
1825    file->version_str = strdup(version_buf);
1826    if (version_buf == NULL)
1827    {
1828       edit_free_file(file);
1829       return JB_ERR_MEMORY;
1830    }
1831
1832    *pfile = file;
1833    return JB_ERR_OK;
1834 }
1835
1836
1837 /*********************************************************************
1838  *
1839  * Function    :  edit_read_actions_file
1840  *
1841  * Description :  Read a complete actions file into memory.
1842  *                Handles CGI parameter parsing.  If requested, also
1843  *                checks the file's modification timestamp.
1844  *
1845  *                If this function detects an error in the categories
1846  *                JB_ERR_FILE, JB_ERR_MODIFIED, or JB_ERR_PARSE,
1847  *                then it handles it by filling in the specified
1848  *                response structure and returning JB_ERR_FILE.
1849  *
1850  * Parameters  :
1851  *          1  :  csp = Current client state (buffers, headers, etc...)
1852  *          2  :  rsp = HTTP response.  Only filled in on error.
1853  *          2  :  parameters = map of cgi parameters.
1854  *          3  :  require_version = true to check "ver" parameter.
1855  *          4  :  pfile = Destination for the file.  Will be set
1856  *                        to NULL on error.
1857  *
1858  * CGI Parameters :
1859  *    filename :  The name of the actions file to read, without the
1860  *                path or ".action" extension.
1861  *         ver :  (Only if require_version is nonzero)
1862  *                Timestamp of the actions file.  If wrong, this
1863  *                function fails with JB_ERR_MODIFIED.
1864  *
1865  * Returns     :  JB_ERR_OK     on success
1866  *                JB_ERR_MEMORY on out-of-memory
1867  *                JB_ERR_CGI_PARAMS if "filename" was not specified
1868  *                                  or is not valid.
1869  *                JB_ERR_FILE  if the file does not contain valid data,
1870  *                             or if file cannot be opened or
1871  *                             contains no data, or if version
1872  *                             checking was requested and failed.
1873  *
1874  *********************************************************************/
1875 jb_err edit_read_actions_file(struct client_state *csp,
1876                               struct http_response *rsp,
1877                               const struct map *parameters,
1878                               int require_version,
1879                               struct editable_file **pfile)
1880 {
1881    jb_err err;
1882    struct editable_file *file;
1883
1884    assert(csp);
1885    assert(parameters);
1886    assert(pfile);
1887
1888    *pfile = NULL;
1889
1890    err = edit_read_file(csp, parameters, require_version, ".action", &file);
1891    if (err)
1892    {
1893       /* Try to handle if possible */
1894       if (err == JB_ERR_FILE)
1895       {
1896          err = cgi_error_file(csp, rsp, lookup(parameters, "f"));
1897       }
1898       else if (err == JB_ERR_MODIFIED)
1899       {
1900          err = cgi_error_modified(csp, rsp, lookup(parameters, "f"));
1901       }
1902       if (err == JB_ERR_OK)
1903       {
1904          /*
1905           * Signal to higher-level CGI code that there was a problem but we
1906           * handled it, they should just return JB_ERR_OK.
1907           */
1908          err = JB_ERR_FILE;
1909       }
1910       return err;
1911    }
1912
1913    err = edit_parse_actions_file(file);
1914    if (err)
1915    {
1916       if (err == JB_ERR_PARSE)
1917       {
1918          err = cgi_error_parse(csp, rsp, file);
1919          if (err == JB_ERR_OK)
1920          {
1921             /*
1922              * Signal to higher-level CGI code that there was a problem but we
1923              * handled it, they should just return JB_ERR_OK.
1924              */
1925             err = JB_ERR_FILE;
1926          }
1927       }
1928       edit_free_file(file);
1929       return err;
1930    }
1931
1932    *pfile = file;
1933    return JB_ERR_OK;
1934 }
1935
1936
1937 /*********************************************************************
1938  *
1939  * Function    :  get_file_name_param
1940  *
1941  * Description :  Get the name of the file to edit from the parameters
1942  *                passed to a CGI function.  This function handles
1943  *                security checks such as blocking urls containing
1944  *                "/" or ".", prepending the config file directory,
1945  *                and adding the specified suffix.
1946  *
1947  *                (This is an essential security check, otherwise
1948  *                users may be able to pass "../../../etc/passwd"
1949  *                and overwrite the password file [linux], "prn:"
1950  *                and print random data [Windows], etc...)
1951  *
1952  *                This function only allows filenames contining the
1953  *                characters '-', '_', 'A'-'Z', 'a'-'z', and '0'-'9'.
1954  *                That's probably too restrictive but at least it's
1955  *                secure.
1956  *
1957  * Parameters  :
1958  *          1  :  csp = Current client state (buffers, headers, etc...)
1959  *          2  :  parameters = map of cgi parameters
1960  *          3  :  param_name = The name of the parameter to read
1961  *          4  :  suffix = File extension, e.g. ".actions"
1962  *          5  :  pfilename = destination for full filename.  Caller
1963  *                free()s.  Set to NULL on error.
1964  *          6  :  pparam = destination for partial filename,
1965  *                suitable for use in another URL.  Allocated as part
1966  *                of the map "parameters", so don't free it.
1967  *                Set to NULL if not specified.
1968  *
1969  * Returns     :  JB_ERR_OK         on success
1970  *                JB_ERR_MEMORY     on out-of-memory
1971  *                JB_ERR_CGI_PARAMS if "filename" was not specified
1972  *                                  or is not valid.
1973  *
1974  *********************************************************************/
1975 static jb_err get_file_name_param(struct client_state *csp,
1976                                   const struct map *parameters,
1977                                   const char *param_name,
1978                                   const char *suffix,
1979                                   char **pfilename,
1980                                   const char **pparam)
1981 {
1982    const char *param;
1983    const char *s;
1984    char *name;
1985    char *fullpath;
1986    char ch;
1987    int len;
1988
1989    assert(csp);
1990    assert(parameters);
1991    assert(suffix);
1992    assert(pfilename);
1993    assert(pparam);
1994
1995    *pfilename = NULL;
1996    *pparam = NULL;
1997
1998    param = lookup(parameters, param_name);
1999    if (!*param)
2000    {
2001       return JB_ERR_CGI_PARAMS;
2002    }
2003
2004    *pparam = param;
2005
2006    len = strlen(param);
2007    if (len >= FILENAME_MAX)
2008    {
2009       /* Too long. */
2010       return JB_ERR_CGI_PARAMS;
2011    }
2012
2013    /* Check every character to see if it's legal */
2014    s = param;
2015    while ((ch = *s++) != '\0')
2016    {
2017       if ( ((ch < 'A') || (ch > 'Z'))
2018         && ((ch < 'a') || (ch > 'z'))
2019         && ((ch < '0') || (ch > '9'))
2020         && (ch != '-')
2021         && (ch != '_') )
2022       {
2023          /* Probable hack attempt. */
2024          return JB_ERR_CGI_PARAMS;
2025       }
2026    }
2027
2028    /* Append extension */
2029    name = malloc(len + strlen(suffix) + 1);
2030    if (name == NULL)
2031    {
2032       return JB_ERR_MEMORY;
2033    }
2034    strcpy(name, param);
2035    strcpy(name + len, suffix);
2036
2037    /* Prepend path */
2038    fullpath = make_path(csp->config->confdir, name);
2039    free(name);
2040
2041    if (fullpath == NULL)
2042    {
2043       return JB_ERR_MEMORY;
2044    }
2045
2046    /* Success */
2047    *pfilename = fullpath;
2048
2049    return JB_ERR_OK;
2050 }
2051
2052
2053 /*********************************************************************
2054  *
2055  * Function    :  get_url_spec_param
2056  *
2057  * Description :  Get a URL pattern from the parameters
2058  *                passed to a CGI function.  Removes leading/trailing
2059  *                spaces and validates it.
2060  *
2061  * Parameters  :
2062  *          1  :  csp = Current client state (buffers, headers, etc...)
2063  *          2  :  parameters = map of cgi parameters
2064  *          3  :  name = Name of CGI parameter to read
2065  *          4  :  pvalue = destination for value.  Will be malloc()'d.
2066  *                         Set to NULL on error.
2067  *
2068  * Returns     :  JB_ERR_OK         on success
2069  *                JB_ERR_MEMORY     on out-of-memory
2070  *                JB_ERR_CGI_PARAMS if the parameter was not specified
2071  *                                  or is not valid.
2072  *
2073  *********************************************************************/
2074 static jb_err get_url_spec_param(struct client_state *csp,
2075                                  const struct map *parameters,
2076                                  const char *name,
2077                                  char **pvalue)
2078 {
2079    const char *orig_param;
2080    char *param;
2081    char *s;
2082    struct url_spec compiled[1];
2083    jb_err err;
2084
2085    assert(csp);
2086    assert(parameters);
2087    assert(name);
2088    assert(pvalue);
2089
2090    *pvalue = NULL;
2091
2092    orig_param = lookup(parameters, name);
2093    if (!*orig_param)
2094    {
2095       return JB_ERR_CGI_PARAMS;
2096    }
2097
2098    /* Copy and trim whitespace */
2099    param = strdup(orig_param);
2100    if (param == NULL)
2101    {
2102       return JB_ERR_MEMORY;
2103    }
2104    chomp(param);
2105
2106    /* Must be non-empty, and can't allow 1st character to be '{' */
2107    if (param[0] == '\0' || param[0] == '{')
2108    {
2109       free(param);
2110       return JB_ERR_CGI_PARAMS;
2111    }
2112
2113    /* Check for embedded newlines */
2114    for (s = param; *s != '\0'; s++)
2115    {
2116       if ((*s == '\r') || (*s == '\n'))
2117       {
2118          free(param);
2119          return JB_ERR_CGI_PARAMS;
2120       }
2121    }
2122
2123    /* Check that regex is valid */
2124    s = strdup(param);
2125    if (s == NULL)
2126    {
2127       free(param);
2128       return JB_ERR_MEMORY;
2129    }
2130    err = create_url_spec(compiled, s);
2131    free(s);
2132    if (err)
2133    {
2134       free(param);
2135       return (err == JB_ERR_MEMORY) ? JB_ERR_MEMORY : JB_ERR_CGI_PARAMS;
2136    }
2137    free_url_spec(compiled);
2138
2139    if (param[strlen(param) - 1] == '\\')
2140    {
2141       /*
2142        * Must protect trailing '\\' from becoming line continuation character.
2143        * Two methods: 1) If it's a domain only, add a trailing '/'.
2144        * 2) For path, add the do-nothing PCRE expression (?:) to the end
2145        */
2146       if (strchr(param, '/') == NULL)
2147       {
2148          err = string_append(&param, "/");
2149       }
2150       else
2151       {
2152          err = string_append(&param, "(?:)");
2153       }
2154       if (err)
2155       {
2156          return err;
2157       }
2158
2159       /* Check that the modified regex is valid */
2160       s = strdup(param);
2161       if (s == NULL)
2162       {
2163          free(param);
2164          return JB_ERR_MEMORY;
2165       }
2166       err = create_url_spec(compiled, s);
2167       free(s);
2168       if (err)
2169       {
2170          free(param);
2171          return (err == JB_ERR_MEMORY) ? JB_ERR_MEMORY : JB_ERR_CGI_PARAMS;
2172       }
2173       free_url_spec(compiled);
2174    }
2175
2176    *pvalue = param;
2177    return JB_ERR_OK;
2178 }
2179
2180 /*********************************************************************
2181  *
2182  * Function    :  map_radio
2183  *
2184  * Description :  Map a set of radio button values.  E.g. if you have
2185  *                3 radio buttons, declare them as:
2186  *                  <option type="radio" name="xyz" @xyz-a@>
2187  *                  <option type="radio" name="xyz" @xyz-b@>
2188  *                  <option type="radio" name="xyz" @xyz-c@>
2189  *                Then map one of the @xyz-?@ variables to "checked"
2190  *                and all the others to empty by calling:
2191  *                map_radio(exports, "xyz", "abc", sel)
2192  *                Where 'sel' is 'a', 'b', or 'c'.
2193  *
2194  * Parameters  :
2195  *          1  :  exports = Exports map to modify.
2196  *          2  :  optionname = name for map
2197  *          3  :  values = null-terminated list of values;
2198  *          4  :  value = Selected value.
2199  *
2200  * CGI Parameters : None
2201  *
2202  * Returns     :  JB_ERR_OK     on success
2203  *                JB_ERR_MEMORY on out-of-memory
2204  *
2205  *********************************************************************/
2206 static jb_err map_radio(struct map * exports,
2207                         const char * optionname,
2208                         const char * values,
2209                         int value)
2210 {
2211    size_t len;
2212    char * buf;
2213    char * p;
2214    char c;
2215
2216    assert(exports);
2217    assert(optionname);
2218    assert(values);
2219
2220    len = strlen(optionname);
2221    buf = malloc(len + 3);
2222    if (buf == NULL)
2223    {
2224       return JB_ERR_MEMORY;
2225    }
2226
2227    strcpy(buf, optionname);
2228    p = buf + len;
2229    *p++ = '-';
2230    p[1] = '\0';
2231
2232    while ((c = *values++) != '\0')
2233    {
2234       if (c != value)
2235       {
2236          *p = c;
2237          if (map(exports, buf, 1, "", 1))
2238          {
2239             return JB_ERR_MEMORY;
2240          }
2241       }
2242    }
2243
2244    *p = value;
2245    return map(exports, buf, 0, "checked", 1);
2246 }
2247
2248
2249 /*********************************************************************
2250  *
2251  * Function    :  cgi_error_modified
2252  *
2253  * Description :  CGI function that is called when a file is modified
2254  *                outside the CGI editor.
2255  *
2256  * Parameters  :
2257  *          1  :  csp = Current client state (buffers, headers, etc...)
2258  *          2  :  rsp = http_response data structure for output
2259  *          3  :  filename = The file that was modified.
2260  *
2261  * CGI Parameters : none
2262  *
2263  * Returns     :  JB_ERR_OK on success
2264  *                JB_ERR_MEMORY on out-of-memory error.
2265  *
2266  *********************************************************************/
2267 jb_err cgi_error_modified(struct client_state *csp,
2268                           struct http_response *rsp,
2269                           const char *filename)
2270 {
2271    struct map *exports;
2272    jb_err err;
2273
2274    assert(csp);
2275    assert(rsp);
2276    assert(filename);
2277
2278    if (NULL == (exports = default_exports(csp, NULL)))
2279    {
2280       return JB_ERR_MEMORY;
2281    }
2282
2283    err = map(exports, "f", 1, html_encode(filename), 0);
2284    if (err)
2285    {
2286       free_map(exports);
2287       return err;
2288    }
2289
2290    return template_fill_for_cgi(csp, "cgi-error-modified", exports, rsp);
2291 }
2292
2293
2294 /*********************************************************************
2295  *
2296  * Function    :  cgi_error_parse
2297  *
2298  * Description :  CGI function that is called when a file cannot
2299  *                be parsed by the CGI editor.
2300  *
2301  * Parameters  :
2302  *          1  :  csp = Current client state (buffers, headers, etc...)
2303  *          2  :  rsp = http_response data structure for output
2304  *          3  :  file = The file that was modified.
2305  *
2306  * CGI Parameters : none
2307  *
2308  * Returns     :  JB_ERR_OK on success
2309  *                JB_ERR_MEMORY on out-of-memory error.
2310  *
2311  *********************************************************************/
2312 jb_err cgi_error_parse(struct client_state *csp,
2313                        struct http_response *rsp,
2314                        struct editable_file *file)
2315 {
2316    struct map *exports;
2317    jb_err err;
2318    struct file_line *cur_line;
2319
2320    assert(csp);
2321    assert(rsp);
2322    assert(file);
2323
2324    if (NULL == (exports = default_exports(csp, NULL)))
2325    {
2326       return JB_ERR_MEMORY;
2327    }
2328
2329    err = map(exports, "f", 1, file->identifier, 1);
2330    if (!err) err = map(exports, "parse-error", 1, html_encode(file->parse_error_text), 0);
2331
2332    cur_line = file->parse_error;
2333    assert(cur_line);
2334
2335    if (!err) err = map(exports, "line-raw", 1, html_encode(cur_line->raw), 0);
2336    if (!err) err = map(exports, "line-data", 1, html_encode(cur_line->unprocessed), 0);
2337
2338    if (err)
2339    {
2340       free_map(exports);
2341       return err;
2342    }
2343
2344    return template_fill_for_cgi(csp, "cgi-error-parse", exports, rsp);
2345 }
2346
2347
2348 /*********************************************************************
2349  *
2350  * Function    :  cgi_error_file
2351  *
2352  * Description :  CGI function that is called when a file cannot be
2353  *                opened by the CGI editor.
2354  *
2355  * Parameters  :
2356  *          1  :  csp = Current client state (buffers, headers, etc...)
2357  *          2  :  rsp = http_response data structure for output
2358  *          3  :  filename = The file that was modified.
2359  *
2360  * CGI Parameters : none
2361  *
2362  * Returns     :  JB_ERR_OK on success
2363  *                JB_ERR_MEMORY on out-of-memory error.
2364  *
2365  *********************************************************************/
2366 jb_err cgi_error_file(struct client_state *csp,
2367                       struct http_response *rsp,
2368                       const char *filename)
2369 {
2370    struct map *exports;
2371    jb_err err;
2372
2373    assert(csp);
2374    assert(rsp);
2375    assert(filename);
2376
2377    if (NULL == (exports = default_exports(csp, NULL)))
2378    {
2379       return JB_ERR_MEMORY;
2380    }
2381
2382    err = map(exports, "f", 1, html_encode(filename), 0);
2383    if (err)
2384    {
2385       free_map(exports);
2386       return err;
2387    }
2388
2389    return template_fill_for_cgi(csp, "cgi-error-file", exports, rsp);
2390 }
2391
2392
2393 /*********************************************************************
2394  *
2395  * Function    :  cgi_error_file
2396  *
2397  * Description :  CGI function that is called when a file cannot be
2398  *                opened for writing by the CGI editor.
2399  *
2400  * Parameters  :
2401  *          1  :  csp = Current client state (buffers, headers, etc...)
2402  *          2  :  rsp = http_response data structure for output
2403  *          3  :  filename = The file that we can't write to
2404  *
2405  * CGI Parameters : none
2406  *
2407  * Returns     :  JB_ERR_OK on success
2408  *                JB_ERR_MEMORY on out-of-memory error.
2409  *
2410  *********************************************************************/
2411 jb_err cgi_error_file_read_only(struct client_state *csp,
2412                                 struct http_response *rsp,
2413                                 const char *filename)
2414 {
2415    struct map *exports;
2416    jb_err err;
2417
2418    assert(csp);
2419    assert(rsp);
2420    assert(filename);
2421
2422    if (NULL == (exports = default_exports(csp, NULL)))
2423    {
2424       return JB_ERR_MEMORY;
2425    }
2426
2427    err = map(exports, "f", 1, html_encode(filename), 0);
2428    if (err)
2429    {
2430       free_map(exports);
2431       return err;
2432    }
2433
2434    return template_fill_for_cgi(csp, "cgi-error-file-read-only", exports, rsp);
2435 }
2436
2437
2438 /*********************************************************************
2439  *
2440  * Function    :  cgi_edit_actions
2441  *
2442  * Description :  CGI function that allows the user to choose which
2443  *                actions file to edit.
2444  *
2445  * Parameters  :
2446  *          1  :  csp = Current client state (buffers, headers, etc...)
2447  *          2  :  rsp = http_response data structure for output
2448  *          3  :  parameters = map of cgi parameters
2449  *
2450  * CGI Parameters : None
2451  *
2452  * Returns     :  JB_ERR_OK on success
2453  *                JB_ERR_MEMORY on out-of-memory error
2454  *
2455  *********************************************************************/
2456 jb_err cgi_edit_actions(struct client_state *csp,
2457                         struct http_response *rsp,
2458                         const struct map *parameters)
2459 {
2460
2461    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
2462    {
2463       return cgi_error_disabled(csp, rsp);
2464    }
2465
2466    /* FIXME: Incomplete */
2467
2468    return cgi_redirect(rsp, CGI_PREFIX "edit-actions-list?f=default");
2469
2470 }
2471
2472
2473 /*********************************************************************
2474  *
2475  * Function    :  cgi_edit_actions_list
2476  *
2477  * Description :  CGI function that edits the actions list.
2478  *                FIXME: This function shouldn't FATAL ever.
2479  *                FIXME: This function doesn't check the retval of map()
2480  * Parameters  :
2481  *          1  :  csp = Current client state (buffers, headers, etc...)
2482  *          2  :  rsp = http_response data structure for output
2483  *          3  :  parameters = map of cgi parameters
2484  *
2485  * CGI Parameters : filename
2486  *
2487  * Returns     :  JB_ERR_OK     on success
2488  *                JB_ERR_MEMORY on out-of-memory
2489  *                JB_ERR_FILE   if the file cannot be opened or
2490  *                              contains no data
2491  *                JB_ERR_CGI_PARAMS if "filename" was not specified
2492  *                                  or is not valid.
2493  *
2494  *********************************************************************/
2495 jb_err cgi_edit_actions_list(struct client_state *csp,
2496                              struct http_response *rsp,
2497                              const struct map *parameters)
2498 {
2499    char * section_template;
2500    char * url_template;
2501    char * sections;
2502    char * urls;
2503    char buf[150];
2504    char * s;
2505    struct map * exports;
2506    struct map * section_exports;
2507    struct map * url_exports;
2508    struct editable_file * file;
2509    struct file_line * cur_line;
2510    unsigned line_number = 0;
2511    unsigned prev_section_line_number = ((unsigned) (-1));
2512    int i, url_1_2;
2513    struct file_list * fl;
2514    struct url_actions * b;
2515    char * buttons = NULL;
2516    jb_err err;
2517
2518    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
2519    {
2520       return cgi_error_disabled(csp, rsp);
2521    }
2522
2523    if (NULL == (exports = default_exports(csp, NULL)))
2524    {
2525       return JB_ERR_MEMORY;
2526    }
2527
2528    /* Load actions file */
2529    err = edit_read_actions_file(csp, rsp, parameters, 0, &file);
2530    if (err)
2531    {
2532       /* No filename specified, can't read file, or out of memory. */
2533       return (err == JB_ERR_FILE ? JB_ERR_OK : err);
2534    }
2535
2536    /* Find start of actions in file */
2537    cur_line = file->lines;
2538    line_number = 1;
2539    while ((cur_line != NULL) && (cur_line->type != FILE_LINE_ACTION))
2540    {
2541       cur_line = cur_line->next;
2542       line_number++;
2543    }
2544
2545    /*
2546     * Conventional actions files should have a match all block
2547     * at the start:
2548     * cur_line             = {...global actions...}
2549     * cur_line->next       = /
2550     * cur_line->next->next = {...actions...} or EOF
2551     */
2552    if ( (cur_line != NULL)
2553      && (cur_line->type == FILE_LINE_ACTION)
2554      && (cur_line->next != NULL)
2555      && (cur_line->next->type == FILE_LINE_URL)
2556      && (0 == strcmp(cur_line->next->unprocessed, "/"))
2557      && ( (cur_line->next->next == NULL)
2558        || (cur_line->next->next->type != FILE_LINE_URL)
2559       ) )
2560    {
2561       /*
2562        * Generate string with buttons to set actions for "/" to
2563        * any predefined set of actions (named standard.*, probably
2564        * residing in standard.action).
2565        */
2566
2567       err = template_load(csp, &section_template, "edit-actions-list-button", 0);
2568       if (err)
2569       {
2570          edit_free_file(file);
2571          free_map(exports);
2572          if (err == JB_ERR_FILE)
2573          {
2574             return cgi_error_no_template(csp, rsp, "edit-actions-list-button");
2575          }
2576          return err;
2577       }
2578
2579       err = template_fill(&section_template, exports);
2580       if (err)
2581       {
2582          edit_free_file(file);
2583          free_map(exports);
2584          return err;
2585       }
2586
2587       buttons = strdup("");
2588       for (i = 0; i < MAX_AF_FILES; i++)
2589       {
2590          if (((fl = csp->actions_list[i]) != NULL) && ((b = fl->f) != NULL))
2591          {
2592             for (b = b->next; NULL != b; b = b->next)
2593             {
2594                if (!strncmp(b->url->spec, "standard.", 9) && *(b->url->spec + 9) != '\0')
2595                {
2596                   if (err || (NULL == (section_exports = new_map())))
2597                   {
2598                      freez(buttons);
2599                      free(section_template);
2600                      edit_free_file(file);
2601                      free_map(exports);
2602                      return JB_ERR_MEMORY;
2603                   }
2604
2605                   err = map(section_exports, "button-name", 1, b->url->spec + 9, 1);
2606
2607                   if (err || (NULL == (s = strdup(section_template))))
2608                   {
2609                      free_map(section_exports);
2610                      freez(buttons);
2611                      free(section_template);
2612                      edit_free_file(file);
2613                      free_map(exports);
2614                      return JB_ERR_MEMORY;
2615                   }
2616
2617                   if (!err) err = template_fill(&s, section_exports);
2618                   free_map(section_exports);
2619                   if (!err) err = string_join(&buttons, s);
2620                }
2621             }
2622          }
2623       }
2624       freez(section_template);
2625       if (!err) err = map(exports, "all-urls-buttons", 1, buttons, 0);
2626
2627       /*
2628        * Conventional actions file, supply extra editing help.
2629        * (e.g. don't allow them to make it an unconventional one).
2630        */
2631       if (!err) err = map_conditional(exports, "all-urls-present", 1);
2632
2633       snprintf(buf, 150, "%d", line_number);
2634       if (!err) err = map(exports, "all-urls-s", 1, buf, 1);
2635       snprintf(buf, 150, "%d", line_number + 2);
2636       if (!err) err = map(exports, "all-urls-s-next", 1, buf, 1);
2637       if (!err) err = map(exports, "all-urls-actions", 1,
2638                           actions_to_html(csp, cur_line->data.action), 0);
2639
2640        /* Skip the 2 lines */
2641       cur_line = cur_line->next->next;
2642       line_number += 2;
2643
2644       /*
2645        * Note that prev_section_line_number is NOT set here.
2646        * This is deliberate and not a bug.  It stops a "Move up"
2647        * option appearing on the next section.  Clicking "Move
2648        * up" would make the actions file unconventional, which
2649        * we don't want, so we hide this option.
2650        */
2651    }
2652    else
2653    {
2654       /*
2655        * Non-standard actions file - does not begin with
2656        * the "All URLs" section.
2657        */
2658       if (!err) err = map_conditional(exports, "all-urls-present", 0);
2659    }
2660
2661    /* Set up global exports */
2662
2663    if (!err) err = map(exports, "f", 1, file->identifier, 1);
2664    if (!err) err = map(exports, "v", 1, file->version_str, 1);
2665
2666    /* Discourage private additions to default.action */
2667
2668    if (!err) err = map_conditional(exports, "default-action",
2669                                    (strcmp("default", lookup(parameters, "f")) == 0));
2670    if (err)
2671    {
2672       edit_free_file(file);
2673       free_map(exports);
2674       return err;
2675    }
2676
2677    /* Should do all global exports above this point */
2678
2679    /* Load templates */
2680
2681    err = template_load(csp, &section_template, "edit-actions-list-section", 0);
2682    if (err)
2683    {
2684       edit_free_file(file);
2685       free_map(exports);
2686       if (err == JB_ERR_FILE)
2687       {
2688          return cgi_error_no_template(csp, rsp, "edit-actions-list-section");
2689       }
2690       return err;
2691    }
2692
2693    err = template_load(csp, &url_template, "edit-actions-list-url", 0);
2694    if (err)
2695    {
2696       free(section_template);
2697       edit_free_file(file);
2698       free_map(exports);
2699       if (err == JB_ERR_FILE)
2700       {
2701          return cgi_error_no_template(csp, rsp, "edit-actions-list-url");
2702       }
2703       return err;
2704    }
2705
2706    err = template_fill(&section_template, exports);
2707    if (err)
2708    {
2709       free(url_template);
2710       edit_free_file(file);
2711       free_map(exports);
2712       free(url_template);
2713       return err;
2714    }
2715
2716    err = template_fill(&url_template, exports);
2717    if (err)
2718    {
2719       free(section_template);
2720       edit_free_file(file);
2721       free_map(exports);
2722       return err;
2723    }
2724
2725    if (NULL == (sections = strdup("")))
2726    {
2727       free(section_template);
2728       free(url_template);
2729       edit_free_file(file);
2730       free_map(exports);
2731       return JB_ERR_MEMORY;
2732    }
2733
2734    while ((cur_line != NULL) && (cur_line->type == FILE_LINE_ACTION))
2735    {
2736       if (NULL == (section_exports = new_map()))
2737       {
2738          free(sections);
2739          free(section_template);
2740          free(url_template);
2741          edit_free_file(file);
2742          free_map(exports);
2743          return JB_ERR_MEMORY;
2744       }
2745
2746       snprintf(buf, 150, "%d", line_number);
2747       err = map(section_exports, "s", 1, buf, 1);
2748       if (!err) err = map(section_exports, "actions", 1,
2749                           actions_to_html(csp, cur_line->data.action), 0);
2750
2751       if ( (!err)
2752         && (cur_line->next != NULL)
2753         && (cur_line->next->type == FILE_LINE_URL))
2754       {
2755          /* This section contains at least one URL, don't allow delete */
2756          err = map_block_killer(section_exports, "empty-section");
2757       }
2758       else
2759       {
2760          if (!err) err = map_block_keep(section_exports, "empty-section");
2761       }
2762
2763       if (prev_section_line_number != ((unsigned)(-1)))
2764       {
2765          /* Not last section */
2766          snprintf(buf, 150, "%d", prev_section_line_number);
2767          if (!err) err = map(section_exports, "s-prev", 1, buf, 1);
2768          if (!err) err = map_block_keep(section_exports, "s-prev-exists");
2769       }
2770       else
2771       {
2772          /* Last section */
2773          if (!err) err = map_block_killer(section_exports, "s-prev-exists");
2774       }
2775       prev_section_line_number = line_number;
2776
2777       if (err)
2778       {
2779          free(sections);
2780          free(section_template);
2781          free(url_template);
2782          edit_free_file(file);
2783          free_map(exports);
2784          free_map(section_exports);
2785          return err;
2786       }
2787
2788       /* Should do all section-specific exports above this point */
2789
2790       if (NULL == (urls = strdup("")))
2791       {
2792          free(sections);
2793          free(section_template);
2794          free(url_template);
2795          edit_free_file(file);
2796          free_map(exports);
2797          free_map(section_exports);
2798          return JB_ERR_MEMORY;
2799       }
2800
2801       url_1_2 = 2;
2802
2803       cur_line = cur_line->next;
2804       line_number++;
2805
2806       while ((cur_line != NULL) && (cur_line->type == FILE_LINE_URL))
2807       {
2808          if (NULL == (url_exports = new_map()))
2809          {
2810             free(urls);
2811             free(sections);
2812             free(section_template);
2813             free(url_template);
2814             edit_free_file(file);
2815             free_map(exports);
2816             free_map(section_exports);
2817             return JB_ERR_MEMORY;
2818          }
2819
2820          snprintf(buf, 150, "%d", line_number);
2821          err = map(url_exports, "p", 1, buf, 1);
2822
2823          snprintf(buf, 150, "%d", url_1_2);
2824          if (!err) err = map(url_exports, "url-1-2", 1, buf, 1);
2825
2826          if (!err) err = map(url_exports, "url-html", 1,
2827                              html_encode(cur_line->unprocessed), 0);
2828          if (!err) err = map(url_exports, "url", 1,
2829                              url_encode(cur_line->unprocessed), 0);
2830
2831          if (err)
2832          {
2833             free(urls);
2834             free(sections);
2835             free(section_template);
2836             free(url_template);
2837             edit_free_file(file);
2838             free_map(exports);
2839             free_map(section_exports);
2840             free_map(url_exports);
2841             return err;
2842          }
2843
2844          if (NULL == (s = strdup(url_template)))
2845          {
2846             free(urls);
2847             free(sections);
2848             free(section_template);
2849             free(url_template);
2850             edit_free_file(file);
2851             free_map(exports);
2852             free_map(section_exports);
2853             free_map(url_exports);
2854             return JB_ERR_MEMORY;
2855          }
2856
2857          err = template_fill(&s, section_exports);
2858          if (!err) err = template_fill(&s, url_exports);
2859          if (!err) err = string_append(&urls, s);
2860
2861          free_map(url_exports);
2862          freez(s);
2863
2864          if (err)
2865          {
2866             freez(urls);
2867             free(sections);
2868             free(section_template);
2869             free(url_template);
2870             edit_free_file(file);
2871             free_map(exports);
2872             free_map(section_exports);
2873             return err;
2874          }
2875
2876          url_1_2 = 3 - url_1_2;
2877
2878          cur_line = cur_line->next;
2879          line_number++;
2880       }
2881
2882       err = map(section_exports, "urls", 1, urls, 0);
2883
2884       /* Could also do section-specific exports here, but it wouldn't be as fast */
2885
2886       snprintf(buf, 150, "%d", line_number);
2887       if (!err) err = map(section_exports, "s-next", 1, buf, 1);
2888
2889       if ( (cur_line != NULL)
2890         && (cur_line->type == FILE_LINE_ACTION))
2891       {
2892          /* Not last section */
2893          if (!err) err = map_block_keep(section_exports, "s-next-exists");
2894       }
2895       else
2896       {
2897          /* Last section */
2898          if (!err) err = map_block_killer(section_exports, "s-next-exists");
2899       }
2900
2901       if (err)
2902       {
2903          free(sections);
2904          free(section_template);
2905          free(url_template);
2906          edit_free_file(file);
2907          free_map(exports);
2908          free_map(section_exports);
2909          return err;
2910       }
2911
2912       if (NULL == (s = strdup(section_template)))
2913       {
2914          free(sections);
2915          free(section_template);
2916          free(url_template);
2917          edit_free_file(file);
2918          free_map(exports);
2919          free_map(section_exports);
2920          return JB_ERR_MEMORY;
2921       }
2922
2923       err = template_fill(&s, section_exports);
2924       if (!err) err = string_append(&sections, s);
2925
2926       freez(s);
2927       free_map(section_exports);
2928
2929       if (err)
2930       {
2931          freez(sections);
2932          free(section_template);
2933          free(url_template);
2934          edit_free_file(file);
2935          free_map(exports);
2936          return err;
2937       }
2938    }
2939
2940    edit_free_file(file);
2941    free(section_template);
2942    free(url_template);
2943
2944    err = map(exports, "sections", 1, sections, 0);
2945    if (err)
2946    {
2947       free_map(exports);
2948       return err;
2949    }
2950
2951    /* Could also do global exports here, but it wouldn't be as fast */
2952
2953    return template_fill_for_cgi(csp, "edit-actions-list", exports, rsp);
2954 }
2955
2956
2957 /*********************************************************************
2958  *
2959  * Function    :  cgi_edit_actions_for_url
2960  *
2961  * Description :  CGI function that edits the Actions list.
2962  *
2963  * Parameters  :
2964  *          1  :  csp = Current client state (buffers, headers, etc...)
2965  *          2  :  rsp = http_response data structure for output
2966  *          3  :  parameters = map of cgi parameters
2967  *
2968  * CGI Parameters : None
2969  *
2970  * Returns     :  JB_ERR_OK     on success
2971  *                JB_ERR_MEMORY on out-of-memory
2972  *                JB_ERR_CGI_PARAMS if the CGI parameters are not
2973  *                                  specified or not valid.
2974  *
2975  *********************************************************************/
2976 jb_err cgi_edit_actions_for_url(struct client_state *csp,
2977                                 struct http_response *rsp,
2978                                 const struct map *parameters)
2979 {
2980    struct map * exports;
2981    unsigned sectionid;
2982    struct editable_file * file;
2983    struct file_line * cur_line;
2984    unsigned line_number;
2985    jb_err err;
2986    struct re_filterfile_spec *filter_group;
2987    int i, have_filters = 0;
2988
2989    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
2990    {
2991       return cgi_error_disabled(csp, rsp);
2992    }
2993
2994    err = get_number_param(csp, parameters, "s", &sectionid);
2995    if (err)
2996    {
2997       return err;
2998    }
2999
3000    err = edit_read_actions_file(csp, rsp, parameters, 1, &file);
3001    if (err)
3002    {
3003       /* No filename specified, can't read file, modified, or out of memory. */
3004       return (err == JB_ERR_FILE ? JB_ERR_OK : err);
3005    }
3006
3007    cur_line = file->lines;
3008
3009    for (line_number = 1; (cur_line != NULL) && (line_number < sectionid); line_number++)
3010    {
3011       cur_line = cur_line->next;
3012    }
3013
3014    if ( (cur_line == NULL)
3015      || (line_number != sectionid)
3016      || (sectionid < 1)
3017      || (cur_line->type != FILE_LINE_ACTION))
3018    {
3019       /* Invalid "sectionid" parameter */
3020       edit_free_file(file);
3021       return JB_ERR_CGI_PARAMS;
3022    }
3023
3024    if (NULL == (exports = default_exports(csp, NULL)))
3025    {
3026       edit_free_file(file);
3027       return JB_ERR_MEMORY;
3028    }
3029
3030    err = map(exports, "f", 1, file->identifier, 1);
3031    if (!err) err = map(exports, "v", 1, file->version_str, 1);
3032    if (!err) err = map(exports, "s", 1, url_encode(lookup(parameters, "s")), 0);
3033
3034    if (!err) err = actions_to_radio(exports, cur_line->data.action);
3035
3036    /*
3037     * XXX: Some browsers (at least IE6 and IE7) have an artifical URL
3038     * length limitation and ignore clicks on the Submit buttons if
3039     * the resulting GET URL would be longer than their limit.
3040     *
3041     * In Privoxy 3.0.5 beta the standard edit-actions-for-url template
3042     * reached this limit and action editing stopped working in these
3043     * browsers (BR #1570678).
3044     *
3045     * The config option split-large-forms works around this browser
3046     * bug (HTTP has no URL lenght limitation) by deviding the action
3047     * list form into multiple smaller ones. It means the URLs are shorter
3048     * and work in broken browsers as well, but the user can no longer change
3049     * all actions with one submit.
3050     *
3051     * A better solution would be to switch to POST requests,
3052     * but this will do for now.
3053     */
3054    if(!err && (csp->config->feature_flags & RUNTIME_FEATURE_SPLIT_LARGE_FORMS))
3055    {
3056       /* Generate multiple smaller form by killing the big one. */
3057       err = map_block_killer(exports, "one-form-only");
3058    }
3059    else
3060    {
3061       /* Default: Generate one large form by killing the smaller ones. */
3062       err = map_block_killer(exports, "multiple-forms");
3063    }
3064
3065    for (i = 0; i < MAX_AF_FILES; i++)
3066    {
3067       if ((csp->rlist[i] != NULL) && (csp->rlist[i]->f != NULL))
3068       {
3069          if (!err) err = map_conditional(exports, "any-filters-defined", 1);
3070          have_filters = 1;
3071          break;
3072       }
3073    }
3074
3075    if (err)
3076    {
3077       edit_free_file(file);
3078       free_map(exports);
3079       return err;
3080    }
3081
3082    if (0 == have_filters)
3083       err = map(exports, "filter-params", 1, "", 1);
3084    else
3085    {
3086       /* We have some entries in the filter list */
3087       char * result;
3088       int index = 0;
3089       char * filter_template;
3090
3091       err = template_load(csp, &filter_template, "edit-actions-for-url-filter", 0);
3092       if (err)
3093       {
3094          edit_free_file(file);
3095          free_map(exports);
3096          if (err == JB_ERR_FILE)
3097          {
3098             return cgi_error_no_template(csp, rsp, "edit-actions-for-url-filter");
3099          }
3100          return err;
3101       }
3102
3103       err = template_fill(&filter_template, exports);
3104
3105       result = strdup("");
3106
3107       for (i = 0; i < MAX_AF_FILES; i++)
3108       {
3109          if ((csp->rlist[i] != NULL) && (csp->rlist[i]->f != NULL))
3110          {
3111             filter_group = csp->rlist[i]->f;
3112             for (;(!err) && (filter_group != NULL); filter_group = filter_group->next)
3113             {
3114                char current_mode = 'x';
3115                struct list_entry *filter_name;
3116                char * this_line;
3117                struct map *line_exports;
3118                char number[20];
3119
3120                filter_name = cur_line->data.action->multi_add[ACTION_MULTI_FILTER]->first;
3121                while ((filter_name != NULL)
3122                    && (0 != strcmp(filter_group->name, filter_name->str)))
3123                {
3124                     filter_name = filter_name->next;
3125                }
3126
3127                if (filter_name != NULL)
3128                {
3129                   current_mode = 'y';
3130                }
3131                else
3132                {
3133                   filter_name = cur_line->data.action->multi_remove[ACTION_MULTI_FILTER]->first;
3134                   while ((filter_name != NULL)
3135                       && (0 != strcmp(filter_group->name, filter_name->str)))
3136                   {
3137                        filter_name = filter_name->next;
3138                   }
3139                   if (filter_name != NULL)
3140                   {
3141                      current_mode = 'n';
3142                   }
3143                }
3144
3145                /* Generate a unique serial number */
3146                snprintf(number, sizeof(number), "%x", index++);
3147                number[sizeof(number) - 1] = '\0';
3148
3149                line_exports = new_map();
3150                if (line_exports == NULL)
3151                {
3152                   err = JB_ERR_MEMORY;
3153                   freez(result);
3154                }
3155                else
3156                {
3157                   if (!err) err = map(line_exports, "index", 1, number, 1);
3158                   if (!err) err = map(line_exports, "name",  1, filter_group->name, 1);
3159                   if (!err) err = map(line_exports, "description",  1, filter_group->description, 1);
3160                   if (!err) err = map_radio(line_exports, "this-filter", "ynx", current_mode);
3161
3162                   this_line = NULL;
3163                   if (!err)
3164                   {
3165                      this_line = strdup(filter_template);
3166                      if (this_line == NULL) err = JB_ERR_MEMORY;
3167                   }
3168                   if (!err) err = template_fill(&this_line, line_exports);
3169                   string_join(&result, this_line);
3170
3171                   free_map(line_exports);
3172                }
3173             }
3174          }
3175       }
3176       freez(filter_template);
3177
3178       if (!err)
3179       {
3180          err = map(exports, "filter-params", 1, result, 0);
3181       }
3182       else
3183       {
3184          freez(result);
3185       }
3186    }
3187
3188    if (!err) err = map_radio(exports, "filter-all", "nx",
3189       (cur_line->data.action->multi_remove_all[ACTION_MULTI_FILTER] ? 'n' : 'x'));
3190
3191    edit_free_file(file);
3192
3193    if (err)
3194    {
3195       free_map(exports);
3196       return err;
3197    }
3198
3199    return template_fill_for_cgi(csp, "edit-actions-for-url", exports, rsp);
3200 }
3201
3202
3203 /*********************************************************************
3204  *
3205  * Function    :  cgi_edit_actions_submit
3206  *
3207  * Description :  CGI function that actually edits the Actions list.
3208  *
3209  * Parameters  :
3210  *          1  :  csp = Current client state (buffers, headers, etc...)
3211  *          2  :  rsp = http_response data structure for output
3212  *          3  :  parameters = map of cgi parameters
3213  *
3214  * CGI Parameters : None
3215  *
3216  * Returns     :  JB_ERR_OK     on success
3217  *                JB_ERR_MEMORY on out-of-memory
3218  *                JB_ERR_CGI_PARAMS if the CGI parameters are not
3219  *                                  specified or not valid.
3220  *
3221  *********************************************************************/
3222 jb_err cgi_edit_actions_submit(struct client_state *csp,
3223                                struct http_response *rsp,
3224                                const struct map *parameters)
3225 {
3226    unsigned sectionid;
3227    char * actiontext;
3228    char * newtext;
3229    size_t len;
3230    struct editable_file * file;
3231    struct file_line * cur_line;
3232    unsigned line_number;
3233    char target[1024];
3234    jb_err err;
3235    int index;
3236    const char * action_set_name;
3237    char ch;
3238    struct file_list * fl;
3239    struct url_actions * b;
3240
3241    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
3242    {
3243       return cgi_error_disabled(csp, rsp);
3244    }
3245
3246    err = get_number_param(csp, parameters, "s", &sectionid);
3247    if (err)
3248    {
3249       return err;
3250    }
3251
3252    err = edit_read_actions_file(csp, rsp, parameters, 1, &file);
3253    if (err)
3254    {
3255       /* No filename specified, can't read file, modified, or out of memory. */
3256       return (err == JB_ERR_FILE ? JB_ERR_OK : err);
3257    }
3258
3259    cur_line = file->lines;
3260
3261    for (line_number = 1; (cur_line != NULL) && (line_number < sectionid); line_number++)
3262    {
3263       cur_line = cur_line->next;
3264    }
3265
3266    if ( (cur_line == NULL)
3267      || (line_number != sectionid)
3268      || (sectionid < 1)
3269      || (cur_line->type != FILE_LINE_ACTION))
3270    {
3271       /* Invalid "sectionid" parameter */
3272       edit_free_file(file);
3273       return JB_ERR_CGI_PARAMS;
3274    }
3275
3276    get_string_param(parameters, "p", &action_set_name);
3277    if (action_set_name != NULL)
3278    {
3279       for (index = 0; index < MAX_AF_FILES; index++)
3280       {
3281          if (((fl = csp->actions_list[index]) != NULL) && ((b = fl->f) != NULL))
3282          {
3283             for (b = b->next; NULL != b; b = b->next)
3284             {
3285                if (!strncmp(b->url->spec, "standard.", 9) && !strcmp(b->url->spec + 9, action_set_name))
3286                {
3287                   copy_action(cur_line->data.action, b->action);
3288                   goto found;
3289                }
3290             }
3291          }
3292       }
3293       edit_free_file(file);
3294       return JB_ERR_CGI_PARAMS;
3295
3296       found: ;
3297    }
3298    else
3299    {
3300       err = actions_from_radio(parameters, cur_line->data.action);
3301    }
3302
3303    if(err)
3304    {
3305       /* Out of memory */
3306       edit_free_file(file);
3307       return err;
3308    }
3309
3310    ch = get_char_param(parameters, "filter_all");
3311    if (ch == 'N')
3312    {
3313       list_remove_all(cur_line->data.action->multi_add[ACTION_MULTI_FILTER]);
3314       list_remove_all(cur_line->data.action->multi_remove[ACTION_MULTI_FILTER]);
3315       cur_line->data.action->multi_remove_all[ACTION_MULTI_FILTER] = 1;
3316    }
3317    else if (ch == 'X')
3318    {
3319       cur_line->data.action->multi_remove_all[ACTION_MULTI_FILTER] = 0;
3320    }
3321
3322    for (index = 0; !err; index++)
3323    {
3324       char key_value[30];
3325       char key_name[30];
3326       const char *name;
3327       char value;
3328
3329       /* Generate the keys */
3330       snprintf(key_value, sizeof(key_value), "filter_r%x", index);
3331       key_value[sizeof(key_value) - 1] = '\0';
3332       snprintf(key_name, sizeof(key_name), "filter_n%x", index);
3333       key_name[sizeof(key_name) - 1] = '\0';
3334
3335       err = get_string_param(parameters, key_name, &name);
3336       if (err) break;
3337
3338       if (name == NULL)
3339       {
3340          /* End of list */
3341          break;
3342       }
3343
3344       value = get_char_param(parameters, key_value);
3345       if (value == 'Y')
3346       {
3347          list_remove_item(cur_line->data.action->multi_add[ACTION_MULTI_FILTER], name);
3348          if (!err) err = enlist(cur_line->data.action->multi_add[ACTION_MULTI_FILTER], name);
3349          list_remove_item(cur_line->data.action->multi_remove[ACTION_MULTI_FILTER], name);
3350       }
3351       else if (value == 'N')
3352       {
3353          list_remove_item(cur_line->data.action->multi_add[ACTION_MULTI_FILTER], name);
3354          if (!cur_line->data.action->multi_remove_all[ACTION_MULTI_FILTER])
3355          {
3356             list_remove_item(cur_line->data.action->multi_remove[ACTION_MULTI_FILTER], name);
3357             if (!err) err = enlist(cur_line->data.action->multi_remove[ACTION_MULTI_FILTER], name);
3358          }
3359       }
3360       else if (value == 'X')
3361       {
3362          list_remove_item(cur_line->data.action->multi_add[ACTION_MULTI_FILTER], name);
3363          list_remove_item(cur_line->data.action->multi_remove[ACTION_MULTI_FILTER], name);
3364       }
3365    }
3366
3367    if(err)
3368    {
3369       /* Out of memory */
3370       edit_free_file(file);
3371       return err;
3372    }
3373
3374    if (NULL == (actiontext = actions_to_text(cur_line->data.action)))
3375    {
3376       /* Out of memory */
3377       edit_free_file(file);
3378       return JB_ERR_MEMORY;
3379    }
3380
3381    len = strlen(actiontext);
3382    if (len == 0)
3383    {
3384       /*
3385        * Empty action - must special-case this.
3386        * Simply setting len to 1 is sufficient...
3387        */
3388       len = 1;
3389    }
3390
3391    if (NULL == (newtext = malloc(len + 2)))
3392    {
3393       /* Out of memory */
3394       free(actiontext);
3395       edit_free_file(file);
3396       return JB_ERR_MEMORY;
3397    }
3398    strcpy(newtext, actiontext);
3399    free(actiontext);
3400    newtext[0]       = '{';
3401    newtext[len]     = '}';
3402    newtext[len + 1] = '\0';
3403
3404    freez(cur_line->raw);
3405    freez(cur_line->unprocessed);
3406    cur_line->unprocessed = newtext;
3407
3408    err = edit_write_file(file);
3409    if (err)
3410    {
3411       /* Error writing file */
3412       if (err == JB_ERR_FILE)
3413       {
3414          /* Read-only file. */
3415          err = cgi_error_file_read_only(csp, rsp, file->identifier);
3416       }
3417       edit_free_file(file);
3418       return err;
3419    }
3420
3421    snprintf(target, 1024, CGI_PREFIX "edit-actions-list?foo=%lu&f=%s#l%d",
3422             (long) time(NULL), file->identifier, sectionid);
3423
3424    edit_free_file(file);
3425
3426    return cgi_redirect(rsp, target);
3427 }
3428
3429
3430 /*********************************************************************
3431  *
3432  * Function    :  cgi_edit_actions_url
3433  *
3434  * Description :  CGI function that actually edits a URL pattern in
3435  *                an actions file.
3436  *
3437  * Parameters  :
3438  *          1  :  csp = Current client state (buffers, headers, etc...)
3439  *          2  :  rsp = http_response data structure for output
3440  *          3  :  parameters = map of cgi parameters
3441  *
3442  * CGI Parameters :
3443  *    filename : Identifies the file to edit
3444  *         ver : File's last-modified time
3445  *     section : Line number of section to edit
3446  *     pattern : Line number of pattern to edit
3447  *      newval : New value for pattern
3448  *
3449  * Returns     :  JB_ERR_OK     on success
3450  *                JB_ERR_MEMORY on out-of-memory
3451  *                JB_ERR_CGI_PARAMS if the CGI parameters are not
3452  *                                  specified or not valid.
3453  *
3454  *********************************************************************/
3455 jb_err cgi_edit_actions_url(struct client_state *csp,
3456                             struct http_response *rsp,
3457                             const struct map *parameters)
3458 {
3459    unsigned patternid;
3460    char * new_pattern;
3461    struct editable_file * file;
3462    struct file_line * cur_line;
3463    unsigned line_number;
3464    unsigned section_start_line_number = 0;
3465    char target[1024];
3466    jb_err err;
3467
3468    assert(csp);
3469    assert(rsp);
3470    assert(parameters);
3471
3472    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
3473    {
3474       return cgi_error_disabled(csp, rsp);
3475    }
3476
3477    err = get_number_param(csp, parameters, "p", &patternid);
3478    if (err)
3479    {
3480       return err;
3481    }
3482    if (patternid < 1U)
3483    {
3484       return JB_ERR_CGI_PARAMS;
3485    }
3486
3487    err = get_url_spec_param(csp, parameters, "u", &new_pattern);
3488    if (err)
3489    {
3490       return err;
3491    }
3492
3493    err = edit_read_actions_file(csp, rsp, parameters, 1, &file);
3494    if (err)
3495    {
3496       /* No filename specified, can't read file, modified, or out of memory. */
3497       free(new_pattern);
3498       return (err == JB_ERR_FILE ? JB_ERR_OK : err);
3499    }
3500
3501    line_number = 1;
3502    cur_line = file->lines;
3503
3504    while ((cur_line != NULL) && (line_number < patternid))
3505    {
3506       if (cur_line->type == FILE_LINE_ACTION)
3507       {
3508          section_start_line_number = line_number;
3509       }
3510       cur_line = cur_line->next;
3511       line_number++;
3512    }
3513
3514    if ( (cur_line == NULL)
3515      || (cur_line->type != FILE_LINE_URL))
3516    {
3517       /* Invalid "patternid" parameter */
3518       free(new_pattern);
3519       edit_free_file(file);
3520       return JB_ERR_CGI_PARAMS;
3521    }
3522
3523    /* At this point, the line to edit is in cur_line */
3524
3525    freez(cur_line->raw);
3526    freez(cur_line->unprocessed);
3527    cur_line->unprocessed = new_pattern;
3528
3529    err = edit_write_file(file);
3530    if (err)
3531    {
3532       /* Error writing file */
3533       if (err == JB_ERR_FILE)
3534       {
3535          /* Read-only file. */
3536          err = cgi_error_file_read_only(csp, rsp, file->identifier);
3537       }
3538       edit_free_file(file);
3539       return err;
3540    }
3541
3542    snprintf(target, 1024, CGI_PREFIX "edit-actions-list?foo=%lu&f=%s#l%d",
3543             (long) time(NULL), file->identifier, section_start_line_number);
3544
3545    edit_free_file(file);
3546
3547    return cgi_redirect(rsp, target);
3548 }
3549
3550
3551 /*********************************************************************
3552  *
3553  * Function    :  cgi_edit_actions_add_url
3554  *
3555  * Description :  CGI function that actually adds a URL pattern to
3556  *                an actions file.
3557  *
3558  * Parameters  :
3559  *          1  :  csp = Current client state (buffers, headers, etc...)
3560  *          2  :  rsp = http_response data structure for output
3561  *          3  :  parameters = map of cgi parameters
3562  *
3563  * CGI Parameters :
3564  *    filename : Identifies the file to edit
3565  *         ver : File's last-modified time
3566  *     section : Line number of section to edit
3567  *      newval : New pattern
3568  *
3569  * Returns     :  JB_ERR_OK     on success
3570  *                JB_ERR_MEMORY on out-of-memory
3571  *                JB_ERR_CGI_PARAMS if the CGI parameters are not
3572  *                                  specified or not valid.
3573  *
3574  *********************************************************************/
3575 jb_err cgi_edit_actions_add_url(struct client_state *csp,
3576                                 struct http_response *rsp,
3577                                 const struct map *parameters)
3578 {
3579    unsigned sectionid;
3580    char * new_pattern;
3581    struct file_line * new_line;
3582    struct editable_file * file;
3583    struct file_line * cur_line;
3584    unsigned line_number;
3585    char target[1024];
3586    jb_err err;
3587
3588    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
3589    {
3590       return cgi_error_disabled(csp, rsp);
3591    }
3592
3593    err = get_number_param(csp, parameters, "s", &sectionid);
3594    if (err)
3595    {
3596       return err;
3597    }
3598    if (sectionid < 1U)
3599    {
3600       return JB_ERR_CGI_PARAMS;
3601    }
3602
3603    err = get_url_spec_param(csp, parameters, "u", &new_pattern);
3604    if (err)
3605    {
3606       return err;
3607    }
3608
3609    err = edit_read_actions_file(csp, rsp, parameters, 1, &file);
3610    if (err)
3611    {
3612       /* No filename specified, can't read file, modified, or out of memory. */
3613       free(new_pattern);
3614       return (err == JB_ERR_FILE ? JB_ERR_OK : err);
3615    }
3616
3617    line_number = 1;
3618    cur_line = file->lines;
3619
3620    while ((cur_line != NULL) && (line_number < sectionid))
3621    {
3622       cur_line = cur_line->next;
3623       line_number++;
3624    }
3625
3626    if ( (cur_line == NULL)
3627      || (cur_line->type != FILE_LINE_ACTION))
3628    {
3629       /* Invalid "sectionid" parameter */
3630       free(new_pattern);
3631       edit_free_file(file);
3632       return JB_ERR_CGI_PARAMS;
3633    }
3634
3635    /* At this point, the section header is in cur_line - add after this. */
3636
3637    /* Allocate the new line */
3638    new_line = (struct file_line *)zalloc(sizeof(*new_line));
3639    if (new_line == NULL)
3640    {
3641       free(new_pattern);
3642       edit_free_file(file);
3643       return JB_ERR_MEMORY;
3644    }
3645
3646    /* Fill in the data members of the new line */
3647    new_line->raw = NULL;
3648    new_line->prefix = NULL;
3649    new_line->unprocessed = new_pattern;
3650    new_line->type = FILE_LINE_URL;
3651
3652    /* Link new_line into the list, after cur_line */
3653    new_line->next = cur_line->next;
3654    cur_line->next = new_line;
3655
3656    /* Done making changes, now commit */
3657
3658    err = edit_write_file(file);
3659    if (err)
3660    {
3661       /* Error writing file */
3662       if (err == JB_ERR_FILE)
3663       {
3664          /* Read-only file. */
3665          err = cgi_error_file_read_only(csp, rsp, file->identifier);
3666       }
3667       edit_free_file(file);
3668       return err;
3669    }
3670
3671    snprintf(target, 1024, CGI_PREFIX "edit-actions-list?foo=%lu&f=%s#l%d",
3672             (long) time(NULL), file->identifier, sectionid);
3673
3674    edit_free_file(file);
3675
3676    return cgi_redirect(rsp, target);
3677 }
3678
3679
3680 /*********************************************************************
3681  *
3682  * Function    :  cgi_edit_actions_remove_url
3683  *
3684  * Description :  CGI function that actually removes a URL pattern from
3685  *                the actions file.
3686  *
3687  * Parameters  :
3688  *          1  :  csp = Current client state (buffers, headers, etc...)
3689  *          2  :  rsp = http_response data structure for output
3690  *          3  :  parameters = map of cgi parameters
3691  *
3692  * CGI Parameters :
3693  *           f : (filename) Identifies the file to edit
3694  *           v : (version) File's last-modified time
3695  *           p : (pattern) Line number of pattern to remove
3696  *
3697  * Returns     :  JB_ERR_OK     on success
3698  *                JB_ERR_MEMORY on out-of-memory
3699  *                JB_ERR_CGI_PARAMS if the CGI parameters are not
3700  *                                  specified or not valid.
3701  *
3702  *********************************************************************/
3703 jb_err cgi_edit_actions_remove_url(struct client_state *csp,
3704                                    struct http_response *rsp,
3705                                    const struct map *parameters)
3706 {
3707    unsigned patternid;
3708    struct editable_file * file;
3709    struct file_line * cur_line;
3710    struct file_line * prev_line;
3711    unsigned line_number;
3712    unsigned section_start_line_number = 0;
3713    char target[1024];
3714    jb_err err;
3715
3716    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
3717    {
3718       return cgi_error_disabled(csp, rsp);
3719    }
3720
3721    err = get_number_param(csp, parameters, "p", &patternid);
3722    if (err)
3723    {
3724       return err;
3725    }
3726
3727    err = edit_read_actions_file(csp, rsp, parameters, 1, &file);
3728    if (err)
3729    {
3730       /* No filename specified, can't read file, modified, or out of memory. */
3731       return (err == JB_ERR_FILE ? JB_ERR_OK : err);
3732    }
3733
3734    line_number = 1;
3735    prev_line = NULL;
3736    cur_line = file->lines;
3737
3738    while ((cur_line != NULL) && (line_number < patternid))
3739    {
3740       if (cur_line->type == FILE_LINE_ACTION)
3741       {
3742          section_start_line_number = line_number;
3743       }
3744       prev_line = cur_line;
3745       cur_line = cur_line->next;
3746       line_number++;
3747    }
3748
3749    if ( (cur_line == NULL)
3750      || (prev_line == NULL)
3751      || (cur_line->type != FILE_LINE_URL))
3752    {
3753       /* Invalid "patternid" parameter */
3754       edit_free_file(file);
3755       return JB_ERR_CGI_PARAMS;
3756    }
3757
3758    /* At this point, the line to remove is in cur_line, and the previous
3759     * one is in prev_line
3760     */
3761
3762    /* Unlink cur_line */
3763    prev_line->next = cur_line->next;
3764    cur_line->next = NULL;
3765
3766    /* Free cur_line */
3767    edit_free_file_lines(cur_line);
3768
3769    err = edit_write_file(file);
3770    if (err)
3771    {
3772       /* Error writing file */
3773       if (err == JB_ERR_FILE)
3774       {
3775          /* Read-only file. */
3776          err = cgi_error_file_read_only(csp, rsp, file->identifier);
3777       }
3778       edit_free_file(file);
3779       return err;
3780    }
3781
3782    snprintf(target, 1024, CGI_PREFIX "edit-actions-list?foo=%lu&f=%s#l%d",
3783             (long) time(NULL), file->identifier, section_start_line_number);
3784
3785    edit_free_file(file);
3786
3787    return cgi_redirect(rsp, target);
3788 }
3789
3790
3791 /*********************************************************************
3792  *
3793  * Function    :  cgi_edit_actions_section_remove
3794  *
3795  * Description :  CGI function that actually removes a whole section from
3796  *                the actions file.  The section must be empty first
3797  *                (else JB_ERR_CGI_PARAMS).
3798  *
3799  * Parameters  :
3800  *          1  :  csp = Current client state (buffers, headers, etc...)
3801  *          2  :  rsp = http_response data structure for output
3802  *          3  :  parameters = map of cgi parameters
3803  *
3804  * CGI Parameters :
3805  *           f : (filename) Identifies the file to edit
3806  *           v : (version) File's last-modified time
3807  *           s : (section) Line number of section to edit
3808  *
3809  * Returns     :  JB_ERR_OK     on success
3810  *                JB_ERR_MEMORY on out-of-memory
3811  *                JB_ERR_CGI_PARAMS if the CGI parameters are not
3812  *                                  specified or not valid.
3813  *
3814  *********************************************************************/
3815 jb_err cgi_edit_actions_section_remove(struct client_state *csp,
3816                                        struct http_response *rsp,
3817                                        const struct map *parameters)
3818 {
3819    unsigned sectionid;
3820    struct editable_file * file;
3821    struct file_line * cur_line;
3822    struct file_line * prev_line;
3823    unsigned line_number;
3824    char target[1024];
3825    jb_err err;
3826
3827    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
3828    {
3829       return cgi_error_disabled(csp, rsp);
3830    }
3831
3832    err = get_number_param(csp, parameters, "s", &sectionid);
3833    if (err)
3834    {
3835       return err;
3836    }
3837
3838    err = edit_read_actions_file(csp, rsp, parameters, 1, &file);
3839    if (err)
3840    {
3841       /* No filename specified, can't read file, modified, or out of memory. */
3842       return (err == JB_ERR_FILE ? JB_ERR_OK : err);
3843    }
3844
3845    line_number = 1;
3846    cur_line = file->lines;
3847
3848    prev_line = NULL;
3849    while ((cur_line != NULL) && (line_number < sectionid))
3850    {
3851       prev_line = cur_line;
3852       cur_line = cur_line->next;
3853       line_number++;
3854    }
3855
3856    if ( (cur_line == NULL)
3857      || (cur_line->type != FILE_LINE_ACTION) )
3858    {
3859       /* Invalid "sectionid" parameter */
3860       edit_free_file(file);
3861       return JB_ERR_CGI_PARAMS;
3862    }
3863
3864    if ( (cur_line->next != NULL)
3865      && (cur_line->next->type == FILE_LINE_URL) )
3866    {
3867       /* Section not empty. */
3868       edit_free_file(file);
3869       return JB_ERR_CGI_PARAMS;
3870    }
3871
3872    /* At this point, the line to remove is in cur_line, and the previous
3873     * one is in prev_line
3874     */
3875
3876    /* Unlink cur_line */
3877    if (prev_line == NULL)
3878    {
3879       /* Removing the first line from the file */
3880       file->lines = cur_line->next;
3881    }
3882    else
3883    {
3884       prev_line->next = cur_line->next;
3885    }
3886    cur_line->next = NULL;
3887
3888    /* Free cur_line */
3889    edit_free_file_lines(cur_line);
3890
3891    err = edit_write_file(file);
3892    if (err)
3893    {
3894       /* Error writing file */
3895       if (err == JB_ERR_FILE)
3896       {
3897          /* Read-only file. */
3898          err = cgi_error_file_read_only(csp, rsp, file->identifier);
3899       }
3900       edit_free_file(file);
3901       return err;
3902    }
3903
3904    snprintf(target, 1024, CGI_PREFIX "edit-actions-list?foo=%lu&f=%s",
3905             (long) time(NULL), file->identifier);
3906
3907    edit_free_file(file);
3908
3909    return cgi_redirect(rsp, target);
3910 }
3911
3912
3913 /*********************************************************************
3914  *
3915  * Function    :  cgi_edit_actions_section_add
3916  *
3917  * Description :  CGI function that adds a new empty section to
3918  *                an actions file.
3919  *
3920  * Parameters  :
3921  *          1  :  csp = Current client state (buffers, headers, etc...)
3922  *          2  :  rsp = http_response data structure for output
3923  *          3  :  parameters = map of cgi parameters
3924  *
3925  * CGI Parameters :
3926  *           f : (filename) Identifies the file to edit
3927  *           v : (version) File's last-modified time
3928  *           s : (section) Line number of section to add after, 0 for
3929  *               start of file.
3930  *
3931  * Returns     :  JB_ERR_OK     on success
3932  *                JB_ERR_MEMORY on out-of-memory
3933  *                JB_ERR_CGI_PARAMS if the CGI parameters are not
3934  *                                  specified or not valid.
3935  *
3936  *********************************************************************/
3937 jb_err cgi_edit_actions_section_add(struct client_state *csp,
3938                                     struct http_response *rsp,
3939                                     const struct map *parameters)
3940 {
3941    unsigned sectionid;
3942    struct file_line * new_line;
3943    char * new_text;
3944    struct editable_file * file;
3945    struct file_line * cur_line;
3946    unsigned line_number;
3947    char target[1024];
3948    jb_err err;
3949
3950    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
3951    {
3952       return cgi_error_disabled(csp, rsp);
3953    }
3954
3955    err = get_number_param(csp, parameters, "s", &sectionid);
3956    if (err)
3957    {
3958       return err;
3959    }
3960
3961    err = edit_read_actions_file(csp, rsp, parameters, 1, &file);
3962    if (err)
3963    {
3964       /* No filename specified, can't read file, modified, or out of memory. */
3965       return (err == JB_ERR_FILE ? JB_ERR_OK : err);
3966    }
3967
3968    line_number = 1;
3969    cur_line = file->lines;
3970
3971    if (sectionid <= 1U)
3972    {
3973       /* Add to start of file */
3974       if (cur_line != NULL && cur_line->type != FILE_LINE_ACTION)
3975       {
3976          /* There's something in the file, find the line before the first
3977           * action.
3978           */
3979          while ( (cur_line->next != NULL)
3980               && (cur_line->next->type != FILE_LINE_ACTION) )
3981          {
3982             cur_line = cur_line->next;
3983             line_number++;
3984          }
3985       }
3986       else
3987       {
3988          /* File starts with action line, so insert at top */
3989          cur_line = NULL;
3990       }
3991    }
3992    else
3993    {
3994       /* Add after stated section. */
3995       while ((cur_line != NULL) && (line_number < sectionid))
3996       {
3997          cur_line = cur_line->next;
3998          line_number++;
3999       }
4000
4001       if ( (cur_line == NULL)
4002         || (cur_line->type != FILE_LINE_ACTION))
4003       {
4004          /* Invalid "sectionid" parameter */
4005          edit_free_file(file);
4006          return JB_ERR_CGI_PARAMS;
4007       }
4008
4009       /* Skip through the section to find the last line in it. */
4010       while ( (cur_line->next != NULL)
4011            && (cur_line->next->type != FILE_LINE_ACTION) )
4012       {
4013          cur_line = cur_line->next;
4014          line_number++;
4015       }
4016    }
4017
4018    /* At this point, the last line in the previous section is in cur_line
4019     * - add after this.  (Or if we need to add as the first line, cur_line
4020     * will be NULL).
4021     */
4022
4023    new_text = strdup("{}");
4024    if (NULL == new_text)
4025    {
4026       edit_free_file(file);
4027       return JB_ERR_MEMORY;
4028    }
4029
4030    /* Allocate the new line */
4031    new_line = (struct file_line *)zalloc(sizeof(*new_line));
4032    if (new_line == NULL)
4033    {
4034       free(new_text);
4035       edit_free_file(file);
4036       return JB_ERR_MEMORY;
4037    }
4038
4039    /* Fill in the data members of the new line */
4040    new_line->raw = NULL;
4041    new_line->prefix = NULL;
4042    new_line->unprocessed = new_text;
4043    new_line->type = FILE_LINE_ACTION;
4044
4045    if (cur_line != NULL)
4046    {
4047       /* Link new_line into the list, after cur_line */
4048       new_line->next = cur_line->next;
4049       cur_line->next = new_line;
4050    }
4051    else
4052    {
4053       /* Link new_line into the list, as first line */
4054       new_line->next = file->lines;
4055       file->lines = new_line;
4056    }
4057
4058    /* Done making changes, now commit */
4059
4060    err = edit_write_file(file);
4061    if (err)
4062    {
4063       /* Error writing file */
4064       if (err == JB_ERR_FILE)
4065       {
4066          /* Read-only file. */
4067          err = cgi_error_file_read_only(csp, rsp, file->identifier);
4068       }
4069       edit_free_file(file);
4070       return err;
4071    }
4072
4073    snprintf(target, 1024, CGI_PREFIX "edit-actions-list?foo=%lu&f=%s",
4074             (long) time(NULL), file->identifier);
4075
4076    edit_free_file(file);
4077
4078    return cgi_redirect(rsp, target);
4079 }
4080
4081
4082 /*********************************************************************
4083  *
4084  * Function    :  cgi_edit_actions_section_swap
4085  *
4086  * Description :  CGI function that swaps the order of two sections
4087  *                in the actions file.  Note that this CGI can actually
4088  *                swap any two arbitrary sections, but the GUI interface
4089  *                currently only allows consecutive sections to be
4090  *                specified.
4091  *
4092  * Parameters  :
4093  *          1  :  csp = Current client state (buffers, headers, etc...)
4094  *          2  :  rsp = http_response data structure for output
4095  *          3  :  parameters = map of cgi parameters
4096  *
4097  * CGI Parameters :
4098  *           f : (filename) Identifies the file to edit
4099  *           v : (version) File's last-modified time
4100  *          s1 : (section1) Line number of first section to swap
4101  *          s2 : (section2) Line number of second section to swap
4102  *
4103  * Returns     :  JB_ERR_OK     on success
4104  *                JB_ERR_MEMORY on out-of-memory
4105  *                JB_ERR_CGI_PARAMS if the CGI parameters are not
4106  *                                  specified or not valid.
4107  *
4108  *********************************************************************/
4109 jb_err cgi_edit_actions_section_swap(struct client_state *csp,
4110                                      struct http_response *rsp,
4111                                      const struct map *parameters)
4112 {
4113    unsigned section1;
4114    unsigned section2;
4115    struct editable_file * file;
4116    struct file_line * cur_line;
4117    struct file_line * prev_line;
4118    struct file_line * line_before_section1;
4119    struct file_line * line_start_section1;
4120    struct file_line * line_end_section1;
4121    struct file_line * line_after_section1;
4122    struct file_line * line_before_section2;
4123    struct file_line * line_start_section2;
4124    struct file_line * line_end_section2;
4125    struct file_line * line_after_section2;
4126    unsigned line_number;
4127    char target[1024];
4128    jb_err err;
4129
4130    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
4131    {
4132       return cgi_error_disabled(csp, rsp);
4133    }
4134
4135    err = get_number_param(csp, parameters, "s1", &section1);
4136    if (!err) err = get_number_param(csp, parameters, "s2", &section2);
4137    if (err)
4138    {
4139       return err;
4140    }
4141
4142    if (section1 > section2)
4143    {
4144       unsigned temp = section2;
4145       section2 = section1;
4146       section1 = temp;
4147    }
4148
4149    err = edit_read_actions_file(csp, rsp, parameters, 1, &file);
4150    if (err)
4151    {
4152       /* No filename specified, can't read file, modified, or out of memory. */
4153       return (err == JB_ERR_FILE ? JB_ERR_OK : err);
4154    }
4155
4156    /* Start at the beginning... */
4157    line_number = 1;
4158    cur_line = file->lines;
4159    prev_line = NULL;
4160
4161    /* ... find section1 ... */
4162    while ((cur_line != NULL) && (line_number < section1))
4163    {
4164       prev_line = cur_line;
4165       cur_line = cur_line->next;
4166       line_number++;
4167    }
4168
4169    if ( (cur_line == NULL)
4170      || (cur_line->type != FILE_LINE_ACTION) )
4171    {
4172       /* Invalid "section1" parameter */
4173       edit_free_file(file);
4174       return JB_ERR_CGI_PARAMS;
4175    }
4176
4177    /* If no-op, we've validated params and can skip the rest. */
4178    if (section1 != section2)
4179    {
4180       /* ... find the end of section1 ... */
4181       line_before_section1 = prev_line;
4182       line_start_section1 = cur_line;
4183       do
4184       {
4185          prev_line = cur_line;
4186          cur_line = cur_line->next;
4187          line_number++;
4188       }
4189       while ((cur_line != NULL) && (cur_line->type == FILE_LINE_URL));
4190       line_end_section1 = prev_line;
4191       line_after_section1 = cur_line;
4192
4193       /* ... find section2 ... */
4194       while ((cur_line != NULL) && (line_number < section2))
4195       {
4196          prev_line = cur_line;
4197          cur_line = cur_line->next;
4198          line_number++;
4199       }
4200
4201       if ( (cur_line == NULL)
4202         || (cur_line->type != FILE_LINE_ACTION) )
4203       {
4204          /* Invalid "section2" parameter */
4205          edit_free_file(file);
4206          return JB_ERR_CGI_PARAMS;
4207       }
4208
4209       /* ... find the end of section2 ... */
4210       line_before_section2 = prev_line;
4211       line_start_section2 = cur_line;
4212       do
4213       {
4214          prev_line = cur_line;
4215          cur_line = cur_line->next;
4216          line_number++;
4217       }
4218       while ((cur_line != NULL) && (cur_line->type == FILE_LINE_URL));
4219       line_end_section2 = prev_line;
4220       line_after_section2 = cur_line;
4221
4222       /* Now have all the pointers we need. Do the swap. */
4223
4224       /* Change the pointer to section1 to point to section2 instead */
4225       if (line_before_section1 == NULL)
4226       {
4227          file->lines = line_start_section2;
4228       }
4229       else
4230       {
4231          line_before_section1->next = line_start_section2;
4232       }
4233
4234       if (line_before_section2 == line_end_section1)
4235       {
4236          /* Consecutive sections */
4237          line_end_section2->next = line_start_section1;
4238       }
4239       else
4240       {
4241          line_end_section2->next = line_after_section1;
4242          line_before_section2->next = line_start_section1;
4243       }
4244
4245       /* Set the pointer from the end of section1 to the rest of the file */
4246       line_end_section1->next = line_after_section2;
4247
4248       err = edit_write_file(file);
4249       if (err)
4250       {
4251          /* Error writing file */
4252          if (err == JB_ERR_FILE)
4253          {
4254             /* Read-only file. */
4255             err = cgi_error_file_read_only(csp, rsp, file->identifier);
4256          }
4257          edit_free_file(file);
4258          return err;
4259       }
4260    } /* END if (section1 != section2) */
4261
4262    snprintf(target, 1024, CGI_PREFIX "edit-actions-list?foo=%lu&f=%s",
4263             (long) time(NULL), file->identifier);
4264
4265    edit_free_file(file);
4266
4267    return cgi_redirect(rsp, target);
4268 }
4269
4270 #ifdef FEATURE_TOGGLE
4271 /*********************************************************************
4272  *
4273  * Function    :  cgi_toggle
4274  *
4275  * Description :  CGI function that adds a new empty section to
4276  *                an actions file.
4277  *
4278  * Parameters  :
4279  *          1  :  csp = Current client state (buffers, headers, etc...)
4280  *          2  :  rsp = http_response data structure for output
4281  *          3  :  parameters = map of cgi parameters
4282  *
4283  * CGI Parameters :
4284  *         set : If present, how to change toggle setting:
4285  *               "enable", "disable", "toggle", or none (default).
4286  *        mini : If present, use mini reply template.
4287  *
4288  * Returns     :  JB_ERR_OK     on success
4289  *                JB_ERR_MEMORY on out-of-memory
4290  *
4291  *********************************************************************/
4292 jb_err cgi_toggle(struct client_state *csp,
4293                   struct http_response *rsp,
4294                   const struct map *parameters)
4295 {
4296    struct map *exports;
4297    char mode;
4298    const char *template_name;
4299
4300    assert(csp);
4301    assert(rsp);
4302    assert(parameters);
4303
4304    if (0 == (csp->config->feature_flags & RUNTIME_FEATURE_CGI_TOGGLE))
4305    {
4306       return cgi_error_disabled(csp, rsp);
4307    }
4308
4309    mode = get_char_param(parameters, "set");
4310
4311    if (mode == 'E')
4312    {
4313       /* Enable */
4314       global_toggle_state = 1;
4315    }
4316    else if (mode == 'D')
4317    {
4318       /* Disable */
4319       global_toggle_state = 0;
4320    }
4321    else if (mode == 'T')
4322    {
4323       /* Toggle */
4324       global_toggle_state = !global_toggle_state;
4325    }
4326
4327    if (NULL == (exports = default_exports(csp, "toggle")))
4328    {
4329       return JB_ERR_MEMORY;
4330    }
4331
4332    template_name = (get_char_param(parameters, "mini")
4333                  ? "toggle-mini"
4334                  : "toggle");
4335
4336    return template_fill_for_cgi(csp, template_name, exports, rsp);
4337 }
4338 #endif /* def FEATURE_TOGGLE */
4339
4340 /*********************************************************************
4341  *
4342  * Function    :  javascriptify
4343  *
4344  * Description :  Converts a string into a form JavaScript will like.
4345  *
4346  *                Netscape 4's JavaScript sucks - it doesn't use
4347  *                "id" parameters, so you have to set the "name"
4348  *                used to submit a form element to something JavaScript
4349  *                will like.  (Or access the elements by index in an
4350  *                array.  That array contains >60 elements and will
4351  *                be changed whenever we add a new action to the
4352  *                editor, so I'm NOT going to use indexes that have
4353  *                to be figured out by hand.)
4354  *
4355  *                Currently the only thing we have to worry about
4356  *                is "-" ==> "_" conversion.
4357  *
4358  *                This is a length-preserving operation so it is
4359  *                carried out in-place, no memory is allocated
4360  *                or freed.
4361  *
4362  * Parameters  :
4363  *          1  :  identifier = String to make JavaScript-friendly.
4364  *
4365  * Returns     :  N/A
4366  *
4367  *********************************************************************/
4368 static void javascriptify(char * identifier)
4369 {
4370    char * p = identifier;
4371    while (NULL != (p = strchr(p, '-')))
4372    {
4373       *p++ = '_';
4374    }
4375 }
4376
4377
4378 /*********************************************************************
4379  *
4380  * Function    :  actions_to_radio
4381  *
4382  * Description :  Converts a actionsfile entry into settings for
4383  *                radio buttons and edit boxes on a HTML form.
4384  *
4385  * Parameters  :
4386  *          1  :  exports = List of substitutions to add to.
4387  *          2  :  action  = Action to read
4388  *
4389  * Returns     :  JB_ERR_OK     on success
4390  *                JB_ERR_MEMORY on out-of-memory
4391  *
4392  *********************************************************************/
4393 static jb_err actions_to_radio(struct map * exports,
4394                                const struct action_spec *action)
4395 {
4396    unsigned mask = action->mask;
4397    unsigned add  = action->add;
4398    int mapped_param;
4399    int checked;
4400    char current_mode;
4401
4402    assert(exports);
4403    assert(action);
4404
4405    mask = action->mask;
4406    add  = action->add;
4407
4408    /* sanity - prevents "-feature +feature" */
4409    mask |= add;
4410
4411
4412 #define DEFINE_ACTION_BOOL(name, bit)                 \
4413    if (!(mask & bit))                                 \
4414    {                                                  \
4415       current_mode = 'n';                             \
4416    }                                                  \
4417    else if (add & bit)                                \
4418    {                                                  \
4419       current_mode = 'y';                             \
4420    }                                                  \
4421    else                                               \
4422    {                                                  \
4423       current_mode = 'x';                             \
4424    }                                                  \
4425    if (map_radio(exports, name, "ynx", current_mode)) \
4426    {                                                  \
4427       return JB_ERR_MEMORY;                           \
4428    }
4429
4430 #define DEFINE_ACTION_STRING(name, bit, index)        \
4431    DEFINE_ACTION_BOOL(name, bit);                     \
4432    mapped_param = 0;
4433
4434 #define DEFINE_CGI_PARAM_RADIO(name, bit, index, value, is_default)  \
4435    if (add & bit)                                                    \
4436    {                                                                 \
4437       checked = !strcmp(action->string[index], value);               \
4438    }                                                                 \
4439    else                                                              \
4440    {                                                                 \
4441       checked = is_default;                                          \
4442    }                                                                 \
4443    mapped_param |= checked;                                          \
4444    if (map(exports, name "-param-" value, 1, (checked ? "checked" : ""), 1)) \
4445    {                                                                 \
4446       return JB_ERR_MEMORY;                                          \
4447    }
4448
4449 #define DEFINE_CGI_PARAM_CUSTOM(name, bit, index, default_val)       \
4450    if (map(exports, name "-param-custom", 1,                         \
4451            ((!mapped_param) ? "checked" : ""), 1))                   \
4452    {                                                                 \
4453       return JB_ERR_MEMORY;                                          \
4454    }                                                                 \
4455    if (map(exports, name "-param", 1,                                \
4456            (((add & bit) && !mapped_param) ?                         \
4457            action->string[index] : default_val), 1))                 \
4458    {                                                                 \
4459       return JB_ERR_MEMORY;                                          \
4460    }
4461
4462 #define DEFINE_CGI_PARAM_NO_RADIO(name, bit, index, default_val)     \
4463    if (map(exports, name "-param", 1,                                \
4464            ((add & bit) ? action->string[index] : default_val), 1))  \
4465    {                                                                 \
4466       return JB_ERR_MEMORY;                                          \
4467    }
4468
4469 #define DEFINE_ACTION_MULTI(name, index)              \
4470    if (action->multi_add[index]->first)               \
4471    {                                                  \
4472       current_mode = 'y';                             \
4473    }                                                  \
4474    else if (action->multi_remove_all[index])          \
4475    {                                                  \
4476       current_mode = 'n';                             \
4477    }                                                  \
4478    else if (action->multi_remove[index]->first)       \
4479    {                                                  \
4480       current_mode = 'y';                             \
4481    }                                                  \
4482    else                                               \
4483    {                                                  \
4484       current_mode = 'x';                             \
4485    }                                                  \
4486    if (map_radio(exports, name, "ynx", current_mode)) \
4487    {                                                  \
4488       return JB_ERR_MEMORY;                           \
4489    }
4490
4491 #define DEFINE_ACTION_ALIAS 0 /* No aliases for output */
4492
4493 #include "actionlist.h"
4494
4495 #undef DEFINE_ACTION_MULTI
4496 #undef DEFINE_ACTION_STRING
4497 #undef DEFINE_ACTION_BOOL
4498 #undef DEFINE_ACTION_ALIAS
4499 #undef DEFINE_CGI_PARAM_CUSTOM
4500 #undef DEFINE_CGI_PARAM_RADIO
4501 #undef DEFINE_CGI_PARAM_NO_RADIO
4502
4503    return JB_ERR_OK;
4504 }
4505
4506
4507 /*********************************************************************
4508  *
4509  * Function    :  actions_from_radio
4510  *
4511  * Description :  Converts a map of parameters passed to a CGI function
4512  *                into an actionsfile entry.
4513  *
4514  * Parameters  :
4515  *          1  :  parameters = parameters to the CGI call
4516  *          2  :  action  = Action to change.  Must be valid before
4517  *                          the call, actions not specified will be
4518  *                          left unchanged.
4519  *
4520  * Returns     :  JB_ERR_OK     on success
4521  *                JB_ERR_MEMORY on out-of-memory
4522  *
4523  *********************************************************************/
4524 static jb_err actions_from_radio(const struct map * parameters,
4525                                  struct action_spec *action)
4526 {
4527    const char * param;
4528    char * param_dup;
4529    char ch;
4530    const char * js_name;
4531    jb_err err = JB_ERR_OK;
4532
4533    assert(parameters);
4534    assert(action);
4535
4536    /* Statics are generally a potential race condition,
4537     * but in this case we're safe and don't need semaphores.
4538     * Be careful if you modify this function.
4539     * - Jon
4540     * The js_name_arr's are never free()d, but this is no
4541     * problem, since they will only be created once and
4542     * used by all threads thereafter. -oes
4543     */
4544
4545 #define JAVASCRIPTIFY(dest_var, string)               \
4546    {                                                  \
4547      static int first_time = 1;                       \
4548      static char *js_name_arr;                        \
4549       if (first_time)                                 \
4550       {                                               \
4551          js_name_arr = strdup(string);                \
4552          javascriptify(js_name_arr);                  \
4553       }                                               \
4554       dest_var = js_name_arr;                         \
4555       first_time = 0;                                 \
4556    }                                                  \
4557
4558 #define DEFINE_ACTION_BOOL(name, bit)                 \
4559    JAVASCRIPTIFY(js_name, name);                      \
4560    ch = get_char_param(parameters, js_name);          \
4561    if (ch == 'Y')                                     \
4562    {                                                  \
4563       action->add  |= bit;                            \
4564       action->mask |= bit;                            \
4565    }                                                  \
4566    else if (ch == 'N')                                \
4567    {                                                  \
4568       action->add  &= ~bit;                           \
4569       action->mask &= ~bit;                           \
4570    }                                                  \
4571    else if (ch == 'X')                                \
4572    {                                                  \
4573       action->add  &= ~bit;                           \
4574       action->mask |= bit;                            \
4575    }                                                  \
4576
4577 #define DEFINE_ACTION_STRING(name, bit, index)                 \
4578    JAVASCRIPTIFY(js_name, name);                               \
4579    ch = get_char_param(parameters, js_name);                   \
4580    if (ch == 'Y')                                              \
4581    {                                                           \
4582       param = NULL;                                            \
4583       JAVASCRIPTIFY(js_name, name "-mode");                    \
4584       if (!err) err = get_string_param(parameters, js_name, &param);    \
4585       if ((param == NULL) || (0 == strcmp(param, "CUSTOM")))            \
4586       {                                                                 \
4587          JAVASCRIPTIFY(js_name, name "-param");                         \
4588          if (!err) err = get_string_param(parameters, js_name, &param); \
4589       }                                                        \
4590       if (param != NULL)                                       \
4591       {                                                        \
4592          if (NULL == (param_dup = strdup(param)))              \
4593          {                                                     \
4594             return JB_ERR_MEMORY;                              \
4595          }                                                     \
4596          freez(action->string[index]);                         \
4597          action->add  |= bit;                                  \
4598          action->mask |= bit;                                  \
4599          action->string[index] = param_dup;                    \
4600       }                                                        \
4601    }                                                           \
4602    else if (ch == 'N')                                         \
4603    {                                                           \
4604       if (action->add & bit)                                   \
4605       {                                                        \
4606          freez(action->string[index]);                         \
4607       }                                                        \
4608       action->add  &= ~bit;                                    \
4609       action->mask &= ~bit;                                    \
4610    }                                                           \
4611    else if (ch == 'X')                                         \
4612    {                                                           \
4613       if (action->add & bit)                                   \
4614       {                                                        \
4615          freez(action->string[index]);                         \
4616       }                                                        \
4617       action->add  &= ~bit;                                    \
4618       action->mask |= bit;                                     \
4619    }                                                           \
4620
4621 #define DEFINE_ACTION_MULTI(name, index)                       \
4622    JAVASCRIPTIFY(js_name, name);                               \
4623    ch = get_char_param(parameters, js_name);                   \
4624    if (ch == 'Y')                                              \
4625    {                                                           \
4626       /* FIXME */                                              \
4627    }                                                           \
4628    else if (ch == 'N')                                         \
4629    {                                                           \
4630       list_remove_all(action->multi_add[index]);               \
4631       list_remove_all(action->multi_remove[index]);            \
4632       action->multi_remove_all[index] = 1;                     \
4633    }                                                           \
4634    else if (ch == 'X')                                         \
4635    {                                                           \
4636       list_remove_all(action->multi_add[index]);               \
4637       list_remove_all(action->multi_remove[index]);            \
4638       action->multi_remove_all[index] = 0;                     \
4639    }                                                           \
4640
4641 #define DEFINE_ACTION_ALIAS 0 /* No aliases for URL parsing */
4642
4643 #include "actionlist.h"
4644
4645 #undef DEFINE_ACTION_MULTI
4646 #undef DEFINE_ACTION_STRING
4647 #undef DEFINE_ACTION_BOOL
4648 #undef DEFINE_ACTION_ALIAS
4649 #undef JAVASCRIPTIFY
4650
4651    return err;
4652 }
4653
4654
4655 #endif /* def FEATURE_CGI_EDIT_ACTIONS */
4656
4657
4658 /*
4659   Local Variables:
4660   tab-width: 3
4661   end:
4662 */