cgi.c

   1 const char cgi_rcs[] = "$Id: cgi.c,v 1.88 2007/01/23 13:14:32 fabiankeil Exp $";
   2 /*********************************************************************
   3  *
   4  * File        :  $Source: /cvsroot/ijbswa/current/cgi.c,v $
   5  *
   6  * Purpose     :  Declares functions to intercept request, generate
   7  *                html or gif answers, and to compose HTTP resonses.
   8  *                This only contains the framework functions, the
   9  *                actual handler functions are declared elsewhere.
  10  *
  11  *                Functions declared include:
  12  *
  13  *
  14  * Copyright   :  Written by and Copyright (C) 2001-2004, 2006-2007
  15  *                the SourceForge Privoxy team. http://www.privoxy.org/
  16  *
  17  *                Based on the Internet Junkbuster originally written
  18  *                by and Copyright (C) 1997 Anonymous Coders and
  19  *                Junkbusters Corporation.  http://www.junkbusters.com
  20  *
  21  *                This program is free software; you can redistribute it
  22  *                and/or modify it under the terms of the GNU General
  23  *                Public License as published by the Free Software
  24  *                Foundation; either version 2 of the License, or (at
  25  *                your option) any later version.
  26  *
  27  *                This program is distributed in the hope that it will
  28  *                be useful, but WITHOUT ANY WARRANTY; without even the
  29  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
  30  *                PARTICULAR PURPOSE.  See the GNU General Public
  31  *                License for more details.
  32  *
  33  *                The GNU General Public License should be included with
  34  *                this file.  If not, you can view it at
  35  *                http://www.gnu.org/copyleft/gpl.html
  36  *                or write to the Free Software Foundation, Inc., 59
  37  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  38  *
  39  * Revisions   :
  40  *    $Log: cgi.c,v $
  41  *    Revision 1.88  2007/01/23 13:14:32  fabiankeil
  42  *    - Map variables that aren't guaranteed to be
  43  *      pure ASCII html_encoded.
  44  *    - Use CGI_PREFIX to generate URL for user manual
  45  *      CGI page to make sure CGI_SITE_2_PATH is included.
  46  *
  47  *    Revision 1.87  2007/01/22 15:34:13  fabiankeil
  48  *    - "Protect" against a rather lame JavaScript-based
  49  *      Privoxy detection "attack" and check the referrer
  50  *      before delivering the CGI style sheet.
  51  *    - Move referrer check for unsafe CGI pages into
  52  *      referrer_is_safe() and log the result.
  53  *    - Map @url@ in cgi-error-disabled page.
  54  *      It's required for the "go there anyway" link.
  55  *    - Mark *csp as immutable for grep_cgi_referrer().
  56  *
  57  *    Revision 1.86  2007/01/09 11:54:26  fabiankeil
  58  *    Fix strdup() error handling in cgi_error_unknown()
  59  *    and cgi_error_no_template(). Reported by Markus Elfring.
  60  *
  61  *    Revision 1.85  2007/01/05 14:19:02  fabiankeil
  62  *    Handle pcrs_execute() errors in template_fill() properly.
  63  *
  64  *    Revision 1.84  2006/12/28 17:54:22  fabiankeil
  65  *    Fixed gcc43 conversion warnings and replaced sprintf
  66  *    calls with snprintf to give OpenBSD's gcc one less reason
  67  *    to complain.
  68  *
  69  *    Revision 1.83  2006/12/17 19:35:19  fabiankeil
  70  *    Escape ampersand in Privoxy menu.
  71  *
  72  *    Revision 1.82  2006/12/17 17:53:39  fabiankeil
  73  *    Suppress the toggle link if remote toggling is disabled.
  74  *
  75  *    Revision 1.81  2006/12/09 13:49:16  fabiankeil
  76  *    Fix configure option --disable-toggle.
  77  *    Thanks to Peter Thoenen for reporting this.
  78  *
  79  *    Revision 1.80  2006/12/08 14:45:32  fabiankeil
  80  *    Don't lose the FORCE_PREFIX in case of
  81  *    connection problems. Fixes #612235.
  82  *
  83  *    Revision 1.79  2006/11/13 19:05:50  fabiankeil
  84  *    Make pthread mutex locking more generic. Instead of
  85  *    checking for OSX and OpenBSD, check for FEATURE_PTHREAD
  86  *    and use mutex locking unless there is an _r function
  87  *    available. Better safe than sorry.
  88  *
  89  *    Fixes "./configure --disable-pthread" and should result
  90  *    in less threading-related problems on pthread-using platforms,
  91  *    but it still doesn't fix BR#1122404.
  92  *
  93  *    Revision 1.78  2006/09/21 19:22:07  fabiankeil
  94  *    Use CGI_PREFIX to check the referrer.
  95  *    The check for "http://config.privoxy.org/" fails
  96  *    if the user modified CGI_SITE_2_HOST.
  97  *
  98  *    Revision 1.77  2006/09/21 15:17:23  fabiankeil
  99  *    Adjusted headers for Privoxy's cgi responses:
 100  *    Don't set Last-Modified, Expires and Cache-Control
 101  *    headers for redirects; always set "Connection: close".
 102  *
 103  *    Revision 1.76  2006/09/07 14:06:38  fabiankeil
 104  *    Only predate the Last-Modified header for cgi responses
 105  *    that are delivered with status code 404 or 503.
 106  *
 107  *    Revision 1.75  2006/09/07 11:56:39  fabiankeil
 108  *    Mark cgi_send_user_manual as harmless,
 109  *    to fix the access denied problem Hal spotted.
 110  *    The manual has no secret content, therefore we
 111  *    don't have to care about "secure" referrers.
 112  *
 113  *    Revision 1.74  2006/09/06 18:45:03  fabiankeil
 114  *    Incorporate modified version of Roland Rosenfeld's patch to
 115  *    optionally access the user-manual via Privoxy. Closes patch 679075.
 116  *
 117  *    Formatting changed to Privoxy style, added call to
 118  *    cgi_error_no_template if the requested file doesn't
 119  *    exist and modified check whether or not Privoxy itself
 120  *    should serve the manual. Should work cross-platform now.
 121  *
 122  *    Revision 1.73  2006/08/03 02:46:41  david__schmidt
 123  *    Incorporate Fabian Keil's patch work:\rhttp://www.fabiankeil.de/sourcecode/privoxy/
 124  *
 125  *    Revision 1.72  2006/07/18 14:48:45  david__schmidt
 126  *    Reorganizing the repository: swapping out what was HEAD (the old 3.1 branch)
 127  *    with what was really the latest development (the v_3_0_branch branch)
 128  *
 129  *    Revision 1.70.2.13  2004/02/17 13:30:23  oes
 130  *    Moved cgi_error_disabled() from cgiedit.c to
 131  *    cgi.c to re-enable build with --disable-editor.
 132  *    Fixes Bug #892744. Thanks to Matthew Fischer
 133  *    for spotting.
 134  *
 135  *    Revision 1.70.2.12  2003/12/17 16:33:16  oes
 136  *     - Added new function cgi_redirect to handle creation of
 137  *       HTTP redirect messages formerly repeated in the code.
 138  *     - Send cgi_error_disabled instead of cgi_error_404 when
 139  *       referrer check fails
 140  *     - Dynamic content now gets Expires header field with date
 141  *       in the past
 142  *
 143  *    Revision 1.70.2.11  2003/10/23 12:29:26  oes
 144  *    Bugfix: Transparent PNG was not transparent. Thanks to
 145  *    Dan Razzell of Starfish Systems for notice and new PNG.
 146  *
 147  *    Revision 1.70.2.10  2003/06/06 07:54:25  oes
 148  *    Security fix: dspatch_known_cgi no longer considers an empty
 149  *    referrer safe for critical CGIs, since malicious links could
 150  *    reside on https:// locations which browsers don't advertize as
 151  *    referrers. Closes bug #749916, thanks to Jeff Epler for the
 152  *    hint. Goodbye One-Click[tm] toggling :-(
 153  *
 154  *    Revision 1.70.2.9  2003/05/08 15:11:31  oes
 155  *    Nit
 156  *
 157  *    Revision 1.70.2.8  2003/04/29 13:33:51  oes
 158  *    Killed a compiler warning on OSX
 159  *
 160  *    Revision 1.70.2.7  2003/04/03 13:50:58  oes
 161  *    - Don't call cgi_error_disabled ifndef FEATURE_CGI_EDIT_ACTIONS
 162  *      (fixes bug #710056)
 163  *    - Show toggle info only if we have it
 164  *
 165  *    Revision 1.70.2.6  2003/03/12 01:26:25  david__schmidt
 166  *    Move declaration of struct tm dummy outside of a control block so it is
 167  *    accessible later on during snprintf in get_http_time.
 168  *
 169  *    Revision 1.70.2.5  2003/03/11 11:53:58  oes
 170  *    Cosmetic: Renamed cryptic variable
 171  *
 172  *    Revision 1.70.2.4  2003/03/07 03:41:03  david__schmidt
 173  *    Wrapping all *_r functions (the non-_r versions of them) with mutex semaphores for OSX.  Hopefully this will take care of all of those pesky crash reports.
 174  *
 175  *    Revision 1.70.2.3  2002/11/28 18:14:32  oes
 176  *    Disable access to critical CGIs via untrusted referrers.
 177  *    This prevents users from being tricked by malicious websites
 178  *    into making unintentional configuration changes:
 179  *
 180  *     - Added flag to each cgi_dispatcher that allows or denies
 181  *       external linking
 182  *     - Introduced proviorical function that greps for the
 183  *       referrer header before regular header parsing happens
 184  *     - Added safety check to dispatch_known_cgi. CGI is called
 185  *       if (cgi harmless || no referrer || we are referrer).
 186  *       Else a) toggle calls are modified not to change status and
 187  *       b) all other calls are denied.
 188  *
 189  *    Revision 1.70.2.2  2002/11/12 16:20:37  oes
 190  *    Added missing #ifdef FEATURE_TOGGLE around g_bToggleIJB; fixes bug #636651
 191  *
 192  *    Revision 1.70.2.1  2002/08/05 11:17:46  oes
 193  *    Fixed Bug #587820, i.e. added workaround for IE bug that includes fragment identifier in (cgi) query
 194  *
 195  *    Revision 1.70  2002/05/19 11:33:20  jongfoster
 196  *    If a CGI error was not handled, and propogated back to
 197  *    dispatch_known_cgi(), then it was assumed to be "out of memory".
 198  *    This gave a very misleading error message.
 199  *
 200  *    Now other errors will cause a simple message giving the error
 201  *    number and asking the user to report a bug.
 202  *
 203  *    Bug report:
 204  *    http://sourceforge.net/tracker/index.php?func=detail
 205  *    &aid=557905&group_id=11118&atid=111118
 206  *
 207  *    Revision 1.69  2002/05/14 21:28:40  oes
 208  *     - Fixed add_help_link to link to the (now split) actions
 209  *       part of the config chapter
 210  *     - Renamed helplink export to actions-help-prefix
 211  *
 212  *    Revision 1.68  2002/05/12 21:36:29  jongfoster
 213  *    Correcting function comments
 214  *
 215  *    Revision 1.67  2002/04/30 12:02:07  oes
 216  *    Nit: updated a comment
 217  *
 218  *    Revision 1.66  2002/04/26 18:32:57  jongfoster
 219  *    Fixing a memory leak on error
 220  *
 221  *    Revision 1.65  2002/04/26 12:53:51  oes
 222  *     - New function add_help_link
 223  *     - default_exports now exports links to the user manual
 224  *       and a prefix for links into the config chapter
 225  *
 226  *    Revision 1.64  2002/04/24 02:17:21  oes
 227  *     - Better descriptions for CGIs
 228  *     - Hide edit-actions, more shortcuts
 229  *     - Moved get_char_param, get_string_param and get_number_param here
 230  *       from cgiedit.c
 231  *
 232  *    Revision 1.63  2002/04/15 19:06:43  jongfoster
 233  *    Typos
 234  *
 235  *    Revision 1.62  2002/04/10 19:59:46  jongfoster
 236  *    Fixes to #include in templates:
 237  *    - Didn't close main file if loading an included template fails.
 238  *    - I'm paranoid and want to disallow "#include /etc/passwd".
 239  *
 240  *    Revision 1.61  2002/04/10 13:37:48  oes
 241  *    Made templates modular: template_load now recursive with max depth 1
 242  *
 243  *    Revision 1.60  2002/04/08 20:50:25  swa
 244  *    fixed JB spelling
 245  *
 246  *    Revision 1.59  2002/04/05 15:51:51  oes
 247  *     - added send-stylesheet CGI
 248  *     - bugfix: error-pages now get correct request protocol
 249  *     - fixed
 250  *     - kludged CGI descriptions and menu not to break JS syntax
 251  *
 252  *    Revision 1.58  2002/03/29 03:33:13  david__schmidt
 253  *    Fix Mac OSX compiler warnings
 254  *
 255  *    Revision 1.57  2002/03/26 22:29:54  swa
 256  *    we have a new homepage!
 257  *
 258  *    Revision 1.56  2002/03/24 17:50:46  jongfoster
 259  *    Fixing compile error if actions file editor disabled
 260  *
 261  *    Revision 1.55  2002/03/24 16:55:06  oes
 262  *    Making GIF checkerboard transparent
 263  *
 264  *    Revision 1.54  2002/03/24 16:18:15  jongfoster
 265  *    Removing old logo
 266  *
 267  *    Revision 1.53  2002/03/24 16:06:00  oes
 268  *    Correct transparency for checkerboard PNG. Thanks, Magnus!
 269  *
 270  *    Revision 1.52  2002/03/24 15:23:33  jongfoster
 271  *    Name changes
 272  *
 273  *    Revision 1.51  2002/03/24 13:25:43  swa
 274  *    name change related issues
 275  *
 276  *    Revision 1.50  2002/03/16 23:54:06  jongfoster
 277  *    Adding graceful termination feature, to help look for memory leaks.
 278  *    If you enable this (which, by design, has to be done by hand
 279  *    editing config.h) and then go to http://i.j.b/die, then the program
 280  *    will exit cleanly after the *next* request.  It should free all the
 281  *    memory that was used.
 282  *
 283  *    Revision 1.49  2002/03/13 00:27:04  jongfoster
 284  *    Killing warnings
 285  *
 286  *    Revision 1.48  2002/03/08 17:47:07  jongfoster
 287  *    Adding comments
 288  *
 289  *    Revision 1.47  2002/03/08 16:41:33  oes
 290  *    Added GIF images again
 291  *
 292  *    Revision 1.46  2002/03/07 03:48:38  oes
 293  *     - Changed built-in images from GIF to PNG
 294  *       (with regard to Unisys patent issue)
 295  *     - Added a 4x4 pattern PNG which is less intrusive
 296  *       than the logo but also clearly marks the deleted banners
 297  *
 298  *    Revision 1.45  2002/03/06 22:54:35  jongfoster
 299  *    Automated function-comment nitpicking.
 300  *
 301  *    Revision 1.44  2002/03/05 22:43:45  david__schmidt
 302  *    - Better error reporting on OS/2
 303  *    - Fix double-slash comment (oops)
 304  *
 305  *    Revision 1.43  2002/03/05 21:33:45  david__schmidt
 306  *    - Re-enable OS/2 building after new parms were added
 307  *    - Fix false out of memory report when resolving CGI templates when no IP
 308  *      address is available of failed attempt (a la no such domain)
 309  *
 310  *    Revision 1.42  2002/01/21 00:33:20  jongfoster
 311  *    Replacing strsav() with the safer string_append() or string_join().
 312  *    Adding map_block_keep() to save a few bytes in the edit-actions-list HTML.
 313  *    Adding missing html_encode() to error message generators.
 314  *    Adding edit-actions-section-swap and many "shortcuts" to the list of CGIs.
 315  *
 316  *    Revision 1.41  2002/01/17 20:56:22  jongfoster
 317  *    Replacing hard references to the URL of the config interface
 318  *    with #defines from project.h
 319  *
 320  *    Revision 1.40  2002/01/09 14:26:46  oes
 321  *    Added support for thread-safe gmtime_r call.
 322  *
 323  *    Revision 1.39  2001/11/16 00:48:13  jongfoster
 324  *    Fixing a compiler warning
 325  *
 326  *    Revision 1.38  2001/11/13 00:31:21  jongfoster
 327  *    - Adding new CGIs for use by non-JavaScript browsers:
 328  *        edit-actions-url-form
 329  *        edit-actions-add-url-form
 330  *        edit-actions-remove-url-form
 331  *    - Fixing make_menu()'s HTML generation - it now quotes the href parameter.
 332  *    - Fixing || bug.
 333  *
 334  *    Revision 1.37  2001/11/01 14:28:47  david__schmidt
 335  *    Show enablement/disablement status in almost all templates.
 336  *    There is a little trickiness here: apparent recursive resolution of
 337  *    @if-enabled-then@ caused the toggle template to show status out-of-phase with
 338  *    the actual enablement status.  So a similar construct,
 339  *    @if-enabled-display-then@, is used to resolve the status display on non-'toggle'
 340  *    templates.
 341  *
 342  *    Revision 1.36  2001/10/26 17:33:27  oes
 343  *    marginal bugfix
 344  *
 345  *    Revision 1.35  2001/10/23 21:48:19  jongfoster
 346  *    Cleaning up error handling in CGI functions - they now send back
 347  *    a HTML error page and should never cause a FATAL error.  (Fixes one
 348  *    potential source of "denial of service" attacks).
 349  *
 350  *    CGI actions file editor that works and is actually useful.
 351  *
 352  *    Ability to toggle Junkbuster remotely using a CGI call.
 353  *
 354  *    You can turn off both the above features in the main configuration
 355  *    file, e.g. if you are running a multi-user proxy.
 356  *
 357  *    Revision 1.34  2001/10/18 22:22:09  david__schmidt
 358  *    Only show "Local support" on templates conditionally:
 359  *      - if either 'admin-address' or 'proxy-info-url' are uncommented in config
 360  *      - if not, no Local support section appears
 361  *
 362  *    Revision 1.33  2001/10/14 22:28:41  jongfoster
 363  *    Fixing stupid typo.
 364  *
 365  *    Revision 1.32  2001/10/14 22:20:18  jongfoster
 366  *    - Changes to CGI dispatching method to match CGI names exactly,
 367  *      rather than doing a prefix match.
 368  *    - No longer need to count the length of the CGI handler names by hand.
 369  *    - Adding new handler for 404 error when disptching a CGI, if none of
 370  *      the handlers match.
 371  *    - Adding new handlers for CGI actionsfile editor.
 372  *
 373  *    Revision 1.31  2001/10/10 10:56:39  oes
 374  *    Failiure to load template now fatal. Before, the user got a hard-to-understand assertion failure from cgi.c
 375  *
 376  *    Revision 1.30  2001/10/02 15:30:57  oes
 377  *    Introduced show-request cgi
 378  *
 379  *    Revision 1.29  2001/09/20 15:47:44  steudten
 380  *
 381  *    Fix BUG: Modify int size to size_t size in fill_template()
 382  *     - removes big trouble on machines where sizeof(int) != sizeof(size_t).
 383  *
 384  *    Revision 1.28  2001/09/19 18:00:37  oes
 385  *     - Deletef time() FIXME (Can't fail under Linux either, if
 386  *       the argument is guaranteed to be in out address space,
 387  *       which it is.)
 388  *     - Fixed comments
 389  *     - Pointer notation cosmetics
 390  *     - Fixed a minor bug in template_fill(): Failiure of
 391  *       pcrs_execute() now secure.
 392  *
 393  *    Revision 1.27  2001/09/16 17:08:54  jongfoster
 394  *    Moving simple CGI functions from cgi.c to new file cgisimple.c
 395  *
 396  *    Revision 1.26  2001/09/16 15:47:37  jongfoster
 397  *    First version of CGI-based edit interface.  This is very much a
 398  *    work-in-progress, and you can't actually use it to edit anything
 399  *    yet.  You must #define FEATURE_CGI_EDIT_ACTIONS for these changes
 400  *    to have any effect.
 401  *
 402  *    Revision 1.25  2001/09/16 15:02:35  jongfoster
 403  *    Adding i.j.b/robots.txt.
 404  *    Inlining add_stats() since it's only ever called from one place.
 405  *
 406  *    Revision 1.24  2001/09/16 11:38:01  jongfoster
 407  *    Splitting fill_template() into 2 functions:
 408  *    template_load() loads the file
 409  *    template_fill() performs the PCRS regexps.
 410  *    This is because the CGI edit interface has a "table row"
 411  *    template which is used many times in the page - this
 412  *    change means it's only loaded from disk once.
 413  *
 414  *    Revision 1.23  2001/09/16 11:16:05  jongfoster
 415  *    Better error handling in dispatch_cgi() and parse_cgi_parameters()
 416  *
 417  *    Revision 1.22  2001/09/16 11:00:10  jongfoster
 418  *    New function alloc_http_response, for symmetry with free_http_response
 419  *
 420  *    Revision 1.21  2001/09/13 23:53:03  jongfoster
 421  *    Support for both static and dynamically generated CGI pages.
 422  *    Correctly setting Last-Modified: and Expires: HTTP headers.
 423  *
 424  *    Revision 1.20  2001/09/13 23:40:36  jongfoster
 425  *    (Cosmetic only) Indentation correction
 426  *
 427  *    Revision 1.19  2001/09/13 23:31:25  jongfoster
 428  *    Moving image data to cgi.c rather than cgi.h.
 429  *
 430  *    Revision 1.18  2001/08/05 16:06:20  jongfoster
 431  *    Modifiying "struct map" so that there are now separate header and
 432  *    "map_entry" structures.  This means that functions which modify a
 433  *    map no longer need to return a pointer to the modified map.
 434  *    Also, it no longer reverses the order of the entries (which may be
 435  *    important with some advanced template substitutions).
 436  *
 437  *    Revision 1.17  2001/08/05 15:57:38  oes
 438  *    Adapted finish_http_response to new list_to_text
 439  *
 440  *    Revision 1.16  2001/08/01 21:33:18  jongfoster
 441  *    Changes to fill_template() that reduce memory usage without having
 442  *    an impact on performance.  I also renamed some variables so as not
 443  *    to clash with the C++ keywords "new" and "template".
 444  *
 445  *    Revision 1.15  2001/08/01 21:19:22  jongfoster
 446  *    Moving file version information to a separate CGI page.
 447  *
 448  *    Revision 1.14  2001/08/01 00:19:03  jongfoster
 449  *    New function: map_conditional() for an if-then-else syntax.
 450  *    Changing to use new version of show_defines()
 451  *
 452  *    Revision 1.13  2001/07/30 22:08:36  jongfoster
 453  *    Tidying up #defines:
 454  *    - All feature #defines are now of the form FEATURE_xxx
 455  *    - Permanently turned off WIN_GUI_EDIT
 456  *    - Permanently turned on WEBDAV and SPLIT_PROXY_ARGS
 457  *
 458  *    Revision 1.12  2001/07/29 18:47:05  jongfoster
 459  *    Adding missing #include "loadcfg.h"
 460  *
 461  *    Revision 1.11  2001/07/18 17:24:37  oes
 462  *    Changed to conform to new pcrs interface
 463  *
 464  *    Revision 1.10  2001/07/13 13:53:13  oes
 465  *    Removed all #ifdef PCRS and related code
 466  *
 467  *    Revision 1.9  2001/06/29 21:45:41  oes
 468  *    Indentation, CRLF->LF, Tab-> Space
 469  *
 470  *    Revision 1.8  2001/06/29 13:21:46  oes
 471  *    - Cosmetics: renamed and reordered functions, variables,
 472  *      texts, improved comments  etc
 473  *
 474  *    - Removed ij_untrusted_url() The relevant
 475  *      info is now part of the "untrusted" page,
 476  *      which is generated by filters.c:trust_url()
 477  *
 478  *    - Generators of content now call finish_http_response()
 479  *      themselves, making jcc.c:chat() a little less
 480  *      cluttered
 481  *
 482  *    - Removed obsolete "Pragma: no-cache" from our headers
 483  *
 484  *    - http_responses now know their head length
 485  *
 486  *    - fill_template now uses the new interface to pcrs, so that
 487  *       - long jobs (like whole files) no longer have to be assembled
 488  *         in a fixed size buffer
 489  *       - the new T (trivial) option is used, and the replacement may
 490  *         contain Perl syntax backrefs without confusing pcrs
 491  *
 492  *    - Introduced default_exports() which generates a set of exports
 493  *      common to all CGIs and other content generators
 494  *
 495  *    - Introduced convenience function map_block_killer()
 496  *
 497  *    - Introduced convenience function make_menu()
 498  *
 499  *    - Introduced CGI-like function error_response() which generates
 500  *      the "No such domain" and "Connect failed" messages using the
 501  *      CGI platform
 502  *
 503  *    - cgi_show_url_info:
 504  *      - adapted to new CGI features
 505  *      - form and answers now generated from same template
 506  *      - http:// prefix in URL now OK
 507  *
 508  *    - cgi_show_status:
 509  *      - adapted to new CGI features
 510  *      - no longer uses csp->init_proxy_args
 511  *
 512  *    - cgi_default:
 513  *      - moved menu generation to make_menu()
 514  *
 515  *    - add_stats now writes single export map entries instead
 516  *      of a fixed string
 517  *
 518  *    - Moved redirect_url() to filters.c
 519  *
 520  *    - Fixed mem leak in free_http_response(), map_block_killer(),
 521  *
 522  *    - Removed logentry from cancelled commit
 523  *
 524  *    Revision 1.7  2001/06/09 10:51:58  jongfoster
 525  *    Changing "show URL info" handler to new style.
 526  *    Changing BUFSIZ ==> BUFFER_SIZE
 527  *
 528  *    Revision 1.6  2001/06/07 23:05:19  jongfoster
 529  *    Removing code related to old forward and ACL files.
 530  *
 531  *    Revision 1.5  2001/06/05 19:59:16  jongfoster
 532  *    Fixing multiline character string (a GCC-only "feature"), and snprintf (it's _snprintf under VC++).
 533  *
 534  *    Revision 1.4  2001/06/04 10:41:52  swa
 535  *    show version string of cgi.h and cgi.c
 536  *
 537  *    Revision 1.3  2001/06/03 19:12:16  oes
 538  *    introduced new cgi handling
 539  *
 540  *    No revisions before 1.3
 541  *
 542  **********************************************************************/
 543 \f
 544
 545 #include "config.h"
 546
 547 #include <stdio.h>
 548 #include <sys/types.h>
 549 #include <stdlib.h>
 550 #include <ctype.h>
 551 #include <string.h>
 552 #include <limits.h>
 553 #include <assert.h>
 554
 555 #ifdef _WIN32
 556 #define snprintf _snprintf
 557 #endif /* def _WIN32 */
 558
 559 #include "project.h"
 560 #include "cgi.h"
 561 #include "list.h"
 562 #include "encode.h"
 563 #include "ssplit.h"
 564 #include "errlog.h"
 565 #include "miscutil.h"
 566 #include "cgisimple.h"
 567 #ifdef FEATURE_CGI_EDIT_ACTIONS
 568 #include "cgiedit.h"
 569 #endif /* def FEATURE_CGI_EDIT_ACTIONS */
 570 #include "loadcfg.h"
 571 /* loadcfg.h is for global_toggle_state only */
 572 #ifdef FEATURE_PTHREAD
 573 #include "jcc.h"
 574 /* jcc.h is for mutex semaphore globals only */
 575 #endif /* def FEATURE_PTHREAD */
 576 const char cgi_h_rcs[] = CGI_H_VERSION;
 577
 578 /*
 579  * List of CGI functions: name, handler, description
 580  * Note: Do NOT use single quotes in the description;
 581  *       this will break the dynamic "blocked" template!
 582  */
 583 static const struct cgi_dispatcher cgi_dispatchers[] = {
 584    { "",
 585          cgi_default,
 586          "Privoxy main page",
 587          TRUE },
 588 #ifdef FEATURE_GRACEFUL_TERMINATION
 589    { "die",
 590          cgi_die,
 591          "<b>Shut down</b> - <em class=\"warning\">Do not deploy this build in a production environment, "
 592         "this is a one click Denial Of Service attack!!!</em>",
 593          FALSE },
 594 #endif
 595    { "show-status",
 596          cgi_show_status,
 597 #ifdef FEATURE_CGI_EDIT_ACTIONS
 598         "View &amp; change the current configuration",
 599 #else
 600         "View the current configuration",
 601 #endif
 602          TRUE },
 603    { "show-version",
 604          cgi_show_version,
 605          "View the source code version numbers",
 606           TRUE },
 607    { "show-request",
 608          cgi_show_request,
 609          "View the request headers.",
 610          TRUE },
 611    { "show-url-info",
 612          cgi_show_url_info,
 613          "Look up which actions apply to a URL and why",
 614          TRUE },
 615 #ifdef FEATURE_CGI_EDIT_ACTIONS
 616 #ifdef FEATURE_TOGGLE
 617    { "toggle",
 618          cgi_toggle,
 619          "Toggle Privoxy on or off",
 620          FALSE },
 621 #endif /* def FEATURE_TOGGLE */
 622    { "edit-actions", /* Edit the actions list */
 623          cgi_edit_actions,
 624          NULL, FALSE },
 625    { "eaa", /* Shortcut for edit-actions-add-url-form */
 626          cgi_edit_actions_add_url_form,
 627          NULL, FALSE },
 628    { "eau", /* Shortcut for edit-actions-url-form */
 629          cgi_edit_actions_url_form,
 630          NULL, FALSE },
 631    { "ear", /* Shortcut for edit-actions-remove-url-form */
 632          cgi_edit_actions_remove_url_form,
 633          NULL, FALSE },
 634    { "eal", /* Shortcut for edit-actions-list */
 635          cgi_edit_actions_list,
 636          NULL, FALSE },
 637    { "eafu", /* Shortcut for edit-actions-for-url */
 638          cgi_edit_actions_for_url,
 639          NULL, FALSE },
 640    { "eas", /* Shortcut for edit-actions-submit */
 641          cgi_edit_actions_submit,
 642          NULL, FALSE },
 643    { "easa", /* Shortcut for edit-actions-section-add */
 644          cgi_edit_actions_section_add,
 645          NULL, FALSE  },
 646    { "easr", /* Shortcut for edit-actions-section-remove */
 647          cgi_edit_actions_section_remove,
 648          NULL, FALSE  },
 649    { "eass", /* Shortcut for edit-actions-section-swap */
 650          cgi_edit_actions_section_swap,
 651          NULL, FALSE  },
 652    { "edit-actions-for-url",
 653          cgi_edit_actions_for_url,
 654          NULL, FALSE  /* Edit the actions for (a) specified URL(s) */ },
 655    { "edit-actions-list",
 656          cgi_edit_actions_list,
 657          NULL, TRUE /* Edit the actions list */ },
 658    { "edit-actions-submit",
 659          cgi_edit_actions_submit,
 660          NULL, FALSE /* Change the actions for (a) specified URL(s) */ },
 661    { "edit-actions-url",
 662          cgi_edit_actions_url,
 663          NULL, FALSE /* Change a URL pattern in the actionsfile */ },
 664    { "edit-actions-url-form",
 665          cgi_edit_actions_url_form,
 666          NULL, FALSE /* Form to change a URL pattern in the actionsfile */ },
 667    { "edit-actions-add-url",
 668          cgi_edit_actions_add_url,
 669          NULL, FALSE /* Add a URL pattern to the actionsfile */ },
 670    { "edit-actions-add-url-form",
 671          cgi_edit_actions_add_url_form,
 672          NULL, FALSE /* Form to add a URL pattern to the actionsfile */ },
 673    { "edit-actions-remove-url",
 674          cgi_edit_actions_remove_url,
 675          NULL, FALSE /* Remove a URL pattern from the actionsfile */ },
 676    { "edit-actions-remove-url-form",
 677          cgi_edit_actions_remove_url_form,
 678          NULL, FALSE /* Form to remove a URL pattern from the actionsfile */ },
 679    { "edit-actions-section-add",
 680          cgi_edit_actions_section_add,
 681          NULL, FALSE /* Remove a section from the actionsfile */ },
 682    { "edit-actions-section-remove",
 683          cgi_edit_actions_section_remove,
 684          NULL, FALSE /* Remove a section from the actionsfile */ },
 685    { "edit-actions-section-swap",
 686          cgi_edit_actions_section_swap,
 687          NULL, FALSE /* Swap two sections in the actionsfile */ },
 688 #endif /* def FEATURE_CGI_EDIT_ACTIONS */
 689    { "error-favicon.ico",
 690          cgi_send_error_favicon,
 691          NULL, TRUE /* Sends the favicon image for error pages. */ },
 692    { "favicon.ico",
 693          cgi_send_default_favicon,
 694          NULL, TRUE /* Sends the default favicon image. */ },
 695    { "robots.txt",
 696          cgi_robots_txt,
 697          NULL, TRUE /* Sends a robots.txt file to tell robots to go away. */ },
 698    { "send-banner",
 699          cgi_send_banner,
 700          NULL, TRUE /* Send a built-in image */ },
 701    { "send-stylesheet",
 702          cgi_send_stylesheet,
 703          NULL, FALSE /* Send templates/cgi-style.css */ },
 704    { "t",
 705          cgi_transparent_image,
 706          NULL, TRUE /* Send a transparent image (short name) */ },
 707    { "user-manual",
 708           cgi_send_user_manual,
 709           NULL, TRUE /* Send user-manual */ },
 710    { NULL, /* NULL Indicates end of list and default page */
 711          cgi_error_404,
 712          NULL, TRUE /* Unknown CGI page */ }
 713 };
 714
 715
 716 /*
 717  * Built-in images for ad replacement
 718  *
 719  * Hint: You can encode your own images like this:
 720  * cat your-image | perl -e 'while (read STDIN, $c, 1) { printf("\\%.3o", unpack("C", $c)); }'
 721  */
 722
 723 #ifdef FEATURE_NO_GIFS
 724
 725 /*
 726  * Checkerboard pattern, as a PNG.
 727  */
 728 const char image_pattern_data[] =
 729    "\211\120\116\107\015\012\032\012\000\000\000\015\111\110\104"
 730    "\122\000\000\000\004\000\000\000\004\010\002\000\000\000\046"
 731    "\223\011\051\000\000\000\006\142\113\107\104\000\310\000\310"
 732    "\000\310\052\045\225\037\000\000\000\032\111\104\101\124\170"
 733    "\332\143\070\161\342\304\377\377\377\041\044\003\234\165\342"
 734    "\304\011\006\234\062\000\125\200\052\251\125\174\360\223\000"
 735    "\000\000\000\111\105\116\104\256\102\140\202";
 736
 737 /*
 738  * 1x1 transparant PNG.
 739  */
 740 const char image_blank_data[] =
 741  "\211\120\116\107\015\012\032\012\000\000\000\015\111\110\104\122"
 742  "\000\000\000\001\000\000\000\001\001\003\000\000\000\045\333\126"
 743  "\312\000\000\000\003\120\114\124\105\377\377\377\247\304\033\310"
 744  "\000\000\000\001\164\122\116\123\000\100\346\330\146\000\000\000"
 745  "\001\142\113\107\104\000\210\005\035\110\000\000\000\012\111\104"
 746  "\101\124\170\001\143\140\000\000\000\002\000\001\163\165\001\030"
 747  "\000\000\000\000\111\105\116\104\256\102\140\202";
 748 #else
 749
 750 /*
 751  * Checkerboard pattern, as a GIF.
 752  */
 753 const char image_pattern_data[] =
 754    "\107\111\106\070\071\141\004\000\004\000\200\000\000\310\310"
 755    "\310\377\377\377\041\376\016\111\040\167\141\163\040\141\040"
 756    "\142\141\156\156\145\162\000\041\371\004\001\012\000\001\000"
 757    "\054\000\000\000\000\004\000\004\000\000\002\005\104\174\147"
 758    "\270\005\000\073";
 759
 760 /*
 761  * 1x1 transparant GIF.
 762  */
 763 const char image_blank_data[] =
 764    "GIF89a\001\000\001\000\200\000\000\377\377\377\000\000"
 765    "\000!\371\004\001\000\000\000\000,\000\000\000\000\001"
 766    "\000\001\000\000\002\002D\001\000;";
 767 #endif
 768
 769 const size_t image_pattern_length = sizeof(image_pattern_data) - 1;
 770 const size_t image_blank_length   = sizeof(image_blank_data) - 1;
 771
 772
 773 static struct http_response cgi_error_memory_response[1];
 774
 775 static struct http_response *dispatch_known_cgi(struct client_state * csp,
 776                                                 const char * path);
 777 static struct map *parse_cgi_parameters(char *argstring);
 778
 779
 780 /*********************************************************************
 781  *
 782  * Function    :  dispatch_cgi
 783  *
 784  * Description :  Checks if a request URL has either the magical
 785  *                hostname CGI_SITE_1_HOST (usually http://p.p/) or
 786  *                matches CGI_SITE_2_HOST CGI_SITE_2_PATH (usually
 787  *                http://config.privoxy.org/). If so, it passes
 788  *                the (rest of the) path onto dispatch_known_cgi, which
 789  *                calls the relevant CGI handler function.
 790  *
 791  * Parameters  :
 792  *          1  :  csp = Current client state (buffers, headers, etc...)
 793  *
 794  * Returns     :  http_response if match, NULL if nonmatch or handler fail
 795  *
 796  *********************************************************************/
 797 struct http_response *dispatch_cgi(struct client_state *csp)
 798 {
 799    const char *host = csp->http->host;
 800    const char *path = csp->http->path;
 801
 802    /*
 803     * Should we intercept ?
 804     */
 805
 806    /* Note: "example.com" and "example.com." are equivalent hostnames. */
 807
 808    /* Either the host matches CGI_SITE_1_HOST ..*/
 809    if (   ( (0 == strcmpic(host, CGI_SITE_1_HOST))
 810          || (0 == strcmpic(host, CGI_SITE_1_HOST ".")))
 811        && (path[0] == '/') )
 812    {
 813       /* ..then the path will all be for us.  Remove leading '/' */
 814       path++;
 815    }
 816    /* Or it's the host part CGI_SITE_2_HOST, and the path CGI_SITE_2_PATH */
 817    else if ( ( (0 == strcmpic(host, CGI_SITE_2_HOST ))
 818             || (0 == strcmpic(host, CGI_SITE_2_HOST ".")) )
 819           && (0 == strncmpic(path, CGI_SITE_2_PATH, strlen(CGI_SITE_2_PATH))) )
 820    {
 821       /* take everything following CGI_SITE_2_PATH */
 822       path += strlen(CGI_SITE_2_PATH);
 823       if (*path == '/')
 824       {
 825          /* skip the forward slash after CGI_SITE_2_PATH */
 826          path++;
 827       }
 828       else if (*path != '\0')
 829       {
 830          /*
 831           * weirdness: URL is /configXXX, where XXX is some string
 832           * Do *NOT* intercept.
 833           */
 834          return NULL;
 835       }
 836    }
 837    else
 838    {
 839       /* Not a CGI */
 840       return NULL;
 841    }
 842
 843    /*
 844     * This is a CGI call.
 845     */
 846
 847    return dispatch_known_cgi(csp, path);
 848 }
 849
 850
 851 /*********************************************************************
 852  *
 853  * Function    :  grep_cgi_referrer
 854  *
 855  * Description :  Ugly provisorical fix that greps the value of the
 856  *                referer HTTP header field out of a linked list of
 857  *                strings like found at csp->headers. Will disappear
 858  *                in Privoxy 3.1.
 859  *
 860  *                FIXME: csp->headers ought to be csp->http->headers
 861  *                FIXME: Parsing all client header lines should
 862  *                       happen right after the request is received!
 863  *
 864  * Parameters  :
 865  *          1  :  csp = Current client state (buffers, headers, etc...)
 866  *
 867  * Returns     :  pointer to value (no copy!), or NULL if none found.
 868  *
 869  *********************************************************************/
 870 char *grep_cgi_referrer(const struct client_state *csp)
 871 {
 872    struct list_entry *p;
 873
 874    for (p = csp->headers->first; p != NULL; p = p->next)
 875    {
 876       if (p->str == NULL) continue;
 877       if (strncmpic(p->str, "Referer: ", 9) == 0)
 878       {
 879          return ((p->str) + 9);
 880       }
 881    }
 882    return NULL;
 883
 884 }
 885
 886
 887 /*********************************************************************
 888  *
 889  * Function    :  referrer_is_safe
 890  *
 891  * Description :  Decides whether we trust the Referer for
 892  *                CGI pages which are only meant to be reachable
 893  *                through Privoxy's web interface directly.
 894  *
 895  * Parameters  :
 896  *          1  :  csp = Current client state (buffers, headers, etc...)
 897  *
 898  * Returns     :  TRUE  if the referrer is safe, or
 899  *                FALSE if the referrer is unsafe or not set.
 900  *
 901  *********************************************************************/
 902 int referrer_is_safe (const struct client_state *csp)
 903 {
 904    char *referrer;
 905    const char alternative_prefix[] = "http://" CGI_SITE_1_HOST "/";
 906
 907    referrer = grep_cgi_referrer(csp);
 908
 909    if (NULL == referrer)
 910    {
 911       /* No referrer, no access  */
 912       log_error(LOG_LEVEL_ERROR, "Denying access to %s. No referrer found.",
 913          csp->http->url);
 914    }
 915    else if ((0 == strncmp(referrer, CGI_PREFIX, sizeof(CGI_PREFIX)-1)
 916          || (0 == strncmp(referrer, alternative_prefix, strlen(alternative_prefix)))))
 917    {
 918       /* Trustworthy referrer */
 919       log_error(LOG_LEVEL_CGI, "Granting access to %s, referrer %s is trustworthy.",
 920          csp->http->url, referrer);
 921
 922       return TRUE;
 923    }
 924    else
 925    {
 926       /* Untrustworthy referrer */
 927       log_error(LOG_LEVEL_ERROR, "Denying access to %s, referrer %s isn't trustworthy.",
 928          csp->http->url, referrer);
 929    }
 930
 931    return FALSE;
 932
 933 }
 934
 935 /*********************************************************************
 936  *
 937  * Function    :  dispatch_known_cgi
 938  *
 939  * Description :  Processes a CGI once dispatch_cgi has determined that
 940  *                it matches one of the magic prefixes. Parses the path
 941  *                as a cgi name plus query string, prepares a map that
 942  *                maps CGI parameter names to their values, initializes
 943  *                the http_response struct, and calls the relevant CGI
 944  *                handler function.
 945  *
 946  * Parameters  :
 947  *          1  :  csp = Current client state (buffers, headers, etc...)
 948  *          2  :  path = Path of CGI, with the CGI prefix removed.
 949  *                       Should not have a leading "/".
 950  *
 951  * Returns     :  http_response, or NULL on handler failure or out of
 952  *                memory.
 953  *
 954  *********************************************************************/
 955 static struct http_response *dispatch_known_cgi(struct client_state * csp,
 956                                                 const char * path)
 957 {
 958    const struct cgi_dispatcher *d;
 959    struct map *param_list;
 960    struct http_response *rsp;
 961    char *query_args_start;
 962    char *path_copy;
 963    jb_err err;
 964
 965    if (NULL == (path_copy = strdup(path)))
 966    {
 967       return cgi_error_memory();
 968    }
 969    query_args_start = path_copy;
 970    while (*query_args_start && *query_args_start != '?' && *query_args_start != '/')
 971    {
 972       query_args_start++;
 973    }
 974    if (*query_args_start == '/')
 975    {
 976       *query_args_start++ = '\0';
 977       if ((param_list = new_map()))
 978       {
 979          map(param_list, "file", 1, url_decode(query_args_start), 0);
 980       }
 981    }
 982    else
 983    {
 984       if (*query_args_start == '?')
 985       {
 986          *query_args_start++ = '\0';
 987       }
 988       if (NULL == (param_list = parse_cgi_parameters(query_args_start)))
 989       {
 990          free(path_copy);
 991          return cgi_error_memory();
 992       }
 993    }
 994
 995    /*
 996     * At this point:
 997     * path_copy        = CGI call name
 998     * param_list       = CGI params, as map
 999     */
1000
1001    /* Get mem for response or fail*/
1002    if (NULL == (rsp = alloc_http_response()))
1003    {
1004       free(path_copy);
1005       free_map(param_list);
1006       return cgi_error_memory();
1007    }
1008
1009    log_error(LOG_LEVEL_GPC, "%s%s cgi call", csp->http->hostport, csp->http->path);
1010    log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 200 3",
1011                             csp->ip_addr_str, csp->http->cmd);
1012
1013    /*
1014     * Find and start the right CGI function
1015     */
1016    d = cgi_dispatchers;
1017    for (;;)
1018    {
1019       if ((d->name == NULL) || (strcmp(path_copy, d->name) == 0))
1020       {
1021          /*
1022           * If the called CGI is either harmless, or referred
1023           * from a trusted source, start it.
1024           */
1025          if (d->harmless || referrer_is_safe(csp))
1026          {
1027             err = (d->handler)(csp, rsp, param_list);
1028          }
1029          else
1030          {
1031             /*
1032              * Else, modify toggle calls so that they only display
1033              * the status, and deny all other calls.
1034              */
1035             if (0 == strcmp(path_copy, "toggle"))
1036             {
1037                unmap(param_list, "set");
1038                err = (d->handler)(csp, rsp, param_list);
1039             }
1040             else
1041             {
1042                err = cgi_error_disabled(csp, rsp);
1043             }
1044          }
1045
1046          free(path_copy);
1047          free_map(param_list);
1048
1049          if (err == JB_ERR_CGI_PARAMS)
1050          {
1051             err = cgi_error_bad_param(csp, rsp);
1052          }
1053          if (err && (err != JB_ERR_MEMORY))
1054          {
1055             /* Unexpected error! Shouldn't get here */
1056             log_error(LOG_LEVEL_ERROR, "Unexpected CGI error %d in top-level handler.  Please file a bug report!", err);
1057             err = cgi_error_unknown(csp, rsp, err);
1058          }
1059          if (!err)
1060          {
1061             /* It worked */
1062             return finish_http_response(rsp);
1063          }
1064          else
1065          {
1066             /* Error in handler, probably out-of-memory */
1067             free_http_response(rsp);
1068             return cgi_error_memory();
1069          }
1070       }
1071       d++;
1072    }
1073 }
1074
1075
1076 /*********************************************************************
1077  *
1078  * Function    :  parse_cgi_parameters
1079  *
1080  * Description :  Parse a URL-encoded argument string into name/value
1081  *                pairs and store them in a struct map list.
1082  *
1083  * Parameters  :
1084  *          1  :  argstring = string to be parsed.  Will be trashed.
1085  *
1086  * Returns     :  pointer to param list, or NULL if out of memory.
1087  *
1088  *********************************************************************/
1089 static struct map *parse_cgi_parameters(char *argstring)
1090 {
1091    char *p;
1092    char *vector[BUFFER_SIZE];
1093    int pairs, i;
1094    struct map *cgi_params;
1095
1096    if (NULL == (cgi_params = new_map()))
1097    {
1098       return NULL;
1099    }
1100
1101    /*
1102     * IE 5 does, of course, violate RFC 2316 Sect 4.1 and sends
1103     * the fragment identifier along with the request, so we must
1104     * cut it off here, so it won't pollute the CGI params:
1105     */
1106    if (NULL != (p = strchr(argstring, '#')))
1107    {
1108       *p = '\0';
1109    }
1110
1111    pairs = ssplit(argstring, "&", vector, SZ(vector), 1, 1);
1112
1113    for (i = 0; i < pairs; i++)
1114    {
1115       if ((NULL != (p = strchr(vector[i], '='))) && (*(p+1) != '\0'))
1116       {
1117          *p = '\0';
1118          if (map(cgi_params, url_decode(vector[i]), 0, url_decode(++p), 0))
1119          {
1120             free_map(cgi_params);
1121             return NULL;
1122          }
1123       }
1124    }
1125
1126    return cgi_params;
1127
1128 }
1129
1130
1131 /*********************************************************************
1132  *
1133  * Function    :  get_char_param
1134  *
1135  * Description :  Get a single-character parameter passed to a CGI
1136  *                function.
1137  *
1138  * Parameters  :
1139  *          1  :  parameters = map of cgi parameters
1140  *          2  :  param_name = The name of the parameter to read
1141  *
1142  * Returns     :  Uppercase character on success, '\0' on error.
1143  *
1144  *********************************************************************/
1145 char get_char_param(const struct map *parameters,
1146                     const char *param_name)
1147 {
1148    char ch;
1149
1150    assert(parameters);
1151    assert(param_name);
1152
1153    ch = *(lookup(parameters, param_name));
1154    if ((ch >= 'a') && (ch <= 'z'))
1155    {
1156       ch = (char)(ch - 'a' + 'A');
1157    }
1158
1159    return ch;
1160 }
1161
1162
1163 /*********************************************************************
1164  *
1165  * Function    :  get_string_param
1166  *
1167  * Description :  Get a string paramater, to be used as an
1168  *                ACTION_STRING or ACTION_MULTI paramater.
1169  *                Validates the input to prevent stupid/malicious
1170  *                users from corrupting their action file.
1171  *
1172  * Parameters  :
1173  *          1  :  parameters = map of cgi parameters
1174  *          2  :  param_name = The name of the parameter to read
1175  *          3  :  pparam = destination for paramater.  Allocated as
1176  *                part of the map "parameters", so don't free it.
1177  *                Set to NULL if not specified.
1178  *
1179  * Returns     :  JB_ERR_OK         on success, or if the paramater
1180  *                                  was not specified.
1181  *                JB_ERR_MEMORY     on out-of-memory.
1182  *                JB_ERR_CGI_PARAMS if the paramater is not valid.
1183  *
1184  *********************************************************************/
1185 jb_err get_string_param(const struct map *parameters,
1186                         const char *param_name,
1187                         const char **pparam)
1188 {
1189    const char *param;
1190    const char *s;
1191    char ch;
1192
1193    assert(parameters);
1194    assert(param_name);
1195    assert(pparam);
1196
1197    *pparam = NULL;
1198
1199    param = lookup(parameters, param_name);
1200    if (!*param)
1201    {
1202       return JB_ERR_OK;
1203    }
1204
1205    if (strlen(param) >= CGI_PARAM_LEN_MAX)
1206    {
1207       /*
1208        * Too long.
1209        *
1210        * Note that the length limit is arbitrary, it just seems
1211        * sensible to limit it to *something*.  There's no
1212        * technical reason for any limit at all.
1213        */
1214       return JB_ERR_CGI_PARAMS;
1215    }
1216
1217    /* Check every character to see if it's legal */
1218    s = param;
1219    while ((ch = *s++) != '\0')
1220    {
1221       if ( ((unsigned char)ch < (unsigned char)' ')
1222         || (ch == '}') )
1223       {
1224          /* Probable hack attempt, or user accidentally used '}'. */
1225          return JB_ERR_CGI_PARAMS;
1226       }
1227    }
1228
1229    /* Success */
1230    *pparam = param;
1231
1232    return JB_ERR_OK;
1233 }
1234
1235
1236 /*********************************************************************
1237  *
1238  * Function    :  get_number_param
1239  *
1240  * Description :  Get a non-negative integer from the parameters
1241  *                passed to a CGI function.
1242  *
1243  * Parameters  :
1244  *          1  :  csp = Current client state (buffers, headers, etc...)
1245  *          2  :  parameters = map of cgi parameters
1246  *          3  :  name = Name of CGI parameter to read
1247  *          4  :  pvalue = destination for value.
1248  *                         Set to -1 on error.
1249  *
1250  * Returns     :  JB_ERR_OK         on success
1251  *                JB_ERR_MEMORY     on out-of-memory
1252  *                JB_ERR_CGI_PARAMS if the parameter was not specified
1253  *                                  or is not valid.
1254  *
1255  *********************************************************************/
1256 jb_err get_number_param(struct client_state *csp,
1257                         const struct map *parameters,
1258                         char *name,
1259                         unsigned *pvalue)
1260 {
1261    const char *param;
1262    char ch;
1263    unsigned value;
1264
1265    assert(csp);
1266    assert(parameters);
1267    assert(name);
1268    assert(pvalue);
1269
1270    *pvalue = 0;
1271
1272    param = lookup(parameters, name);
1273    if (!*param)
1274    {
1275       return JB_ERR_CGI_PARAMS;
1276    }
1277
1278    /* We don't use atoi because I want to check this carefully... */
1279
1280    value = 0;
1281    while ((ch = *param++) != '\0')
1282    {
1283       if ((ch < '0') || (ch > '9'))
1284       {
1285          return JB_ERR_CGI_PARAMS;
1286       }
1287
1288       ch = (char)(ch - '0');
1289
1290       /* Note:
1291        *
1292        * <limits.h> defines UINT_MAX
1293        *
1294        * (UINT_MAX - ch) / 10 is the largest number that
1295        *     can be safely multiplied by 10 then have ch added.
1296        */
1297       if (value > ((UINT_MAX - (unsigned)ch) / 10U))
1298       {
1299          return JB_ERR_CGI_PARAMS;
1300       }
1301
1302       value = value * 10 + (unsigned)ch;
1303    }
1304
1305    /* Success */
1306    *pvalue = value;
1307
1308    return JB_ERR_OK;
1309
1310 }
1311
1312
1313 /*********************************************************************
1314  *
1315  * Function    :  error_response
1316  *
1317  * Description :  returns an http_response that explains the reason
1318  *                why a request failed.
1319  *
1320  * Parameters  :
1321  *          1  :  csp = Current client state (buffers, headers, etc...)
1322  *          2  :  templatename = Which template should be used for the answer
1323  *          3  :  sys_err = system error number
1324  *
1325  * Returns     :  A http_response.  If we run out of memory, this
1326  *                will be cgi_error_memory().
1327  *
1328  *********************************************************************/
1329 struct http_response *error_response(struct client_state *csp,
1330                                      const char *templatename,
1331                                      int sys_err)
1332 {
1333    jb_err err;
1334    struct http_response *rsp;
1335    struct map *exports = default_exports(csp, NULL);
1336    char *path = NULL;
1337
1338    if (exports == NULL)
1339    {
1340       return cgi_error_memory();
1341    }
1342
1343    if (NULL == (rsp = alloc_http_response()))
1344    {
1345       free_map(exports);
1346       return cgi_error_memory();
1347    }
1348
1349    if (csp->flags & CSP_FLAG_FORCED)
1350    {
1351       path = strdup(FORCE_PREFIX);
1352    }
1353    else
1354    {
1355       path = strdup("");
1356    }
1357    err = string_append(&path, csp->http->path);
1358
1359    if (!err) err = map(exports, "host", 1, html_encode(csp->http->host), 0);
1360    if (!err) err = map(exports, "hostport", 1, html_encode(csp->http->hostport), 0);
1361    if (!err) err = map(exports, "path", 1, html_encode_and_free_original(path), 0);
1362    if (!err) err = map(exports, "error", 1, html_encode_and_free_original(safe_strerror(sys_err)), 0);
1363    if (!err) err = map(exports, "protocol", 1, csp->http->ssl ? "https://" : "http://", 1);
1364    if (!err)
1365    {
1366      err = map(exports, "host-ip", 1, html_encode(csp->http->host_ip_addr_str), 0);
1367      if (err)
1368      {
1369        /* Some failures, like "404 no such domain", don't have an IP address. */
1370        err = map(exports, "host-ip", 1, html_encode(csp->http->host), 0);
1371      }
1372    }
1373
1374
1375    if (err)
1376    {
1377       free_map(exports);
1378       free_http_response(rsp);
1379       return cgi_error_memory();
1380    }
1381
1382    if (!strcmp(templatename, "no-such-domain"))
1383    {
1384       rsp->status = strdup("404 No such domain");
1385       if (rsp->status == NULL)
1386       {
1387          free_map(exports);
1388          free_http_response(rsp);
1389          return cgi_error_memory();
1390       }
1391    }
1392    else if (!strcmp(templatename, "connect-failed"))
1393    {
1394       rsp->status = strdup("503 Connect failed");
1395       if (rsp->status == NULL)
1396       {
1397          free_map(exports);
1398          free_http_response(rsp);
1399          return cgi_error_memory();
1400       }
1401    }
1402
1403    err = template_fill_for_cgi(csp, templatename, exports, rsp);
1404    if (err)
1405    {
1406       free_http_response(rsp);
1407       return cgi_error_memory();
1408    }
1409
1410    return finish_http_response(rsp);
1411 }
1412
1413
1414 /*********************************************************************
1415  *
1416  * Function    :  cgi_error_disabled
1417  *
1418  * Description :  CGI function that is called to generate an error
1419  *                response if the actions editor or toggle CGI are
1420  *                accessed despite having being disabled at compile-
1421  *                or run-time, or if the user followed an untrusted link
1422  *                to access a unsafe CGI feature that is only reachable
1423  *                through Privoxy directly.
1424  *
1425  * Parameters  :
1426  *          1  :  csp = Current client state (buffers, headers, etc...)
1427  *          2  :  rsp = http_response data structure for output
1428  *
1429  * CGI Parameters : none
1430  *
1431  * Returns     :  JB_ERR_OK on success
1432  *                JB_ERR_MEMORY on out-of-memory error.
1433  *
1434  *********************************************************************/
1435 jb_err cgi_error_disabled(struct client_state *csp,
1436                           struct http_response *rsp)
1437 {
1438    struct map *exports;
1439
1440    assert(csp);
1441    assert(rsp);
1442
1443    if (NULL == (exports = default_exports(csp, "cgi-error-disabled")))
1444    {
1445       return JB_ERR_MEMORY;
1446    }
1447    if (map(exports, "url", 1, html_encode(csp->http->url), 0))
1448    {
1449       /* Not important enough to do anything */
1450       log_error(LOG_LEVEL_ERROR, "Failed to fill in url.");
1451    }
1452
1453    return template_fill_for_cgi(csp, "cgi-error-disabled", exports, rsp);
1454 }
1455
1456
1457 /*********************************************************************
1458  *
1459  * Function    :  cgi_init_error_messages
1460  *
1461  * Description :  Call at the start of the program to initialize
1462  *                the error message used by cgi_error_memory().
1463  *
1464  * Parameters  :  N/A
1465  *
1466  * Returns     :  N/A
1467  *
1468  *********************************************************************/
1469 void cgi_init_error_messages(void)
1470 {
1471    memset(cgi_error_memory_response, '\0', sizeof(*cgi_error_memory_response));
1472    cgi_error_memory_response->head =
1473       "HTTP/1.0 500 Internal Privoxy Error\r\n"
1474       "Content-Type: text/html\r\n"
1475       "\r\n";
1476    cgi_error_memory_response->body =
1477       "<html>\r\n"
1478       "<head><title>500 Internal Privoxy Error</title></head>\r\n"
1479       "<body>\r\n"
1480       "<h1>500 Internal Privoxy Error</h1>\r\n"
1481       "<p>Privoxy <b>ran out of memory</b> while processing your request.</p>\r\n"
1482       "<p>Please contact your proxy administrator, or try again later</p>\r\n"
1483       "</body>\r\n"
1484       "</html>\r\n";
1485
1486    cgi_error_memory_response->head_length =
1487       strlen(cgi_error_memory_response->head);
1488    cgi_error_memory_response->content_length =
1489       strlen(cgi_error_memory_response->body);
1490 }
1491
1492
1493 /*********************************************************************
1494  *
1495  * Function    :  cgi_error_memory
1496  *
1497  * Description :  Called if a CGI function runs out of memory.
1498  *                Returns a statically-allocated error response.
1499  *
1500  * Parameters  :  N/A
1501  *
1502  * Returns     :  http_response data structure for output.  This is
1503  *                statically allocated, for obvious reasons.
1504  *
1505  *********************************************************************/
1506 struct http_response *cgi_error_memory(void)
1507 {
1508    /* assert that it's been initialized. */
1509    assert(cgi_error_memory_response->head);
1510
1511    return cgi_error_memory_response;
1512 }
1513
1514
1515 /*********************************************************************
1516  *
1517  * Function    :  cgi_error_no_template
1518  *
1519  * Description :  Almost-CGI function that is called if a template
1520  *                cannot be loaded.  Note this is not a true CGI,
1521  *                it takes a template name rather than a map of
1522  *                parameters.
1523  *
1524  * Parameters  :
1525  *          1  :  csp = Current client state (buffers, headers, etc...)
1526  *          2  :  rsp = http_response data structure for output
1527  *          3  :  template_name = Name of template that could not
1528  *                                be loaded.
1529  *
1530  * Returns     :  JB_ERR_OK on success
1531  *                JB_ERR_MEMORY on out-of-memory error.
1532  *
1533  *********************************************************************/
1534 jb_err cgi_error_no_template(struct client_state *csp,
1535                              struct http_response *rsp,
1536                              const char *template_name)
1537 {
1538    static const char status[] =
1539       "500 Internal Privoxy Error";
1540    static const char body_prefix[] =
1541       "<html>\r\n"
1542       "<head><title>500 Internal Privoxy Error</title></head>\r\n"
1543       "<body>\r\n"
1544       "<h1>500 Internal Privoxy Error</h1>\r\n"
1545       "<p>Privoxy encountered an error while processing your request:</p>\r\n"
1546       "<p><b>Could not load template file <code>";
1547    static const char body_suffix[] =
1548       "</code> or one of it's included components.</b></p>\r\n"
1549       "<p>Please contact your proxy administrator.</p>\r\n"
1550       "<p>If you are the proxy administrator, please put the required file(s)"
1551       "in the <code><i>(confdir)</i>/templates</code> directory.  The "
1552       "location of the <code><i>(confdir)</i></code> directory "
1553       "is specified in the main Privoxy <code>config</code> "
1554       "file.  (It's typically the Privoxy install directory"
1555 #ifndef _WIN32
1556       ", or <code>/etc/privoxy/</code>"
1557 #endif /* ndef _WIN32 */
1558       ").</p>\r\n"
1559       "</body>\r\n"
1560       "</html>\r\n";
1561
1562    assert(csp);
1563    assert(rsp);
1564    assert(template_name);
1565
1566    /* Reset rsp, if needed */
1567    freez(rsp->status);
1568    freez(rsp->head);
1569    freez(rsp->body);
1570    rsp->content_length = 0;
1571    rsp->head_length = 0;
1572    rsp->is_static = 0;
1573
1574    rsp->body = malloc(strlen(body_prefix) + strlen(template_name) + strlen(body_suffix) + 1);
1575    if (rsp->body == NULL)
1576    {
1577       return JB_ERR_MEMORY;
1578    }
1579    strcpy(rsp->body, body_prefix);
1580    strcat(rsp->body, template_name);
1581    strcat(rsp->body, body_suffix);
1582
1583    rsp->status = strdup(status);
1584    if (rsp->status == NULL)
1585    {
1586       return JB_ERR_MEMORY;
1587    }
1588
1589    return JB_ERR_OK;
1590 }
1591
1592
1593 /*********************************************************************
1594  *
1595  * Function    :  cgi_error_unknown
1596  *
1597  * Description :  Almost-CGI function that is called if an unexpected
1598  *                error occurs in the top-level CGI dispatcher.
1599  *                In this context, "unexpected" means "anything other
1600  *                than JB_ERR_MEMORY or JB_ERR_CGI_PARAMS" - CGIs are
1601  *                expected to handle all other errors internally,
1602  *                since they can give more relavent error messages
1603  *                that way.
1604  *
1605  *                Note this is not a true CGI, it takes an error
1606  *                code rather than a map of parameters.
1607  *
1608  * Parameters  :
1609  *          1  :  csp = Current client state (buffers, headers, etc...)
1610  *          2  :  rsp = http_response data structure for output
1611  *          3  :  error_to_report = Error code to report.
1612  *
1613  * Returns     :  JB_ERR_OK on success
1614  *                JB_ERR_MEMORY on out-of-memory error.
1615  *
1616  *********************************************************************/
1617 jb_err cgi_error_unknown(struct client_state *csp,
1618                          struct http_response *rsp,
1619                          jb_err error_to_report)
1620 {
1621    static const char status[] =
1622       "500 Internal Privoxy Error";
1623    static const char body_prefix[] =
1624       "<html>\r\n"
1625       "<head><title>500 Internal Privoxy Error</title></head>\r\n"
1626       "<body>\r\n"
1627       "<h1>500 Internal Privoxy Error</h1>\r\n"
1628       "<p>Privoxy encountered an error while processing your request:</p>\r\n"
1629       "<p><b>Unexpected internal error: ";
1630    static const char body_suffix[] =
1631       "</b></p>\r\n"
1632       "<p>Please "
1633       "<a href=\"http://sourceforge.net/tracker/?group_id=11118&atid=111118\">"
1634       "file a bug report</a>.</p>\r\n"
1635       "</body>\r\n"
1636       "</html>\r\n";
1637    char errnumbuf[30];
1638    assert(csp);
1639    assert(rsp);
1640
1641    /* Reset rsp, if needed */
1642    freez(rsp->status);
1643    freez(rsp->head);
1644    freez(rsp->body);
1645    rsp->content_length = 0;
1646    rsp->head_length = 0;
1647    rsp->is_static = 0;
1648
1649    snprintf(errnumbuf, sizeof(errnumbuf), "%d", error_to_report);
1650
1651    rsp->body = malloc(strlen(body_prefix) + strlen(errnumbuf) + strlen(body_suffix) + 1);
1652    if (rsp->body == NULL)
1653    {
1654       return JB_ERR_MEMORY;
1655    }
1656    strcpy(rsp->body, body_prefix);
1657    strcat(rsp->body, errnumbuf);
1658    strcat(rsp->body, body_suffix);
1659
1660    rsp->status = strdup(status);
1661    if (rsp->status == NULL)
1662    {
1663       return JB_ERR_MEMORY;
1664    }
1665
1666    return JB_ERR_OK;
1667 }
1668
1669
1670 /*********************************************************************
1671  *
1672  * Function    :  cgi_error_bad_param
1673  *
1674  * Description :  CGI function that is called if the parameters
1675  *                (query string) for a CGI were wrong.
1676  *
1677  * Parameters  :
1678  *          1  :  csp = Current client state (buffers, headers, etc...)
1679  *          2  :  rsp = http_response data structure for output
1680  *
1681  * CGI Parameters : none
1682  *
1683  * Returns     :  JB_ERR_OK on success
1684  *                JB_ERR_MEMORY on out-of-memory error.
1685  *
1686  *********************************************************************/
1687 jb_err cgi_error_bad_param(struct client_state *csp,
1688                            struct http_response *rsp)
1689 {
1690    struct map *exports;
1691
1692    assert(csp);
1693    assert(rsp);
1694
1695    if (NULL == (exports = default_exports(csp, NULL)))
1696    {
1697       return JB_ERR_MEMORY;
1698    }
1699
1700    return template_fill_for_cgi(csp, "cgi-error-bad-param", exports, rsp);
1701 }
1702
1703
1704 /*********************************************************************
1705  *
1706  * Function    :  cgi_redirect
1707  *
1708  * Description :  CGI support function to generate a HTTP redirect
1709  *                message
1710  *
1711  * Parameters  :
1712  *          1  :  rsp = http_response data structure for output
1713  *          2  :  target = string with the target URL
1714  *
1715  * CGI Parameters : None
1716  *
1717  * Returns     :  JB_ERR_OK on success
1718  *                JB_ERR_MEMORY on out-of-memory error.
1719  *
1720  *********************************************************************/
1721 jb_err cgi_redirect (struct http_response * rsp, const char *target)
1722 {
1723    jb_err err;
1724
1725    assert(rsp);
1726    assert(target);
1727
1728    err = enlist_unique_header(rsp->headers, "Location", target);
1729
1730    rsp->status = strdup("302 Local Redirect from Privoxy");
1731    if (rsp->status == NULL)
1732    {
1733       return JB_ERR_MEMORY;
1734    }
1735
1736    return err;
1737 }
1738
1739
1740 /*********************************************************************
1741  *
1742  * Function    :  add_help_link
1743  *
1744  * Description :  Produce a copy of the string given as item,
1745  *                embedded in an HTML link to its corresponding
1746  *                section (item name in uppercase) in the actions
1747  *                chapter of the user manual, (whose URL is given in
1748  *                the config and defaults to our web site).
1749  *
1750  *                FIXME: I currently only work for actions, and would
1751  *                       like to be generalized for other topics.
1752  *
1753  * Parameters  :
1754  *          1  :  item = item (will NOT be free()d.)
1755  *                       It is assumed to be HTML-safe.
1756  *          2  :  config = The current configuration.
1757  *
1758  * Returns     :  String with item embedded in link, or NULL on
1759  *                out-of-memory
1760  *
1761  *********************************************************************/
1762 char *add_help_link(const char *item,
1763                     struct configuration_spec *config)
1764 {
1765    char *result;
1766
1767    if (!item) return NULL;
1768
1769    result = strdup("<a href=\"");
1770    if (!strncmpic(config->usermanual, "file://", 7) ||
1771        !strncmpic(config->usermanual, "http", 4))
1772    {
1773       string_append(&result, config->usermanual);
1774    }
1775    else
1776    {
1777       string_append(&result, "http://");
1778       string_append(&result, CGI_SITE_2_HOST);
1779       string_append(&result, "/user-manual/");
1780    }
1781    string_append(&result, ACTIONS_HELP_PREFIX);
1782    string_join  (&result, string_toupper(item));
1783    string_append(&result, "\">");
1784    string_append(&result, item);
1785    string_append(&result, "</a> ");
1786
1787    return result;
1788 }
1789
1790
1791 /*********************************************************************
1792  *
1793  * Function    :  get_http_time
1794  *
1795  * Description :  Get the time in a format suitable for use in a
1796  *                HTTP header - e.g.:
1797  *                "Sun, 06 Nov 1994 08:49:37 GMT"
1798  *
1799  * Parameters  :
1800  *          1  :  time_offset = Time returned will be current time
1801  *                              plus this number of seconds.
1802  *          2  :  buf = Destination for result.  Must be long enough
1803  *                      to hold 29 characters plus a trailing zero.
1804  *
1805  * Returns     :  N/A
1806  *
1807  *********************************************************************/
1808 void get_http_time(int time_offset, char *buf)
1809 {
1810    static const char day_names[7][4] =
1811       { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
1812    static const char month_names[12][4] =
1813       { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
1814         "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
1815
1816    struct tm *t;
1817    time_t current_time;
1818 #if defined(HAVE_GMTIME_R)
1819    /*
1820     * Declare dummy up here (instead of inside get/set gmt block) so it
1821     * doesn't go out of scope before it's potentially used in snprintf later.
1822     * Wrapping declaration inside HAVE_GMTIME_R keeps the compiler quiet when
1823     * !defined HAVE_GMTIME_R.
1824     */
1825    struct tm dummy;
1826 #endif
1827
1828    assert(buf);
1829
1830    time(&current_time); /* get current time */
1831
1832    current_time += time_offset;
1833
1834    /* get and save the gmt */
1835    {
1836 #if HAVE_GMTIME_R
1837       t = gmtime_r(&current_time, &dummy);
1838 #elif FEATURE_PTHREAD
1839       pthread_mutex_lock(&gmtime_mutex);
1840       t = gmtime(&current_time);
1841       pthread_mutex_unlock(&gmtime_mutex);
1842 #else
1843       t = gmtime(&current_time);
1844 #endif
1845    }
1846
1847    /* Format: "Sun, 06 Nov 1994 08:49:37 GMT" */
1848    snprintf(buf, 30,
1849       "%s, %02d %s %4d %02d:%02d:%02d GMT",
1850       day_names[t->tm_wday],
1851       t->tm_mday,
1852       month_names[t->tm_mon],
1853       t->tm_year + 1900,
1854       t->tm_hour,
1855       t->tm_min,
1856       t->tm_sec
1857       );
1858
1859 }
1860
1861
1862 /*********************************************************************
1863  *
1864  * Function    :  finish_http_response
1865  *
1866  * Description :  Fill in the missing headers in an http response,
1867  *                and flatten the headers to an http head.
1868  *
1869  * Parameters  :
1870  *          1  :  rsp = pointer to http_response to be processed
1871  *
1872  * Returns     :  A http_response, usually the rsp parameter.
1873  *                On error, free()s rsp and returns cgi_error_memory()
1874  *
1875  *********************************************************************/
1876 struct http_response *finish_http_response(struct http_response *rsp)
1877 {
1878    char buf[BUFFER_SIZE];
1879    jb_err err;
1880
1881    /* Special case - do NOT change this statically allocated response,
1882     * which is ready for output anyway.
1883     */
1884    if (rsp == cgi_error_memory_response)
1885    {
1886       return rsp;
1887    }
1888
1889    /*
1890     * Fill in the HTTP Status
1891     */
1892    snprintf(buf, sizeof(buf), "HTTP/1.0 %s", rsp->status ? rsp->status : "200 OK");
1893    err = enlist_first(rsp->headers, buf);
1894
1895    /*
1896     * Set the Content-Length
1897     */
1898    if (rsp->content_length == 0)
1899    {
1900       rsp->content_length = rsp->body ? strlen(rsp->body) : 0;
1901    }
1902    if (!err)
1903    {
1904       snprintf(buf, sizeof(buf), "Content-Length: %d", (int)rsp->content_length);
1905       err = enlist(rsp->headers, buf);
1906    }
1907
1908    if (strncmpic(rsp->status, "302", 3))
1909    {
1910      /*
1911       * If it's not a redirect without any content,
1912       * set the Content-Type to text/html if it's
1913       * not already specified.
1914       */
1915      if (!err) err = enlist_unique(rsp->headers, "Content-Type: text/html", 13);
1916    }
1917
1918    /*
1919     * Fill in the rest of the default headers:
1920     *
1921     * Date: set to current date/time.
1922     * Last-Modified: set to date/time the page was last changed.
1923     * Expires: set to date/time page next needs reloading.
1924     * Cache-Control: set to "no-cache" if applicable.
1925     *
1926     * See http://www.w3.org/Protocols/rfc2068/rfc2068
1927     */
1928    if (rsp->is_static)
1929    {
1930       /*
1931        * Set Expires to about 10 min into the future so it'll get reloaded
1932        * occasionally, e.g. if Privoxy gets upgraded.
1933        */
1934
1935       if (!err)
1936       {
1937          get_http_time(0, buf);
1938          err = enlist_unique_header(rsp->headers, "Date", buf);
1939       }
1940
1941       /* Some date in the past. */
1942       if (!err) err = enlist_unique_header(rsp->headers, "Last-Modified", "Sat, 17 Jun 2000 12:00:00 GMT");
1943
1944       if (!err)
1945       {
1946          get_http_time(10 * 60, buf); /* 10 * 60sec = 10 minutes */
1947          err = enlist_unique_header(rsp->headers, "Expires", buf);
1948       }
1949    }
1950    else if (!strncmpic(rsp->status, "302", 3))
1951    {
1952       get_http_time(0, buf);
1953       if (!err) err = enlist_unique_header(rsp->headers, "Date", buf);
1954    }
1955    else
1956    {
1957       /*
1958        * Setting "Cache-Control" to "no-cache" and  "Expires" to
1959        * the current time doesn't exactly forbid caching, it just
1960        * requires the client to revalidate the cached copy.
1961        *
1962        * If a temporary problem occurs and the user tries again after
1963        * getting Privoxy's error message, a compliant browser may set the
1964        * If-Modified-Since header with the content of the error page's
1965        * Last-Modified header. More often than not, the document on the server
1966        * is older than Privoxy's error message, the server would send status code
1967        * 304 and the browser would display the outdated error message again and again.
1968        *
1969        * For documents delivered with status code 404 or 503 we set "Last-Modified"
1970        * to Tim Berners-Lee's birthday, which predates the age of any page on the web
1971        * and can be safely used to "revalidate" without getting a status code 304.
1972        *
1973        * There is no need to let the useless If-Modified-Since header reach the
1974        * server, it is therefore stripped by client_if_modified_since in parsers.c.
1975        */
1976       if (!err) err = enlist_unique_header(rsp->headers, "Cache-Control", "no-cache");
1977
1978       get_http_time(0, buf);
1979       if (!err) err = enlist_unique_header(rsp->headers, "Date", buf);
1980       if (!strncmpic(rsp->status, "404", 3) || !strncmpic(rsp->status, "503", 3))
1981       {
1982          if (!err) err = enlist_unique_header(rsp->headers, "Last-Modified", "Wed, 08 Jun 1955 12:00:00 GMT");
1983       }
1984       else
1985       {
1986          if (!err) err = enlist_unique_header(rsp->headers, "Last-Modified", buf);
1987       }
1988       if (!err) err = enlist_unique_header(rsp->headers, "Expires", "Sat, 17 Jun 2000 12:00:00 GMT");
1989       if (!err) err = enlist_unique_header(rsp->headers, "Pragma", "no-cache");
1990    }
1991
1992    /*
1993     * Quoting RFC 2616:
1994     *
1995     * HTTP/1.1 applications that do not support persistent connections MUST
1996     * include the "close" connection option in every message.
1997     */
1998    if (!err) err = enlist_unique_header(rsp->headers, "Connection", "close");
1999
2000    /*
2001     * Write the head
2002     */
2003    if (err || (NULL == (rsp->head = list_to_text(rsp->headers))))
2004    {
2005       free_http_response(rsp);
2006       return cgi_error_memory();
2007    }
2008    rsp->head_length = strlen(rsp->head);
2009
2010    return rsp;
2011
2012 }
2013
2014
2015 /*********************************************************************
2016  *
2017  * Function    :  alloc_http_response
2018  *
2019  * Description :  Allocates a new http_response structure.
2020  *
2021  * Parameters  :  N/A
2022  *
2023  * Returns     :  pointer to a new http_response, or NULL.
2024  *
2025  *********************************************************************/
2026 struct http_response *alloc_http_response(void)
2027 {
2028    return (struct http_response *) zalloc(sizeof(struct http_response));
2029
2030 }
2031
2032
2033 /*********************************************************************
2034  *
2035  * Function    :  free_http_response
2036  *
2037  * Description :  Free the memory occupied by an http_response
2038  *                and its depandant structures.
2039  *
2040  * Parameters  :
2041  *          1  :  rsp = pointer to http_response to be freed
2042  *
2043  * Returns     :  N/A
2044  *
2045  *********************************************************************/
2046 void free_http_response(struct http_response *rsp)
2047 {
2048    /*
2049     * Must special case cgi_error_memory_response, which is never freed.
2050     */
2051    if (rsp && (rsp != cgi_error_memory_response))
2052    {
2053       freez(rsp->status);
2054       freez(rsp->head);
2055       freez(rsp->body);
2056       destroy_list(rsp->headers);
2057       free(rsp);
2058    }
2059
2060 }
2061
2062
2063 /*********************************************************************
2064  *
2065  * Function    :  template_load
2066  *
2067  * Description :  CGI support function that loads a given HTML
2068  *                template from the confdir, ignoring comment
2069  *                lines and following #include statements up to
2070  *                a depth of 1.
2071  *
2072  * Parameters  :
2073  *          1  :  csp = Current client state (buffers, headers, etc...)
2074  *          2  :  template_ptr = Destination for pointer to loaded
2075  *                               template text.
2076  *          3  :  templatename = name of the HTML template to be used
2077  *          4  :  recursive = Flag set if this function calls itself
2078  *                            following an #include statament
2079  *
2080  * Returns     :  JB_ERR_OK on success
2081  *                JB_ERR_MEMORY on out-of-memory error.
2082  *                JB_ERR_FILE if the template file cannot be read
2083  *
2084  *********************************************************************/
2085 jb_err template_load(struct client_state *csp, char **template_ptr,
2086                      const char *templatename, int recursive)
2087 {
2088    jb_err err;
2089    char *templates_dir_path;
2090    char *full_path;
2091    char *file_buffer;
2092    char *included_module;
2093    const char *p;
2094    FILE *fp;
2095    char buf[BUFFER_SIZE];
2096
2097    assert(csp);
2098    assert(template_ptr);
2099    assert(templatename);
2100
2101    *template_ptr = NULL;
2102
2103    /* Validate template name.  Paranoia. */
2104    for (p = templatename; *p != 0; p++)
2105    {
2106       if ( ((*p < 'a') || (*p > 'z'))
2107         && ((*p < 'A') || (*p > 'Z'))
2108         && ((*p < '0') || (*p > '9'))
2109         && (*p != '-')
2110         && (*p != '.'))
2111       {
2112          /* Illegal character */
2113          return JB_ERR_FILE;
2114       }
2115    }
2116
2117    /* Generate full path */
2118
2119    templates_dir_path = make_path(csp->config->confdir, "templates");
2120    if (templates_dir_path == NULL)
2121    {
2122       return JB_ERR_MEMORY;
2123    }
2124
2125    full_path = make_path(templates_dir_path, templatename);
2126    free(templates_dir_path);
2127    if (full_path == NULL)
2128    {
2129       return JB_ERR_MEMORY;
2130    }
2131
2132    /* Allocate buffer */
2133
2134    file_buffer = strdup("");
2135    if (file_buffer == NULL)
2136    {
2137       free(full_path);
2138       return JB_ERR_MEMORY;
2139    }
2140
2141    /* Open template file */
2142
2143    if (NULL == (fp = fopen(full_path, "r")))
2144    {
2145       log_error(LOG_LEVEL_ERROR, "Cannot open template file %s: %E", full_path);
2146       free(full_path);
2147       free(file_buffer);
2148       return JB_ERR_FILE;
2149    }
2150    free(full_path);
2151
2152    /*
2153     * Read the file, ignoring comments, and honoring #include
2154     * statements, unless we're already called recursively.
2155     *
2156     * FIXME: The comment handling could break with lines >BUFFER_SIZE long.
2157     *        This is unlikely in practise.
2158     */
2159    while (fgets(buf, BUFFER_SIZE, fp))
2160    {
2161       if (!recursive && !strncmp(buf, "#include ", 9))
2162       {
2163          if (JB_ERR_OK != (err = template_load(csp, &included_module, chomp(buf + 9), 1)))
2164          {
2165             free(file_buffer);
2166             fclose(fp);
2167             return err;
2168          }
2169
2170          if (string_join(&file_buffer, included_module))
2171          {
2172             fclose(fp);
2173             return JB_ERR_MEMORY;
2174          }
2175
2176          continue;
2177       }
2178
2179       /* skip lines starting with '#' */
2180       if (*buf == '#')
2181       {
2182          continue;
2183       }
2184
2185       if (string_append(&file_buffer, buf))
2186       {
2187          fclose(fp);
2188          return JB_ERR_MEMORY;
2189       }
2190    }
2191    fclose(fp);
2192
2193    *template_ptr = file_buffer;
2194
2195    return JB_ERR_OK;
2196 }
2197
2198
2199 /*********************************************************************
2200  *
2201  * Function    :  template_fill
2202  *
2203  * Description :  CGI support function that fills in a pre-loaded
2204  *                HTML template by replacing @name@ with value using
2205  *                pcrs, for each item in the output map.
2206  *
2207  *                Note that a leading '$' charachter in the export map's
2208  *                values will be stripped and toggle on backreference
2209  *                interpretation.
2210  *
2211  * Parameters  :
2212  *          1  :  template_ptr = IN: Template to be filled out.
2213  *                                   Will be free()d.
2214  *                               OUT: Filled out template.
2215  *                                    Caller must free().
2216  *          2  :  exports = map with fill in symbol -> name pairs
2217  *
2218  * Returns     :  JB_ERR_OK on success (and for uncritical errors)
2219  *                JB_ERR_MEMORY on out-of-memory error
2220  *
2221  *********************************************************************/
2222 jb_err template_fill(char **template_ptr, const struct map *exports)
2223 {
2224    struct map_entry *m;
2225    pcrs_job *job;
2226    char buf[BUFFER_SIZE];
2227    char *tmp_out_buffer;
2228    char *file_buffer;
2229    size_t  size;
2230    int error;
2231    const char *flags;
2232
2233    assert(template_ptr);
2234    assert(*template_ptr);
2235    assert(exports);
2236
2237    file_buffer = *template_ptr;
2238    size = strlen(file_buffer) + 1;
2239
2240    /*
2241     * Assemble pcrs joblist from exports map
2242     */
2243    for (m = exports->first; m != NULL; m = m->next)
2244    {
2245       if (*m->name == '$')
2246       {
2247          /*
2248           * First character of name is '$', so remove this flag
2249           * character and allow backreferences ($1 etc) in the
2250           * "replace with" text.
2251           */
2252          snprintf(buf, BUFFER_SIZE, "%s", m->name + 1);
2253          flags = "sigU";
2254       }
2255       else
2256       {
2257          /*
2258           * Treat the "replace with" text as a literal string -
2259           * no quoting needed, no backreferences allowed.
2260           * ("Trivial" ['T'] flag).
2261           */
2262          flags = "sigTU";
2263
2264          /* Enclose name in @@ */
2265          snprintf(buf, BUFFER_SIZE, "@%s@", m->name);
2266       }
2267
2268
2269       log_error(LOG_LEVEL_CGI, "Substituting: s/%s/%s/%s", buf, m->value, flags);
2270
2271       /* Make and run job. */
2272       job = pcrs_compile(buf, m->value, flags,  &error);
2273       if (job == NULL)
2274       {
2275          if (error == PCRS_ERR_NOMEM)
2276          {
2277             free(file_buffer);
2278             *template_ptr = NULL;
2279             return JB_ERR_MEMORY;
2280          }
2281          else
2282          {
2283             log_error(LOG_LEVEL_ERROR, "Error compiling template fill job %s: %d", m->name, error);
2284             /* Hope it wasn't important and silently ignore the invalid job */
2285          }
2286       }
2287       else
2288       {
2289          error = pcrs_execute(job, file_buffer, size, &tmp_out_buffer, &size);
2290
2291          pcrs_free_job(job);
2292          if (NULL == tmp_out_buffer)
2293          {
2294             *template_ptr = NULL;
2295             return JB_ERR_MEMORY;
2296          }
2297
2298          if (error < 0)
2299          {
2300             /*
2301              * Substitution failed, keep the original buffer,
2302              * log the problem and ignore it.
2303              *
2304              * The user might see some unresolved @CGI_VARIABLES@,
2305              * but returning a special CGI error page seems unreasonable
2306              * and could mask more important error messages.
2307              */
2308             free(tmp_out_buffer);
2309             log_error(LOG_LEVEL_ERROR, "Failed to execute s/%s/%s/%s. %s",
2310                buf, m->value, flags, pcrs_strerror(error));
2311          }
2312          else
2313          {
2314             /* Substitution succeeded, use modified buffer. */
2315             free(file_buffer);
2316             file_buffer = tmp_out_buffer;
2317          }
2318       }
2319    }
2320
2321    /*
2322     * Return
2323     */
2324    *template_ptr = file_buffer;
2325    return JB_ERR_OK;
2326 }
2327
2328
2329 /*********************************************************************
2330  *
2331  * Function    :  template_fill_for_cgi
2332  *
2333  * Description :  CGI support function that loads a HTML template
2334  *                and fills it in.  Handles file-not-found errors
2335  *                by sending a HTML error message.  For convenience,
2336  *                this function also frees the passed "exports" map.
2337  *
2338  * Parameters  :
2339  *          1  :  csp = Client state
2340  *          2  :  templatename = name of the HTML template to be used
2341  *          3  :  exports = map with fill in symbol -> name pairs.
2342  *                          Will be freed by this function.
2343  *          4  :  rsp = Response structure to fill in.
2344  *
2345  * Returns     :  JB_ERR_OK on success
2346  *                JB_ERR_MEMORY on out-of-memory error
2347  *
2348  *********************************************************************/
2349 jb_err template_fill_for_cgi(struct client_state *csp,
2350                              const char *templatename,
2351                              struct map *exports,
2352                              struct http_response *rsp)
2353 {
2354    jb_err err;
2355
2356    assert(csp);
2357    assert(templatename);
2358    assert(exports);
2359    assert(rsp);
2360
2361    err = template_load(csp, &rsp->body, templatename, 0);
2362    if (err == JB_ERR_FILE)
2363    {
2364       free_map(exports);
2365       return cgi_error_no_template(csp, rsp, templatename);
2366    }
2367    else if (err)
2368    {
2369       free_map(exports);
2370       return err; /* JB_ERR_MEMORY */
2371    }
2372    err = template_fill(&rsp->body, exports);
2373    free_map(exports);
2374    return err;
2375 }
2376
2377
2378 /*********************************************************************
2379  *
2380  * Function    :  default_exports
2381  *
2382  * Description :  returns a struct map list that contains exports
2383  *                which are common to all CGI functions.
2384  *
2385  * Parameters  :
2386  *          1  :  csp = Current client state (buffers, headers, etc...)
2387  *          2  :  caller = name of CGI who calls us and which should
2388  *                         be excluded from the generated menu. May be
2389  *                         NULL.
2390  * Returns     :  NULL if no memory, else a new map.  Caller frees.
2391  *
2392  *********************************************************************/
2393 struct map *default_exports(const struct client_state *csp, const char *caller)
2394 {
2395    char buf[20];
2396    jb_err err;
2397    struct map * exports;
2398    int local_help_exists = 0;
2399
2400    assert(csp);
2401
2402    exports = new_map();
2403    if (exports == NULL)
2404    {
2405       return NULL;
2406    }
2407
2408    err = map(exports, "version", 1, html_encode(VERSION), 0);
2409    if (!err) err = map(exports, "my-ip-address", 1, html_encode(csp->my_ip_addr_str ? csp->my_ip_addr_str : "unknown"), 0);
2410    if (!err) err = map(exports, "my-hostname",   1, html_encode(csp->my_hostname ? csp->my_hostname : "unknown"), 0);
2411    if (!err) err = map(exports, "homepage",      1, html_encode(HOME_PAGE_URL), 0);
2412    if (!err) err = map(exports, "default-cgi",   1, html_encode(CGI_PREFIX), 0);
2413    if (!err) err = map(exports, "menu",          1, make_menu(caller, csp->config->feature_flags), 0);
2414    if (!err) err = map(exports, "code-status",   1, CODE_STATUS, 1);
2415    if (!strncmpic(csp->config->usermanual, "file://", 7) ||
2416        !strncmpic(csp->config->usermanual, "http", 4))
2417    {
2418       /* Manual is located somewhere else, just link to it. */
2419       if (!err) err = map(exports, "user-manual", 1, html_encode(csp->config->usermanual), 0);
2420    }
2421    else
2422    {
2423       /* Manual is delivered by Privoxy. */
2424       if (!err) err = map(exports, "user-manual", 1, html_encode(CGI_PREFIX"user-manual/"), 0);
2425    }
2426    if (!err) err = map(exports, "actions-help-prefix", 1, ACTIONS_HELP_PREFIX ,1);
2427 #ifdef FEATURE_TOGGLE
2428    if (!err) err = map_conditional(exports, "enabled-display", global_toggle_state);
2429 #else
2430    if (!err) err = map_block_killer(exports, "can-toggle");
2431 #endif
2432
2433    snprintf(buf, 20, "%d", csp->config->hport);
2434    if (!err) err = map(exports, "my-port", 1, buf, 1);
2435
2436    if(!strcmp(CODE_STATUS, "stable"))
2437    {
2438       if (!err) err = map_block_killer(exports, "unstable");
2439    }
2440
2441    if (csp->config->admin_address != NULL)
2442    {
2443       if (!err) err = map(exports, "admin-address", 1, html_encode(csp->config->admin_address), 0);
2444       local_help_exists = 1;
2445    }
2446    else
2447    {
2448       if (!err) err = map_block_killer(exports, "have-adminaddr-info");
2449    }
2450
2451    if (csp->config->proxy_info_url != NULL)
2452    {
2453       if (!err) err = map(exports, "proxy-info-url", 1, html_encode(csp->config->proxy_info_url), 0);
2454       local_help_exists = 1;
2455    }
2456    else
2457    {
2458       if (!err) err = map_block_killer(exports, "have-proxy-info");
2459    }
2460
2461    if (local_help_exists == 0)
2462    {
2463       if (!err) err = map_block_killer(exports, "have-help-info");
2464    }
2465
2466    if (err)
2467    {
2468       free_map(exports);
2469       return NULL;
2470    }
2471
2472    return exports;
2473 }
2474
2475
2476 /*********************************************************************
2477  *
2478  * Function    :  map_block_killer
2479  *
2480  * Description :  Convenience function.
2481  *                Adds a "killer" for the conditional HTML-template
2482  *                block <name>, i.e. a substitution of the regex
2483  *                "if-<name>-start.*if-<name>-end" to the given
2484  *                export list.
2485  *
2486  * Parameters  :
2487  *          1  :  exports = map to extend
2488  *          2  :  name = name of conditional block
2489  *
2490  * Returns     :  JB_ERR_OK on success
2491  *                JB_ERR_MEMORY on out-of-memory error.
2492  *
2493  *********************************************************************/
2494 jb_err map_block_killer(struct map *exports, const char *name)
2495 {
2496    char buf[1000]; /* Will do, since the names are hardwired */
2497
2498    assert(exports);
2499    assert(name);
2500    assert(strlen(name) < 490);
2501
2502    snprintf(buf, 1000, "if-%s-start.*if-%s-end", name, name);
2503    return map(exports, buf, 1, "", 1);
2504 }
2505
2506
2507 /*********************************************************************
2508  *
2509  * Function    :  map_block_keep
2510  *
2511  * Description :  Convenience function.  Removes the markers used
2512  *                by map-block-killer, to save a few bytes.
2513  *                i.e. removes "@if-<name>-start@" and "@if-<name>-end@"
2514  *
2515  * Parameters  :
2516  *          1  :  exports = map to extend
2517  *          2  :  name = name of conditional block
2518  *
2519  * Returns     :  JB_ERR_OK on success
2520  *                JB_ERR_MEMORY on out-of-memory error.
2521  *
2522  *********************************************************************/
2523 jb_err map_block_keep(struct map *exports, const char *name)
2524 {
2525    jb_err err;
2526    char buf[500]; /* Will do, since the names are hardwired */
2527
2528    assert(exports);
2529    assert(name);
2530    assert(strlen(name) < 490);
2531
2532    snprintf(buf, 500, "if-%s-start", name);
2533    err = map(exports, buf, 1, "", 1);
2534
2535    if (err)
2536    {
2537       return err;
2538    }
2539
2540    snprintf(buf, 500, "if-%s-end", name);
2541    return map(exports, buf, 1, "", 1);
2542 }
2543
2544
2545 /*********************************************************************
2546  *
2547  * Function    :  map_conditional
2548  *
2549  * Description :  Convenience function.
2550  *                Adds an "if-then-else" for the conditional HTML-template
2551  *                block <name>, i.e. a substitution of the form:
2552  *                @if-<name>-then@
2553  *                   True text
2554  *                @else-not-<name>@
2555  *                   False text
2556  *                @endif-<name>@
2557  *
2558  *                The control structure and one of the alternatives
2559  *                will be hidden.
2560  *
2561  * Parameters  :
2562  *          1  :  exports = map to extend
2563  *          2  :  name = name of conditional block
2564  *          3  :  choose_first = nonzero for first, zero for second.
2565  *
2566  * Returns     :  JB_ERR_OK on success
2567  *                JB_ERR_MEMORY on out-of-memory error.
2568  *
2569  *********************************************************************/
2570 jb_err map_conditional(struct map *exports, const char *name, int choose_first)
2571 {
2572    char buf[1000]; /* Will do, since the names are hardwired */
2573    jb_err err;
2574
2575    assert(exports);
2576    assert(name);
2577    assert(strlen(name) < 480);
2578
2579    snprintf(buf, 1000, (choose_first
2580       ? "else-not-%s@.*@endif-%s"
2581       : "if-%s-then@.*@else-not-%s"),
2582       name, name);
2583
2584    err = map(exports, buf, 1, "", 1);
2585    if (err)
2586    {
2587       return err;
2588    }
2589
2590    snprintf(buf, 1000, (choose_first ? "if-%s-then" : "endif-%s"), name);
2591    return map(exports, buf, 1, "", 1);
2592 }
2593
2594
2595 /*********************************************************************
2596  *
2597  * Function    :  make_menu
2598  *
2599  * Description :  Returns an HTML-formatted menu of the available
2600  *                unhidden CGIs, excluding the one given in <self>
2601  *                and the toggle CGI if toggling is disabled.
2602  *
2603  * Parameters  :
2604  *          1  :  self = name of CGI to leave out, can be NULL for
2605  *                complete listing.
2606  *          2  :  feature_flags = feature bitmap from csp->config
2607  *
2608  *
2609  * Returns     :  menu string, or NULL on out-of-memory error.
2610  *
2611  *********************************************************************/
2612 char *make_menu(const char *self, const unsigned feature_flags)
2613 {
2614    const struct cgi_dispatcher *d;
2615    char *result = strdup("");
2616
2617    if (self == NULL)
2618    {
2619       self = "NO-SUCH-CGI!";
2620    }
2621
2622    /* List available unhidden CGI's and export as "other-cgis" */
2623    for (d = cgi_dispatchers; d->name; d++)
2624    {
2625
2626 #ifdef FEATURE_TOGGLE
2627       if (!(feature_flags & RUNTIME_FEATURE_CGI_TOGGLE) && !strcmp(d->name, "toggle"))
2628       {
2629          /*
2630           * Suppress the toggle link if remote toggling is disabled.
2631           */
2632          continue;
2633       }
2634 #endif /* def FEATURE_TOGGLE */
2635
2636       if (d->description && strcmp(d->name, self))
2637       {
2638          char *html_encoded_prefix;
2639
2640          string_append(&result, "<li><a href=\"");
2641          html_encoded_prefix = html_encode(CGI_PREFIX);
2642          if (html_encoded_prefix == NULL)
2643          {
2644             return NULL;
2645          }
2646          else
2647          {
2648             string_append(&result, html_encoded_prefix);
2649             free(html_encoded_prefix);
2650          }
2651          string_append(&result, d->name);
2652          string_append(&result, "\">");
2653          string_append(&result, d->description);
2654          string_append(&result, "</a></li>\n");
2655       }
2656    }
2657
2658    return result;
2659 }
2660
2661
2662 /*********************************************************************
2663  *
2664  * Function    :  dump_map
2665  *
2666  * Description :  HTML-dump a map for debugging (as table)
2667  *
2668  * Parameters  :
2669  *          1  :  the_map = map to dump
2670  *
2671  * Returns     :  string with HTML
2672  *
2673  *********************************************************************/
2674 char *dump_map(const struct map *the_map)
2675 {
2676    struct map_entry *cur_entry;
2677    char *ret = strdup("");
2678
2679    string_append(&ret, "<table>\n");
2680
2681    for (cur_entry = the_map->first;
2682         (cur_entry != NULL) && (ret != NULL);
2683         cur_entry = cur_entry->next)
2684    {
2685       string_append(&ret, "<tr><td><b>");
2686       string_join  (&ret, html_encode(cur_entry->name));
2687       string_append(&ret, "</b></td><td>");
2688       string_join  (&ret, html_encode(cur_entry->value));
2689       string_append(&ret, "</td></tr>\n");
2690    }
2691
2692    string_append(&ret, "</table>\n");
2693    return ret;
2694 }
2695
2696
2697 /*
2698   Local Variables:
2699   tab-width: 3
2700   end:
2701 */