cgisimple.c

   1 const char cgisimple_rcs[] = "$Id: cgisimple.c,v 1.123 2014/05/20 11:55:09 fabiankeil Exp $";
   2 /*********************************************************************
   3  *
   4  * File        :  $Source: /cvsroot/ijbswa/current/cgisimple.c,v $
   5  *
   6  * Purpose     :  Simple CGIs to get information about Privoxy's
   7  *                status.
   8  *
   9  * Copyright   :  Written by and Copyright (C) 2001-2014 the
  10  *                Privoxy team. http://www.privoxy.org/
  11  *
  12  *                Based on the Internet Junkbuster originally written
  13  *                by and Copyright (C) 1997 Anonymous Coders and
  14  *                Junkbusters Corporation.  http://www.junkbusters.com
  15  *
  16  *                This program is free software; you can redistribute it
  17  *                and/or modify it under the terms of the GNU General
  18  *                Public License as published by the Free Software
  19  *                Foundation; either version 2 of the License, or (at
  20  *                your option) any later version.
  21  *
  22  *                This program is distributed in the hope that it will
  23  *                be useful, but WITHOUT ANY WARRANTY; without even the
  24  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
  25  *                PARTICULAR PURPOSE.  See the GNU General Public
  26  *                License for more details.
  27  *
  28  *                The GNU General Public License should be included with
  29  *                this file.  If not, you can view it at
  30  *                http://www.gnu.org/copyleft/gpl.html
  31  *                or write to the Free Software Foundation, Inc., 59
  32  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  33  *
  34  **********************************************************************/
  35
  36
  37 #include "config.h"
  38
  39 #include <stdio.h>
  40 #include <sys/types.h>
  41 #include <stdlib.h>
  42 #include <ctype.h>
  43 #include <string.h>
  44 #include <assert.h>
  45
  46 #if defined (HAVE_ACCESS) && defined (HAVE_UNISTD_H)
  47 #include <unistd.h>
  48 #endif /* def HAVE_ACCESS && HAVE_UNISTD_H */
  49
  50 #include "project.h"
  51 #include "cgi.h"
  52 #include "cgisimple.h"
  53 #include "list.h"
  54 #include "encode.h"
  55 #include "jcc.h"
  56 #include "filters.h"
  57 #include "actions.h"
  58 #include "miscutil.h"
  59 #include "loadcfg.h"
  60 #include "parsers.h"
  61 #include "urlmatch.h"
  62 #include "errlog.h"
  63
  64 const char cgisimple_h_rcs[] = CGISIMPLE_H_VERSION;
  65
  66 static char *show_rcs(void);
  67 static jb_err show_defines(struct map *exports);
  68 static jb_err cgi_show_file(struct client_state *csp,
  69                             struct http_response *rsp,
  70                             const struct map *parameters);
  71 static jb_err load_file(const char *filename, char **buffer, size_t *length);
  72
  73 /*********************************************************************
  74  *
  75  * Function    :  cgi_default
  76  *
  77  * Description :  CGI function that is called for the CGI_SITE_1_HOST
  78  *                and CGI_SITE_2_HOST/CGI_SITE_2_PATH base URLs.
  79  *                Boring - only exports the default exports.
  80  *
  81  * Parameters  :
  82  *          1  :  csp = Current client state (buffers, headers, etc...)
  83  *          2  :  rsp = http_response data structure for output
  84  *          3  :  parameters = map of cgi parameters
  85  *
  86  * CGI Parameters : none
  87  *
  88  * Returns     :  JB_ERR_OK on success
  89  *                JB_ERR_MEMORY on out-of-memory
  90  *
  91  *********************************************************************/
  92 jb_err cgi_default(struct client_state *csp,
  93                    struct http_response *rsp,
  94                    const struct map *parameters)
  95 {
  96    struct map *exports;
  97
  98    (void)parameters;
  99
 100    assert(csp);
 101    assert(rsp);
 102
 103    if (NULL == (exports = default_exports(csp, "")))
 104    {
 105       return JB_ERR_MEMORY;
 106    }
 107
 108    return template_fill_for_cgi(csp, "default", exports, rsp);
 109 }
 110
 111
 112 /*********************************************************************
 113  *
 114  * Function    :  cgi_error_404
 115  *
 116  * Description :  CGI function that is called if an unknown action was
 117  *                given.
 118  *
 119  * Parameters  :
 120  *          1  :  csp = Current client state (buffers, headers, etc...)
 121  *          2  :  rsp = http_response data structure for output
 122  *          3  :  parameters = map of cgi parameters
 123  *
 124  * CGI Parameters : none
 125  *
 126  * Returns     :  JB_ERR_OK on success
 127  *                JB_ERR_MEMORY on out-of-memory error.
 128  *
 129  *********************************************************************/
 130 jb_err cgi_error_404(struct client_state *csp,
 131                      struct http_response *rsp,
 132                      const struct map *parameters)
 133 {
 134    struct map *exports;
 135
 136    assert(csp);
 137    assert(rsp);
 138    assert(parameters);
 139
 140    if (NULL == (exports = default_exports(csp, NULL)))
 141    {
 142       return JB_ERR_MEMORY;
 143    }
 144
 145    rsp->status = strdup("404 Privoxy configuration page not found");
 146    if (rsp->status == NULL)
 147    {
 148       free_map(exports);
 149       return JB_ERR_MEMORY;
 150    }
 151
 152    return template_fill_for_cgi(csp, "cgi-error-404", exports, rsp);
 153 }
 154
 155
 156 #ifdef FEATURE_GRACEFUL_TERMINATION
 157 /*********************************************************************
 158  *
 159  * Function    :  cgi_die
 160  *
 161  * Description :  CGI function to shut down Privoxy.
 162  *                NOTE: Turning this on in a production build
 163  *                would be a BAD idea.  An EXTREMELY BAD idea.
 164  *                In short, don't do it.
 165  *
 166  * Parameters  :
 167  *          1  :  csp = Current client state (buffers, headers, etc...)
 168  *          2  :  rsp = http_response data structure for output
 169  *          3  :  parameters = map of cgi parameters
 170  *
 171  * CGI Parameters : none
 172  *
 173  * Returns     :  JB_ERR_OK on success
 174  *                JB_ERR_MEMORY on out-of-memory error.
 175  *
 176  *********************************************************************/
 177 jb_err cgi_die (struct client_state *csp,
 178                 struct http_response *rsp,
 179                 const struct map *parameters)
 180 {
 181    static const char status[] = "200 OK Privoxy shutdown request received";
 182    static const char body[] =
 183       "<html>\n"
 184       "<head>\n"
 185       " <title>Privoxy shutdown request received</title>\n"
 186       " <link rel=\"shortcut icon\" href=\"" CGI_PREFIX "error-favicon.ico\" type=\"image/x-icon\">\n"
 187       " <link rel=\"stylesheet\" type=\"text/css\" href=\"http://config.privoxy.org/send-stylesheet\">\n"
 188       "</head>\n"
 189       "<body>\n"
 190       "<h1>Privoxy shutdown request received</h1>\n"
 191       "<p>Privoxy is going to shut down after the next request.</p>\n"
 192       "</body>\n"
 193       "</html>\n";
 194
 195    assert(csp);
 196    assert(rsp);
 197    assert(parameters);
 198
 199    /* quit */
 200    g_terminate = 1;
 201
 202    csp->flags &= ~CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE;
 203
 204    rsp->content_length = 0;
 205    rsp->head_length = 0;
 206    rsp->is_static = 0;
 207
 208    rsp->body = strdup(body);
 209    rsp->status = strdup(status);
 210
 211    if ((rsp->body == NULL) || (rsp->status == NULL))
 212    {
 213       return JB_ERR_MEMORY;
 214    }
 215
 216    return JB_ERR_OK;
 217 }
 218 #endif /* def FEATURE_GRACEFUL_TERMINATION */
 219
 220
 221 /*********************************************************************
 222  *
 223  * Function    :  cgi_show_request
 224  *
 225  * Description :  Show the client's request and what sed() would have
 226  *                made of it.
 227  *
 228  * Parameters  :
 229  *          1  :  csp = Current client state (buffers, headers, etc...)
 230  *          2  :  rsp = http_response data structure for output
 231  *          3  :  parameters = map of cgi parameters
 232  *
 233  * CGI Parameters : none
 234  *
 235  * Returns     :  JB_ERR_OK on success
 236  *                JB_ERR_MEMORY on out-of-memory error.
 237  *
 238  *********************************************************************/
 239 jb_err cgi_show_request(struct client_state *csp,
 240                         struct http_response *rsp,
 241                         const struct map *parameters)
 242 {
 243    char *p;
 244    struct map *exports;
 245
 246    assert(csp);
 247    assert(rsp);
 248    assert(parameters);
 249
 250    if (NULL == (exports = default_exports(csp, "show-request")))
 251    {
 252       return JB_ERR_MEMORY;
 253    }
 254
 255    /*
 256     * Repair the damage done to the IOB by get_header()
 257     */
 258    for (p = csp->client_iob->buf; p < csp->client_iob->cur; p++)
 259    {
 260       if (*p == '\0') *p = '\n';
 261    }
 262
 263    /*
 264     * Export the original client's request and the one we would
 265     * be sending to the server if this wasn't a CGI call
 266     */
 267
 268    if (map(exports, "client-request", 1, html_encode(csp->client_iob->buf), 0))
 269    {
 270       free_map(exports);
 271       return JB_ERR_MEMORY;
 272    }
 273
 274    if (map(exports, "processed-request", 1,
 275          html_encode_and_free_original(list_to_text(csp->headers)), 0))
 276    {
 277       free_map(exports);
 278       return JB_ERR_MEMORY;
 279    }
 280
 281    return template_fill_for_cgi(csp, "show-request", exports, rsp);
 282 }
 283
 284
 285 /*********************************************************************
 286  *
 287  * Function    :  cgi_send_banner
 288  *
 289  * Description :  CGI function that returns a banner.
 290  *
 291  * Parameters  :
 292  *          1  :  csp = Current client state (buffers, headers, etc...)
 293  *          2  :  rsp = http_response data structure for output
 294  *          3  :  parameters = map of cgi parameters
 295  *
 296  * CGI Parameters :
 297  *           type : Selects the type of banner between "trans", "logo",
 298  *                  and "auto". Defaults to "logo" if absent or invalid.
 299  *                  "auto" means to select as if we were image-blocking.
 300  *                  (Only the first character really counts; b and t are
 301  *                  equivalent).
 302  *
 303  * Returns     :  JB_ERR_OK on success
 304  *                JB_ERR_MEMORY on out-of-memory error.
 305  *
 306  *********************************************************************/
 307 jb_err cgi_send_banner(struct client_state *csp,
 308                        struct http_response *rsp,
 309                        const struct map *parameters)
 310 {
 311    char imagetype = lookup(parameters, "type")[0];
 312
 313    /*
 314     * If type is auto, then determine the right thing
 315     * to do from the set-image-blocker action
 316     */
 317    if (imagetype == 'a')
 318    {
 319       /*
 320        * Default to pattern
 321        */
 322       imagetype = 'p';
 323
 324 #ifdef FEATURE_IMAGE_BLOCKING
 325       if ((csp->action->flags & ACTION_IMAGE_BLOCKER) != 0)
 326       {
 327          static const char prefix1[] = CGI_PREFIX "send-banner?type=";
 328          static const char prefix2[] = "http://" CGI_SITE_1_HOST "/send-banner?type=";
 329          const char *p = csp->action->string[ACTION_STRING_IMAGE_BLOCKER];
 330
 331          if (p == NULL)
 332          {
 333             /* Use default - nothing to do here. */
 334          }
 335          else if (0 == strcmpic(p, "blank"))
 336          {
 337             imagetype = 'b';
 338          }
 339          else if (0 == strcmpic(p, "pattern"))
 340          {
 341             imagetype = 'p';
 342          }
 343
 344          /*
 345           * If the action is to call this CGI, determine
 346           * the argument:
 347           */
 348          else if (0 == strncmpic(p, prefix1, sizeof(prefix1) - 1))
 349          {
 350             imagetype = p[sizeof(prefix1) - 1];
 351          }
 352          else if (0 == strncmpic(p, prefix2, sizeof(prefix2) - 1))
 353          {
 354             imagetype = p[sizeof(prefix2) - 1];
 355          }
 356
 357          /*
 358           * Everything else must (should) be a URL to
 359           * redirect to.
 360           */
 361          else
 362          {
 363             imagetype = 'r';
 364          }
 365       }
 366 #endif /* def FEATURE_IMAGE_BLOCKING */
 367    }
 368
 369    /*
 370     * Now imagetype is either the non-auto type we were called with,
 371     * or it was auto and has since been determined. In any case, we
 372     * can proceed to actually answering the request by sending a redirect
 373     * or an image as appropriate:
 374     */
 375    if (imagetype == 'r')
 376    {
 377       rsp->status = strdup("302 Local Redirect from Privoxy");
 378       if (rsp->status == NULL)
 379       {
 380          return JB_ERR_MEMORY;
 381       }
 382       if (enlist_unique_header(rsp->headers, "Location",
 383                                csp->action->string[ACTION_STRING_IMAGE_BLOCKER]))
 384       {
 385          return JB_ERR_MEMORY;
 386       }
 387    }
 388    else
 389    {
 390       if ((imagetype == 'b') || (imagetype == 't'))
 391       {
 392          rsp->body = bindup(image_blank_data, image_blank_length);
 393          rsp->content_length = image_blank_length;
 394       }
 395       else
 396       {
 397          rsp->body = bindup(image_pattern_data, image_pattern_length);
 398          rsp->content_length = image_pattern_length;
 399       }
 400
 401       if (rsp->body == NULL)
 402       {
 403          return JB_ERR_MEMORY;
 404       }
 405       if (enlist(rsp->headers, "Content-Type: " BUILTIN_IMAGE_MIMETYPE))
 406       {
 407          return JB_ERR_MEMORY;
 408       }
 409
 410       rsp->is_static = 1;
 411    }
 412
 413    return JB_ERR_OK;
 414
 415 }
 416
 417
 418 /*********************************************************************
 419  *
 420  * Function    :  cgi_transparent_image
 421  *
 422  * Description :  CGI function that sends a 1x1 transparent image.
 423  *
 424  * Parameters  :
 425  *          1  :  csp = Current client state (buffers, headers, etc...)
 426  *          2  :  rsp = http_response data structure for output
 427  *          3  :  parameters = map of cgi parameters
 428  *
 429  * CGI Parameters : None
 430  *
 431  * Returns     :  JB_ERR_OK on success
 432  *                JB_ERR_MEMORY on out-of-memory error.
 433  *
 434  *********************************************************************/
 435 jb_err cgi_transparent_image(struct client_state *csp,
 436                              struct http_response *rsp,
 437                              const struct map *parameters)
 438 {
 439    (void)csp;
 440    (void)parameters;
 441
 442    rsp->body = bindup(image_blank_data, image_blank_length);
 443    rsp->content_length = image_blank_length;
 444
 445    if (rsp->body == NULL)
 446    {
 447       return JB_ERR_MEMORY;
 448    }
 449
 450    if (enlist(rsp->headers, "Content-Type: " BUILTIN_IMAGE_MIMETYPE))
 451    {
 452       return JB_ERR_MEMORY;
 453    }
 454
 455    rsp->is_static = 1;
 456
 457    return JB_ERR_OK;
 458
 459 }
 460
 461
 462 /*********************************************************************
 463  *
 464  * Function    :  cgi_send_default_favicon
 465  *
 466  * Description :  CGI function that sends the standard favicon.
 467  *
 468  * Parameters  :
 469  *          1  :  csp = Current client state (buffers, headers, etc...)
 470  *          2  :  rsp = http_response data structure for output
 471  *          3  :  parameters = map of cgi parameters
 472  *
 473  * CGI Parameters : None
 474  *
 475  * Returns     :  JB_ERR_OK on success
 476  *                JB_ERR_MEMORY on out-of-memory error.
 477  *
 478  *********************************************************************/
 479 jb_err cgi_send_default_favicon(struct client_state *csp,
 480                                 struct http_response *rsp,
 481                                 const struct map *parameters)
 482 {
 483    static const char default_favicon_data[] =
 484       "\000\000\001\000\001\000\020\020\002\000\000\000\000\000\260"
 485       "\000\000\000\026\000\000\000\050\000\000\000\020\000\000\000"
 486       "\040\000\000\000\001\000\001\000\000\000\000\000\100\000\000"
 487       "\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000"
 488       "\000\000\377\377\377\000\377\000\052\000\017\360\000\000\077"
 489       "\374\000\000\161\376\000\000\161\376\000\000\361\377\000\000"
 490       "\361\377\000\000\360\017\000\000\360\007\000\000\361\307\000"
 491       "\000\361\307\000\000\361\307\000\000\360\007\000\000\160\036"
 492       "\000\000\177\376\000\000\077\374\000\000\017\360\000\000\360"
 493       "\017\000\000\300\003\000\000\200\001\000\000\200\001\000\000"
 494       "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
 495       "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
 496       "\000\000\200\001\000\000\200\001\000\000\300\003\000\000\360"
 497       "\017\000\000";
 498    static const size_t favicon_length = sizeof(default_favicon_data) - 1;
 499
 500    (void)csp;
 501    (void)parameters;
 502
 503    rsp->body = bindup(default_favicon_data, favicon_length);
 504    rsp->content_length = favicon_length;
 505
 506    if (rsp->body == NULL)
 507    {
 508       return JB_ERR_MEMORY;
 509    }
 510
 511    if (enlist(rsp->headers, "Content-Type: image/x-icon"))
 512    {
 513       return JB_ERR_MEMORY;
 514    }
 515
 516    rsp->is_static = 1;
 517
 518    return JB_ERR_OK;
 519
 520 }
 521
 522
 523 /*********************************************************************
 524  *
 525  * Function    :  cgi_send_error_favicon
 526  *
 527  * Description :  CGI function that sends the favicon for error pages.
 528  *
 529  * Parameters  :
 530  *          1  :  csp = Current client state (buffers, headers, etc...)
 531  *          2  :  rsp = http_response data structure for output
 532  *          3  :  parameters = map of cgi parameters
 533  *
 534  * CGI Parameters : None
 535  *
 536  * Returns     :  JB_ERR_OK on success
 537  *                JB_ERR_MEMORY on out-of-memory error.
 538  *
 539  *********************************************************************/
 540 jb_err cgi_send_error_favicon(struct client_state *csp,
 541                               struct http_response *rsp,
 542                               const struct map *parameters)
 543 {
 544    static const char error_favicon_data[] =
 545       "\000\000\001\000\001\000\020\020\002\000\000\000\000\000\260"
 546       "\000\000\000\026\000\000\000\050\000\000\000\020\000\000\000"
 547       "\040\000\000\000\001\000\001\000\000\000\000\000\100\000\000"
 548       "\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000"
 549       "\000\000\377\377\377\000\000\000\377\000\017\360\000\000\077"
 550       "\374\000\000\161\376\000\000\161\376\000\000\361\377\000\000"
 551       "\361\377\000\000\360\017\000\000\360\007\000\000\361\307\000"
 552       "\000\361\307\000\000\361\307\000\000\360\007\000\000\160\036"
 553       "\000\000\177\376\000\000\077\374\000\000\017\360\000\000\360"
 554       "\017\000\000\300\003\000\000\200\001\000\000\200\001\000\000"
 555       "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
 556       "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
 557       "\000\000\200\001\000\000\200\001\000\000\300\003\000\000\360"
 558       "\017\000\000";
 559    static const size_t favicon_length = sizeof(error_favicon_data) - 1;
 560
 561    (void)csp;
 562    (void)parameters;
 563
 564    rsp->body = bindup(error_favicon_data, favicon_length);
 565    rsp->content_length = favicon_length;
 566
 567    if (rsp->body == NULL)
 568    {
 569       return JB_ERR_MEMORY;
 570    }
 571
 572    if (enlist(rsp->headers, "Content-Type: image/x-icon"))
 573    {
 574       return JB_ERR_MEMORY;
 575    }
 576
 577    rsp->is_static = 1;
 578
 579    return JB_ERR_OK;
 580
 581 }
 582
 583
 584 /*********************************************************************
 585  *
 586  * Function    :  cgi_send_stylesheet
 587  *
 588  * Description :  CGI function that sends a css stylesheet found
 589  *                in the cgi-style.css template
 590  *
 591  * Parameters  :
 592  *          1  :  csp = Current client state (buffers, headers, etc...)
 593  *          2  :  rsp = http_response data structure for output
 594  *          3  :  parameters = map of cgi parameters
 595  *
 596  * CGI Parameters : None
 597  *
 598  * Returns     :  JB_ERR_OK on success
 599  *                JB_ERR_MEMORY on out-of-memory error.
 600  *
 601  *********************************************************************/
 602 jb_err cgi_send_stylesheet(struct client_state *csp,
 603                            struct http_response *rsp,
 604                            const struct map *parameters)
 605 {
 606    jb_err err;
 607
 608    assert(csp);
 609    assert(rsp);
 610
 611    (void)parameters;
 612
 613    err = template_load(csp, &rsp->body, "cgi-style.css", 0);
 614
 615    if (err == JB_ERR_FILE)
 616    {
 617       /*
 618        * No way to tell user; send empty stylesheet
 619        */
 620       log_error(LOG_LEVEL_ERROR, "Could not find cgi-style.css template");
 621    }
 622    else if (err)
 623    {
 624       return err; /* JB_ERR_MEMORY */
 625    }
 626
 627    if (enlist(rsp->headers, "Content-Type: text/css"))
 628    {
 629       return JB_ERR_MEMORY;
 630    }
 631
 632    return JB_ERR_OK;
 633
 634 }
 635
 636
 637 /*********************************************************************
 638  *
 639  * Function    :  cgi_send_url_info_osd
 640  *
 641  * Description :  CGI function that sends the OpenSearch Description
 642  *                template for the show-url-info page. It allows to
 643  *                access the page through "search engine plugins".
 644  *
 645  * Parameters  :
 646  *          1  :  csp = Current client state (buffers, headers, etc...)
 647  *          2  :  rsp = http_response data structure for output
 648  *          3  :  parameters = map of cgi parameters
 649  *
 650  * CGI Parameters : None
 651  *
 652  * Returns     :  JB_ERR_OK on success
 653  *                JB_ERR_MEMORY on out-of-memory error.
 654  *
 655  *********************************************************************/
 656 jb_err cgi_send_url_info_osd(struct client_state *csp,
 657                                struct http_response *rsp,
 658                                const struct map *parameters)
 659 {
 660    jb_err err = JB_ERR_MEMORY;
 661    struct map *exports = default_exports(csp, NULL);
 662
 663    (void)csp;
 664    (void)parameters;
 665
 666    if (NULL != exports)
 667    {
 668       err = template_fill_for_cgi(csp, "url-info-osd.xml", exports, rsp);
 669       if (JB_ERR_OK == err)
 670       {
 671          err = enlist(rsp->headers,
 672             "Content-Type: application/opensearchdescription+xml");
 673       }
 674    }
 675
 676    return err;
 677
 678 }
 679
 680
 681 /*********************************************************************
 682  *
 683  * Function    :  get_content_type
 684  *
 685  * Description :  Use the file extension to guess the content type
 686  *                header we should use to serve the file.
 687  *
 688  * Parameters  :
 689  *          1  :  filename = Name of the file whose content type
 690  *                           we care about
 691  *
 692  * Returns     :  The guessed content type.
 693  *
 694  *********************************************************************/
 695 static const char *get_content_type(const char *filename)
 696 {
 697    int i;
 698    struct content_type
 699    {
 700       const char *extension;
 701       const char *content_type;
 702    };
 703    static const struct content_type content_types[] =
 704    {
 705       {".css",  "text/css"},
 706       {".jpg",  "image/jpeg"},
 707       {".jpeg", "image/jpeg"},
 708       {".png",  "image/png"},
 709    };
 710
 711    for (i = 0; i < SZ(content_types); i++)
 712    {
 713       if (strstr(filename, content_types[i].extension))
 714       {
 715          return content_types[i].content_type;
 716       }
 717    }
 718
 719    /* No match by extension, default to html */
 720    return "text/html";
 721 }
 722
 723 /*********************************************************************
 724  *
 725  * Function    :  cgi_send_user_manual
 726  *
 727  * Description :  CGI function that sends a file in the user
 728  *                manual directory.
 729  *
 730  * Parameters  :
 731  *          1  :  csp = Current client state (buffers, headers, etc...)
 732  *          2  :  rsp = http_response data structure for output
 733  *          3  :  parameters = map of cgi parameters
 734  *
 735  * CGI Parameters : file=name.html, the name of the HTML file
 736  *                  (relative to user-manual from config)
 737  *
 738  * Returns     :  JB_ERR_OK on success
 739  *                JB_ERR_MEMORY on out-of-memory error.
 740  *
 741  *********************************************************************/
 742 jb_err cgi_send_user_manual(struct client_state *csp,
 743                             struct http_response *rsp,
 744                             const struct map *parameters)
 745 {
 746    const char *filename;
 747    char *full_path;
 748    jb_err err = JB_ERR_OK;
 749    const char *content_type;
 750
 751    assert(csp);
 752    assert(rsp);
 753    assert(parameters);
 754
 755    if (0 == strncmpic(csp->config->usermanual, "http://", 7))
 756    {
 757       log_error(LOG_LEVEL_CGI, "Request for local user-manual "
 758          "received while user-manual delivery is disabled.");
 759       return cgi_error_404(csp, rsp, parameters);
 760    }
 761
 762    if (!parameters->first)
 763    {
 764       /* requested http://p.p/user-manual (without trailing slash) */
 765       return cgi_redirect(rsp, CGI_PREFIX "user-manual/");
 766    }
 767
 768    get_string_param(parameters, "file", &filename);
 769    if (filename == NULL)
 770    {
 771       /* It's '/' so serve the index.html if there is one.  */
 772       filename = "index.html";
 773    }
 774    else if (NULL != strchr(filename, '/') || NULL != strstr(filename, ".."))
 775    {
 776       /*
 777        * We currently only support a flat file
 778        * hierarchy for the documentation.
 779        */
 780       log_error(LOG_LEVEL_ERROR,
 781          "Rejecting the request to serve '%s' as it contains '/' or '..'",
 782          filename);
 783       return JB_ERR_CGI_PARAMS;
 784    }
 785
 786    full_path = make_path(csp->config->usermanual, filename);
 787    if (full_path == NULL)
 788    {
 789       return JB_ERR_MEMORY;
 790    }
 791
 792    err = load_file(full_path, &rsp->body, &rsp->content_length);
 793    if (JB_ERR_OK != err)
 794    {
 795       assert((JB_ERR_FILE == err) || (JB_ERR_MEMORY == err));
 796       if (JB_ERR_FILE == err)
 797       {
 798          err = cgi_error_no_template(csp, rsp, full_path);
 799       }
 800       freez(full_path);
 801       return err;
 802    }
 803    freez(full_path);
 804
 805    content_type = get_content_type(filename);
 806    log_error(LOG_LEVEL_CGI,
 807       "Content-Type guessed for %s: %s", filename, content_type);
 808
 809    return enlist_unique_header(rsp->headers, "Content-Type", content_type);
 810
 811 }
 812
 813
 814 /*********************************************************************
 815  *
 816  * Function    :  cgi_show_version
 817  *
 818  * Description :  CGI function that returns a a web page describing the
 819  *                file versions of Privoxy.
 820  *
 821  * Parameters  :
 822  *          1  :  csp = Current client state (buffers, headers, etc...)
 823  *          2  :  rsp = http_response data structure for output
 824  *          3  :  parameters = map of cgi parameters
 825  *
 826  * CGI Parameters : none
 827  *
 828  * Returns     :  JB_ERR_OK on success
 829  *                JB_ERR_MEMORY on out-of-memory error.
 830  *
 831  *********************************************************************/
 832 jb_err cgi_show_version(struct client_state *csp,
 833                         struct http_response *rsp,
 834                         const struct map *parameters)
 835 {
 836    struct map *exports;
 837
 838    assert(csp);
 839    assert(rsp);
 840    assert(parameters);
 841
 842    if (NULL == (exports = default_exports(csp, "show-version")))
 843    {
 844       return JB_ERR_MEMORY;
 845    }
 846
 847    if (map(exports, "sourceversions", 1, show_rcs(), 0))
 848    {
 849       free_map(exports);
 850       return JB_ERR_MEMORY;
 851    }
 852
 853    return template_fill_for_cgi(csp, "show-version", exports, rsp);
 854 }
 855
 856
 857 /*********************************************************************
 858  *
 859  * Function    :  cgi_show_status
 860  *
 861  * Description :  CGI function that returns a web page describing the
 862  *                current status of Privoxy.
 863  *
 864  * Parameters  :
 865  *          1  :  csp = Current client state (buffers, headers, etc...)
 866  *          2  :  rsp = http_response data structure for output
 867  *          3  :  parameters = map of cgi parameters
 868  *
 869  * CGI Parameters :
 870  *        file :  Which file to show.  Only first letter is checked,
 871  *                valid values are:
 872  *                - "a"ction file
 873  *                - "r"egex
 874  *                - "t"rust
 875  *                Default is to show menu and other information.
 876  *
 877  * Returns     :  JB_ERR_OK on success
 878  *                JB_ERR_MEMORY on out-of-memory error.
 879  *
 880  *********************************************************************/
 881 jb_err cgi_show_status(struct client_state *csp,
 882                        struct http_response *rsp,
 883                        const struct map *parameters)
 884 {
 885    char *s = NULL;
 886    unsigned i;
 887    int j;
 888
 889    char buf[BUFFER_SIZE];
 890 #ifdef FEATURE_STATISTICS
 891    float perc_rej;   /* Percentage of http requests rejected */
 892    int local_urls_read;
 893    int local_urls_rejected;
 894 #endif /* ndef FEATURE_STATISTICS */
 895    jb_err err = JB_ERR_OK;
 896
 897    struct map *exports;
 898
 899    assert(csp);
 900    assert(rsp);
 901    assert(parameters);
 902
 903    if ('\0' != *(lookup(parameters, "file")))
 904    {
 905       return cgi_show_file(csp, rsp, parameters);
 906    }
 907
 908    if (NULL == (exports = default_exports(csp, "show-status")))
 909    {
 910       return JB_ERR_MEMORY;
 911    }
 912
 913    s = strdup("");
 914    for (j = 0; (s != NULL) && (j < Argc); j++)
 915    {
 916       if (!err) err = string_join  (&s, html_encode(Argv[j]));
 917       if (!err) err = string_append(&s, " ");
 918    }
 919    if (!err) err = map(exports, "invocation", 1, s, 0);
 920
 921    if (!err) err = map(exports, "options", 1, csp->config->proxy_args, 1);
 922    if (!err) err = show_defines(exports);
 923
 924    if (err)
 925    {
 926       free_map(exports);
 927       return JB_ERR_MEMORY;
 928    }
 929
 930 #ifdef FEATURE_STATISTICS
 931    local_urls_read     = urls_read;
 932    local_urls_rejected = urls_rejected;
 933
 934    /*
 935     * Need to alter the stats not to include the fetch of this
 936     * page.
 937     *
 938     * Can't do following thread safely! doh!
 939     *
 940     * urls_read--;
 941     * urls_rejected--; * This will be incremented subsequently *
 942     */
 943
 944    if (local_urls_read == 0)
 945    {
 946       if (!err) err = map_block_killer(exports, "have-stats");
 947    }
 948    else
 949    {
 950       if (!err) err = map_block_killer(exports, "have-no-stats");
 951
 952       perc_rej = (float)local_urls_rejected * 100.0F /
 953             (float)local_urls_read;
 954
 955       snprintf(buf, sizeof(buf), "%d", local_urls_read);
 956       if (!err) err = map(exports, "requests-received", 1, buf, 1);
 957
 958       snprintf(buf, sizeof(buf), "%d", local_urls_rejected);
 959       if (!err) err = map(exports, "requests-blocked", 1, buf, 1);
 960
 961       snprintf(buf, sizeof(buf), "%6.2f", perc_rej);
 962       if (!err) err = map(exports, "percent-blocked", 1, buf, 1);
 963    }
 964
 965 #else /* ndef FEATURE_STATISTICS */
 966    err = err || map_block_killer(exports, "statistics");
 967 #endif /* ndef FEATURE_STATISTICS */
 968
 969    /*
 970     * List all action files in use, together with view and edit links,
 971     * except for standard.action, which should only be viewable. (Not
 972     * enforced in the editor itself)
 973     * FIXME: Shouldn't include hardwired HTML here, use line template instead!
 974     */
 975    s = strdup("");
 976    for (i = 0; i < MAX_AF_FILES; i++)
 977    {
 978       if (csp->actions_list[i] != NULL)
 979       {
 980          if (!err) err = string_append(&s, "<tr><td>");
 981          if (!err) err = string_join(&s, html_encode(csp->actions_list[i]->filename));
 982          snprintf(buf, sizeof(buf),
 983             "</td><td class=\"buttons\"><a href=\"/show-status?file=actions&amp;index=%u\">View</a>", i);
 984          if (!err) err = string_append(&s, buf);
 985
 986 #ifdef FEATURE_CGI_EDIT_ACTIONS
 987          if ((csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS)
 988             && (NULL == strstr(csp->actions_list[i]->filename, "standard.action"))
 989             && (NULL != csp->config->actions_file_short[i]))
 990          {
 991 #ifdef HAVE_ACCESS
 992             if (access(csp->config->actions_file[i], W_OK) == 0)
 993             {
 994 #endif /* def HAVE_ACCESS */
 995                snprintf(buf, sizeof(buf), "&nbsp;&nbsp;<a href=\"/edit-actions-list?f=%u\">Edit</a>", i);
 996                if (!err) err = string_append(&s, buf);
 997 #ifdef HAVE_ACCESS
 998             }
 999             else
1000             {
1001                if (!err) err = string_append(&s, "&nbsp;&nbsp;<strong>No write access.</strong>");
1002             }
1003 #endif /* def HAVE_ACCESS */
1004          }
1005 #endif
1006
1007          if (!err) err = string_append(&s, "</td></tr>\n");
1008       }
1009    }
1010    if (*s != '\0')
1011    {
1012       if (!err) err = map(exports, "actions-filenames", 1, s, 0);
1013    }
1014    else
1015    {
1016       if (!err) err = map(exports, "actions-filenames", 1, "<tr><td>None specified</td></tr>", 1);
1017    }
1018
1019    /*
1020     * List all re_filterfiles in use, together with view options.
1021     * FIXME: Shouldn't include hardwired HTML here, use line template instead!
1022     */
1023    s = strdup("");
1024    for (i = 0; i < MAX_AF_FILES; i++)
1025    {
1026       if (csp->rlist[i] != NULL)
1027       {
1028          if (!err) err = string_append(&s, "<tr><td>");
1029          if (!err) err = string_join(&s, html_encode(csp->rlist[i]->filename));
1030          snprintf(buf, sizeof(buf),
1031             "</td><td class=\"buttons\"><a href=\"/show-status?file=filter&amp;index=%u\">View</a>", i);
1032          if (!err) err = string_append(&s, buf);
1033          if (!err) err = string_append(&s, "</td></tr>\n");
1034       }
1035    }
1036    if (*s != '\0')
1037    {
1038       if (!err) err = map(exports, "re-filter-filenames", 1, s, 0);
1039    }
1040    else
1041    {
1042       if (!err) err = map(exports, "re-filter-filenames", 1, "<tr><td>None specified</td></tr>", 1);
1043       if (!err) err = map_block_killer(exports, "have-filterfile");
1044    }
1045
1046 #ifdef FEATURE_TRUST
1047    if (csp->tlist)
1048    {
1049       if (!err) err = map(exports, "trust-filename", 1, html_encode(csp->tlist->filename), 0);
1050    }
1051    else
1052    {
1053       if (!err) err = map(exports, "trust-filename", 1, "None specified", 1);
1054       if (!err) err = map_block_killer(exports, "have-trustfile");
1055    }
1056 #else
1057    if (!err) err = map_block_killer(exports, "trust-support");
1058 #endif /* ndef FEATURE_TRUST */
1059
1060 #ifdef FEATURE_CGI_EDIT_ACTIONS
1061    if (!err && (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
1062    {
1063       err = map_block_killer(exports, "cgi-editor-is-disabled");
1064    }
1065 #endif /* ndef CGI_EDIT_ACTIONS */
1066
1067    if (err)
1068    {
1069       free_map(exports);
1070       return JB_ERR_MEMORY;
1071    }
1072
1073    return template_fill_for_cgi(csp, "show-status", exports, rsp);
1074 }
1075
1076
1077 /*********************************************************************
1078  *
1079  * Function    :  cgi_show_url_info
1080  *
1081  * Description :  CGI function that determines and shows which actions
1082  *                Privoxy will perform for a given url, and which
1083  *                matches starting from the defaults have lead to that.
1084  *
1085  * Parameters  :
1086  *          1  :  csp = Current client state (buffers, headers, etc...)
1087  *          2  :  rsp = http_response data structure for output
1088  *          3  :  parameters = map of cgi parameters
1089  *
1090  * CGI Parameters :
1091  *            url : The url whose actions are to be determined.
1092  *                  If url is unset, the url-given conditional will be
1093  *                  set, so that all but the form can be suppressed in
1094  *                  the template.
1095  *
1096  * Returns     :  JB_ERR_OK on success
1097  *                JB_ERR_MEMORY on out-of-memory error.
1098  *
1099  *********************************************************************/
1100 jb_err cgi_show_url_info(struct client_state *csp,
1101                          struct http_response *rsp,
1102                          const struct map *parameters)
1103 {
1104    char *url_param;
1105    struct map *exports;
1106    char buf[150];
1107
1108    assert(csp);
1109    assert(rsp);
1110    assert(parameters);
1111
1112    if (NULL == (exports = default_exports(csp, "show-url-info")))
1113    {
1114       return JB_ERR_MEMORY;
1115    }
1116
1117    /*
1118     * Get the url= parameter (if present) and remove any leading/trailing spaces.
1119     */
1120    url_param = strdup(lookup(parameters, "url"));
1121    if (url_param == NULL)
1122    {
1123       free_map(exports);
1124       return JB_ERR_MEMORY;
1125    }
1126    chomp(url_param);
1127
1128    /*
1129     * Handle prefixes.  4 possibilities:
1130     * 1) "http://" or "https://" prefix present and followed by URL - OK
1131     * 2) Only the "http://" or "https://" part is present, no URL - change
1132     *    to empty string so it will be detected later as "no URL".
1133     * 3) Parameter specified but doesn't start with "http(s?)://" - add a
1134     *    "http://" prefix.
1135     * 4) Parameter not specified or is empty string - let this fall through
1136     *    for now, next block of code will handle it.
1137     */
1138    if (0 == strncmp(url_param, "http://", 7))
1139    {
1140       if (url_param[7] == '\0')
1141       {
1142          /*
1143           * Empty URL (just prefix).
1144           * Make it totally empty so it's caught by the next if ()
1145           */
1146          url_param[0] = '\0';
1147       }
1148    }
1149    else if (0 == strncmp(url_param, "https://", 8))
1150    {
1151       if (url_param[8] == '\0')
1152       {
1153          /*
1154           * Empty URL (just prefix).
1155           * Make it totally empty so it's caught by the next if ()
1156           */
1157          url_param[0] = '\0';
1158       }
1159    }
1160    else if ((url_param[0] != '\0')
1161       && ((NULL == strstr(url_param, "://")
1162             || (strstr(url_param, "://") > strstr(url_param, "/")))))
1163    {
1164       /*
1165        * No prefix or at least no prefix before
1166        * the first slash - assume http://
1167        */
1168       char *url_param_prefixed = strdup("http://");
1169
1170       if (JB_ERR_OK != string_join(&url_param_prefixed, url_param))
1171       {
1172          free_map(exports);
1173          return JB_ERR_MEMORY;
1174       }
1175       url_param = url_param_prefixed;
1176    }
1177
1178    /*
1179     * Hide "toggle off" warning if Privoxy is toggled on.
1180     */
1181    if (
1182 #ifdef FEATURE_TOGGLE
1183        (global_toggle_state == 1) &&
1184 #endif /* def FEATURE_TOGGLE */
1185        map_block_killer(exports, "privoxy-is-toggled-off")
1186       )
1187    {
1188       free_map(exports);
1189       return JB_ERR_MEMORY;
1190    }
1191
1192    if (url_param[0] == '\0')
1193    {
1194       /* URL paramater not specified, display query form only. */
1195       free(url_param);
1196       if (map_block_killer(exports, "url-given")
1197         || map(exports, "url", 1, "", 1))
1198       {
1199          free_map(exports);
1200          return JB_ERR_MEMORY;
1201       }
1202    }
1203    else
1204    {
1205       /* Given a URL, so query it. */
1206       jb_err err;
1207       char *matches;
1208       char *s;
1209       int hits = 0;
1210       struct file_list *fl;
1211       struct url_actions *b;
1212       struct http_request url_to_query[1];
1213       struct current_action_spec action[1];
1214       int i;
1215
1216       if (map(exports, "url", 1, html_encode(url_param), 0))
1217       {
1218          free(url_param);
1219          free_map(exports);
1220          return JB_ERR_MEMORY;
1221       }
1222
1223       init_current_action(action);
1224
1225       if (map(exports, "default", 1, current_action_to_html(csp, action), 0))
1226       {
1227          free_current_action(action);
1228          free(url_param);
1229          free_map(exports);
1230          return JB_ERR_MEMORY;
1231       }
1232
1233       memset(url_to_query, '\0', sizeof(url_to_query));
1234       err = parse_http_url(url_param, url_to_query, REQUIRE_PROTOCOL);
1235       assert((err != JB_ERR_OK) || (url_to_query->ssl == !strncmpic(url_param, "https://", 8)));
1236
1237       free(url_param);
1238
1239       if (err == JB_ERR_MEMORY)
1240       {
1241          free_http_request(url_to_query);
1242          free_current_action(action);
1243          free_map(exports);
1244          return JB_ERR_MEMORY;
1245       }
1246       else if (err)
1247       {
1248          /* Invalid URL */
1249
1250          err = map(exports, "matches", 1, "<b>[Invalid URL specified!]</b>" , 1);
1251          if (!err) err = map(exports, "final", 1, lookup(exports, "default"), 1);
1252          if (!err) err = map_block_killer(exports, "valid-url");
1253
1254          free_current_action(action);
1255          free_http_request(url_to_query);
1256
1257          if (err)
1258          {
1259             free_map(exports);
1260             return JB_ERR_MEMORY;
1261          }
1262
1263          return template_fill_for_cgi(csp, "show-url-info", exports, rsp);
1264       }
1265
1266       /*
1267        * We have a warning about SSL paths.  Hide it for unencrypted sites.
1268        */
1269       if (!url_to_query->ssl)
1270       {
1271          if (map_block_killer(exports, "https"))
1272          {
1273             free_current_action(action);
1274             free_map(exports);
1275             free_http_request(url_to_query);
1276             return JB_ERR_MEMORY;
1277          }
1278       }
1279
1280       matches = strdup("<table summary=\"\" class=\"transparent\">");
1281
1282       for (i = 0; i < MAX_AF_FILES; i++)
1283       {
1284          if (NULL == csp->config->actions_file_short[i]
1285              || !strcmp(csp->config->actions_file_short[i], "standard.action")) continue;
1286
1287          b = NULL;
1288          hits = 1;
1289          if ((fl = csp->actions_list[i]) != NULL)
1290          {
1291             if ((b = fl->f) != NULL)
1292             {
1293                /* FIXME: Hardcoded HTML! */
1294                string_append(&matches, "<tr><th>In file: ");
1295                string_join  (&matches, html_encode(csp->config->actions_file_short[i]));
1296                snprintf(buf, sizeof(buf), " <a class=\"cmd\" href=\"/show-status?file=actions&amp;index=%d\">", i);
1297                string_append(&matches, buf);
1298                string_append(&matches, "View</a>");
1299 #ifdef FEATURE_CGI_EDIT_ACTIONS
1300                if (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS)
1301                {
1302 #ifdef HAVE_ACCESS
1303                   if (access(csp->config->actions_file[i], W_OK) == 0)
1304                   {
1305 #endif /* def HAVE_ACCESS */
1306                      snprintf(buf, sizeof(buf),
1307                         " <a class=\"cmd\" href=\"/edit-actions-list?f=%d\">", i);
1308                      string_append(&matches, buf);
1309                      string_append(&matches, "Edit</a>");
1310 #ifdef HAVE_ACCESS
1311                   }
1312                   else
1313                   {
1314                      string_append(&matches, " <strong>No write access.</strong>");
1315                   }
1316 #endif /* def HAVE_ACCESS */
1317                }
1318 #endif /* FEATURE_CGI_EDIT_ACTIONS */
1319
1320                string_append(&matches, "</th></tr>\n");
1321
1322                hits = 0;
1323                b = b->next;
1324             }
1325          }
1326
1327          for (; (b != NULL) && (matches != NULL); b = b->next)
1328          {
1329             if (url_match(b->url, url_to_query))
1330             {
1331                string_append(&matches, "<tr><td>{");
1332                string_join  (&matches, actions_to_html(csp, b->action));
1333                string_append(&matches, " }<br>\n<code>");
1334                string_join  (&matches, html_encode(b->url->spec));
1335                string_append(&matches, "</code></td></tr>\n");
1336
1337                if (merge_current_action(action, b->action))
1338                {
1339                   freez(matches);
1340                   free_http_request(url_to_query);
1341                   free_current_action(action);
1342                   free_map(exports);
1343                   return JB_ERR_MEMORY;
1344                }
1345                hits++;
1346             }
1347          }
1348
1349          if (!hits)
1350          {
1351             string_append(&matches, "<tr><td>(no matches in this file)</td></tr>\n");
1352          }
1353       }
1354       string_append(&matches, "</table>\n");
1355
1356       /*
1357        * XXX: Kludge to make sure the "Forward settings" section
1358        * shows what forward-override{} would do with the requested URL.
1359        * No one really cares how the CGI request would be forwarded
1360        * if it wasn't intercepted as CGI request in the first place.
1361        *
1362        * From here on the action bitmask will no longer reflect
1363        * the real url (http://config.privoxy.org/show-url-info?url=.*),
1364        * but luckily it's no longer required later on anyway.
1365        */
1366       free_current_action(csp->action);
1367       get_url_actions(csp, url_to_query);
1368
1369       /*
1370        * Fill in forwarding settings.
1371        *
1372        * The possibilities are:
1373        *  - no forwarding
1374        *  - http forwarding only
1375        *  - socks4(a) forwarding only
1376        *  - socks4(a) and http forwarding.
1377        *
1378        * XXX: Parts of this code could be reused for the
1379        * "forwarding-failed" template which currently doesn't
1380        * display the proxy port and an eventual second forwarder.
1381        */
1382       {
1383          const struct forward_spec *fwd = forward_url(csp, url_to_query);
1384
1385          if ((fwd->gateway_host == NULL) && (fwd->forward_host == NULL))
1386          {
1387             if (!err) err = map_block_killer(exports, "socks-forwarder");
1388             if (!err) err = map_block_killer(exports, "http-forwarder");
1389          }
1390          else
1391          {
1392             char port[10]; /* We save proxy ports as int but need a string here */
1393
1394             if (!err) err = map_block_killer(exports, "no-forwarder");
1395
1396             if (fwd->gateway_host != NULL)
1397             {
1398                char *socks_type = NULL;
1399
1400                switch (fwd->type)
1401                {
1402                   case SOCKS_4:
1403                      socks_type = "socks4";
1404                      break;
1405                   case SOCKS_4A:
1406                      socks_type = "socks4a";
1407                      break;
1408                   case SOCKS_5:
1409                      socks_type = "socks5";
1410                      break;
1411                   case SOCKS_5T:
1412                      socks_type = "socks5t";
1413                      break;
1414                   default:
1415                      log_error(LOG_LEVEL_FATAL, "Unknown socks type: %d.", fwd->type);
1416                }
1417
1418                if (!err) err = map(exports, "socks-type", 1, socks_type, 1);
1419                if (!err) err = map(exports, "gateway-host", 1, fwd->gateway_host, 1);
1420                snprintf(port, sizeof(port), "%d", fwd->gateway_port);
1421                if (!err) err = map(exports, "gateway-port", 1, port, 1);
1422             }
1423             else
1424             {
1425                if (!err) err = map_block_killer(exports, "socks-forwarder");
1426             }
1427
1428             if (fwd->forward_host != NULL)
1429             {
1430                if (!err) err = map(exports, "forward-host", 1, fwd->forward_host, 1);
1431                snprintf(port, sizeof(port), "%d", fwd->forward_port);
1432                if (!err) err = map(exports, "forward-port", 1, port, 1);
1433             }
1434             else
1435             {
1436                if (!err) err = map_block_killer(exports, "http-forwarder");
1437             }
1438          }
1439       }
1440
1441       free_http_request(url_to_query);
1442
1443       if (err || matches == NULL)
1444       {
1445          free_current_action(action);
1446          free_map(exports);
1447          return JB_ERR_MEMORY;
1448       }
1449
1450 #ifdef FEATURE_CGI_EDIT_ACTIONS
1451       if ((csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
1452       {
1453          err = map_block_killer(exports, "cgi-editor-is-disabled");
1454       }
1455 #endif /* FEATURE_CGI_EDIT_ACTIONS */
1456
1457       /*
1458        * If zlib support is available, if no content filters
1459        * are enabled or if the prevent-compression action is enabled,
1460        * suppress the "compression could prevent filtering" warning.
1461        */
1462 #ifndef FEATURE_ZLIB
1463       if (!content_filters_enabled(action) ||
1464          (action->flags & ACTION_NO_COMPRESSION))
1465 #endif
1466       {
1467          if (!err) err = map_block_killer(exports, "filters-might-be-ineffective");
1468       }
1469
1470       if (err || map(exports, "matches", 1, matches , 0))
1471       {
1472          free_current_action(action);
1473          free_map(exports);
1474          return JB_ERR_MEMORY;
1475       }
1476
1477       s = current_action_to_html(csp, action);
1478
1479       free_current_action(action);
1480
1481       if (map(exports, "final", 1, s, 0))
1482       {
1483          free_map(exports);
1484          return JB_ERR_MEMORY;
1485       }
1486    }
1487
1488    return template_fill_for_cgi(csp, "show-url-info", exports, rsp);
1489 }
1490
1491
1492 /*********************************************************************
1493  *
1494  * Function    :  cgi_robots_txt
1495  *
1496  * Description :  CGI function to return "/robots.txt".
1497  *
1498  * Parameters  :
1499  *          1  :  csp = Current client state (buffers, headers, etc...)
1500  *          2  :  rsp = http_response data structure for output
1501  *          3  :  parameters = map of cgi parameters
1502  *
1503  * CGI Parameters : None
1504  *
1505  * Returns     :  JB_ERR_OK on success
1506  *                JB_ERR_MEMORY on out-of-memory error.
1507  *
1508  *********************************************************************/
1509 jb_err cgi_robots_txt(struct client_state *csp,
1510                       struct http_response *rsp,
1511                       const struct map *parameters)
1512 {
1513    char buf[100];
1514    jb_err err;
1515
1516    (void)csp;
1517    (void)parameters;
1518
1519    rsp->body = strdup(
1520       "# This is the Privoxy control interface.\n"
1521       "# It isn't very useful to index it, and you're likely to break stuff.\n"
1522       "# So go away!\n"
1523       "\n"
1524       "User-agent: *\n"
1525       "Disallow: /\n"
1526       "\n");
1527    if (rsp->body == NULL)
1528    {
1529       return JB_ERR_MEMORY;
1530    }
1531
1532    err = enlist_unique(rsp->headers, "Content-Type: text/plain", 13);
1533
1534    rsp->is_static = 1;
1535
1536    get_http_time(7 * 24 * 60 * 60, buf, sizeof(buf)); /* 7 days into future */
1537    if (!err) err = enlist_unique_header(rsp->headers, "Expires", buf);
1538
1539    return (err ? JB_ERR_MEMORY : JB_ERR_OK);
1540 }
1541
1542
1543 /*********************************************************************
1544  *
1545  * Function    :  show_defines
1546  *
1547  * Description :  Add to a map the state od all conditional #defines
1548  *                used when building
1549  *
1550  * Parameters  :
1551  *          1  :  exports = map to extend
1552  *
1553  * Returns     :  JB_ERR_OK on success
1554  *                JB_ERR_MEMORY on out-of-memory error.
1555  *
1556  *********************************************************************/
1557 static jb_err show_defines(struct map *exports)
1558 {
1559    jb_err err = JB_ERR_OK;
1560    int i;
1561    struct feature {
1562       const char name[31];
1563       const unsigned char is_available;
1564    };
1565
1566    static const struct feature features[] = {
1567       {
1568          "FEATURE_ACCEPT_FILTER",
1569 #ifdef FEATURE_ACCEPT_FILTER
1570          1,
1571 #else
1572          0,
1573 #endif
1574       },
1575       {
1576          "FEATURE_ACL",
1577 #ifdef FEATURE_ACL
1578          1,
1579 #else
1580          0,
1581 #endif
1582       },
1583       {
1584          "FEATURE_CGI_EDIT_ACTIONS",
1585 #ifdef FEATURE_CGI_EDIT_ACTIONS
1586          1,
1587 #else
1588          0,
1589 #endif
1590       },
1591       {
1592          "FEATURE_COMPRESSION",
1593 #ifdef FEATURE_COMPRESSION
1594          1,
1595 #else
1596          0,
1597 #endif
1598       },
1599       {
1600          "FEATURE_CONNECTION_KEEP_ALIVE",
1601 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
1602          1,
1603 #else
1604          0,
1605 #endif
1606       },
1607       {
1608          "FEATURE_CONNECTION_SHARING",
1609 #ifdef FEATURE_CONNECTION_SHARING
1610          1,
1611 #else
1612          0,
1613 #endif
1614       },
1615       {
1616          "FEATURE_FAST_REDIRECTS",
1617 #ifdef FEATURE_FAST_REDIRECTS
1618          1,
1619 #else
1620          0,
1621 #endif
1622       },
1623       {
1624          "FEATURE_FORCE_LOAD",
1625 #ifdef FEATURE_FORCE_LOAD
1626          1,
1627 #else
1628          0,
1629 #endif
1630       },
1631       {
1632          "FEATURE_GRACEFUL_TERMINATION",
1633 #ifdef FEATURE_GRACEFUL_TERMINATION
1634          1,
1635 #else
1636          0,
1637 #endif
1638       },
1639       {
1640          "FEATURE_IMAGE_BLOCKING",
1641 #ifdef FEATURE_IMAGE_BLOCKING
1642          1,
1643 #else
1644          0,
1645 #endif
1646       },
1647       {
1648          "FEATURE_IMAGE_DETECT_MSIE",
1649 #ifdef FEATURE_IMAGE_DETECT_MSIE
1650          1,
1651 #else
1652          0,
1653 #endif
1654       },
1655       {
1656          "FEATURE_IPV6_SUPPORT",
1657 #ifdef HAVE_RFC2553
1658          1,
1659 #else
1660          0,
1661 #endif
1662       },
1663       {
1664          "FEATURE_NO_GIFS",
1665 #ifdef FEATURE_NO_GIFS
1666          1,
1667 #else
1668          0,
1669 #endif
1670       },
1671       {
1672          "FEATURE_PTHREAD",
1673 #ifdef FEATURE_PTHREAD
1674          1,
1675 #else
1676          0,
1677 #endif
1678       },
1679       {
1680          "FEATURE_STATISTICS",
1681 #ifdef FEATURE_STATISTICS
1682          1,
1683 #else
1684          0,
1685 #endif
1686       },
1687       {
1688          "FEATURE_STRPTIME_SANITY_CHECKS",
1689 #ifdef FEATURE_STRPTIME_SANITY_CHECKS
1690          1,
1691 #else
1692          0,
1693 #endif
1694       },
1695       {
1696          "FEATURE_TOGGLE",
1697 #ifdef FEATURE_TOGGLE
1698          1,
1699 #else
1700          0,
1701 #endif
1702       },
1703       {
1704          "FEATURE_TRUST",
1705 #ifdef FEATURE_TRUST
1706          1,
1707 #else
1708          0,
1709 #endif
1710       },
1711       {
1712          "FEATURE_ZLIB",
1713 #ifdef FEATURE_ZLIB
1714          1,
1715 #else
1716          0,
1717 #endif
1718       },
1719       {
1720          "FEATURE_DYNAMIC_PCRE",
1721 #ifdef FEATURE_DYNAMIC_PCRE
1722          1,
1723 #else
1724          0,
1725 #endif
1726       }
1727    };
1728
1729    for (i = 0; i < SZ(features); i++)
1730    {
1731       err = map_conditional(exports, features[i].name, features[i].is_available);
1732       if (err)
1733       {
1734          break;
1735       }
1736    }
1737
1738    return err;
1739
1740 }
1741
1742
1743 /*********************************************************************
1744  *
1745  * Function    :  show_rcs
1746  *
1747  * Description :  Create a string with the rcs info for all sourcefiles
1748  *
1749  * Parameters  :  None
1750  *
1751  * Returns     :  A string, or NULL on out-of-memory.
1752  *
1753  *********************************************************************/
1754 static char *show_rcs(void)
1755 {
1756    char *result = strdup("");
1757    char buf[BUFFER_SIZE];
1758
1759    /* Instead of including *all* dot h's in the project (thus creating a
1760     * tremendous amount of dependencies), I will concede to declaring them
1761     * as extern's.  This forces the developer to add to this list, but oh well.
1762     */
1763
1764 #define SHOW_RCS(__x)              \
1765    {                               \
1766       extern const char __x[];     \
1767       snprintf(buf, sizeof(buf), " %s\n", __x);   \
1768       string_append(&result, buf); \
1769    }
1770
1771    /* In alphabetical order */
1772    SHOW_RCS(actions_h_rcs)
1773    SHOW_RCS(actions_rcs)
1774 #ifdef AMIGA
1775    SHOW_RCS(amiga_h_rcs)
1776    SHOW_RCS(amiga_rcs)
1777 #endif /* def AMIGA */
1778    SHOW_RCS(cgi_h_rcs)
1779    SHOW_RCS(cgi_rcs)
1780 #ifdef FEATURE_CGI_EDIT_ACTIONS
1781    SHOW_RCS(cgiedit_h_rcs)
1782    SHOW_RCS(cgiedit_rcs)
1783 #endif /* def FEATURE_CGI_EDIT_ACTIONS */
1784    SHOW_RCS(cgisimple_h_rcs)
1785    SHOW_RCS(cgisimple_rcs)
1786 #ifdef __MINGW32__
1787    SHOW_RCS(cygwin_h_rcs)
1788 #endif
1789    SHOW_RCS(deanimate_h_rcs)
1790    SHOW_RCS(deanimate_rcs)
1791    SHOW_RCS(encode_h_rcs)
1792    SHOW_RCS(encode_rcs)
1793    SHOW_RCS(errlog_h_rcs)
1794    SHOW_RCS(errlog_rcs)
1795    SHOW_RCS(filters_h_rcs)
1796    SHOW_RCS(filters_rcs)
1797    SHOW_RCS(gateway_h_rcs)
1798    SHOW_RCS(gateway_rcs)
1799    SHOW_RCS(jbsockets_h_rcs)
1800    SHOW_RCS(jbsockets_rcs)
1801    SHOW_RCS(jcc_h_rcs)
1802    SHOW_RCS(jcc_rcs)
1803    SHOW_RCS(list_h_rcs)
1804    SHOW_RCS(list_rcs)
1805    SHOW_RCS(loadcfg_h_rcs)
1806    SHOW_RCS(loadcfg_rcs)
1807    SHOW_RCS(loaders_h_rcs)
1808    SHOW_RCS(loaders_rcs)
1809    SHOW_RCS(miscutil_h_rcs)
1810    SHOW_RCS(miscutil_rcs)
1811    SHOW_RCS(parsers_h_rcs)
1812    SHOW_RCS(parsers_rcs)
1813    SHOW_RCS(pcrs_rcs)
1814    SHOW_RCS(pcrs_h_rcs)
1815    SHOW_RCS(project_h_rcs)
1816    SHOW_RCS(ssplit_h_rcs)
1817    SHOW_RCS(ssplit_rcs)
1818    SHOW_RCS(urlmatch_h_rcs)
1819    SHOW_RCS(urlmatch_rcs)
1820 #ifdef _WIN32
1821 #ifndef _WIN_CONSOLE
1822    SHOW_RCS(w32log_h_rcs)
1823    SHOW_RCS(w32log_rcs)
1824    SHOW_RCS(w32res_h_rcs)
1825    SHOW_RCS(w32taskbar_h_rcs)
1826    SHOW_RCS(w32taskbar_rcs)
1827 #endif /* ndef _WIN_CONSOLE */
1828    SHOW_RCS(win32_h_rcs)
1829    SHOW_RCS(win32_rcs)
1830 #endif /* def _WIN32 */
1831
1832 #undef SHOW_RCS
1833
1834    return result;
1835
1836 }
1837
1838
1839 /*********************************************************************
1840  *
1841  * Function    :  cgi_show_file
1842  *
1843  * Description :  CGI function that shows the content of a
1844  *                configuration file.
1845  *
1846  * Parameters  :
1847  *          1  :  csp = Current client state (buffers, headers, etc...)
1848  *          2  :  rsp = http_response data structure for output
1849  *          3  :  parameters = map of cgi parameters
1850  *
1851  * CGI Parameters :
1852  *        file :  Which file to show.  Only first letter is checked,
1853  *                valid values are:
1854  *                - "a"ction file
1855  *                - "r"egex
1856  *                - "t"rust
1857  *                Default is to show menu and other information.
1858  *
1859  * Returns     :  JB_ERR_OK on success
1860  *                JB_ERR_MEMORY on out-of-memory error.
1861  *
1862  *********************************************************************/
1863 static jb_err cgi_show_file(struct client_state *csp,
1864                             struct http_response *rsp,
1865                             const struct map *parameters)
1866 {
1867    unsigned i;
1868    const char * filename = NULL;
1869    char * file_description = NULL;
1870
1871    assert(csp);
1872    assert(rsp);
1873    assert(parameters);
1874
1875    switch (*(lookup(parameters, "file")))
1876    {
1877    case 'a':
1878       if (!get_number_param(csp, parameters, "index", &i) && i < MAX_AF_FILES && csp->actions_list[i])
1879       {
1880          filename = csp->actions_list[i]->filename;
1881          file_description = "Actions File";
1882       }
1883       break;
1884
1885    case 'f':
1886       if (!get_number_param(csp, parameters, "index", &i) && i < MAX_AF_FILES && csp->rlist[i])
1887       {
1888          filename = csp->rlist[i]->filename;
1889          file_description = "Filter File";
1890       }
1891       break;
1892
1893 #ifdef FEATURE_TRUST
1894    case 't':
1895       if (csp->tlist)
1896       {
1897          filename = csp->tlist->filename;
1898          file_description = "Trust File";
1899       }
1900       break;
1901 #endif /* def FEATURE_TRUST */
1902    }
1903
1904    if (NULL != filename)
1905    {
1906       struct map *exports;
1907       char *s;
1908       jb_err err;
1909       size_t length;
1910
1911       exports = default_exports(csp, "show-status");
1912       if (NULL == exports)
1913       {
1914          return JB_ERR_MEMORY;
1915       }
1916
1917       if (map(exports, "file-description", 1, file_description, 1)
1918         || map(exports, "filepath", 1, html_encode(filename), 0))
1919       {
1920          free_map(exports);
1921          return JB_ERR_MEMORY;
1922       }
1923
1924       err = load_file(filename, &s, &length);
1925       if (JB_ERR_OK != err)
1926       {
1927          if (map(exports, "contents", 1, "<h1>ERROR OPENING FILE!</h1>", 1))
1928          {
1929             free_map(exports);
1930             return JB_ERR_MEMORY;
1931          }
1932       }
1933       else
1934       {
1935          s = html_encode_and_free_original(s);
1936          if (NULL == s)
1937          {
1938             return JB_ERR_MEMORY;
1939          }
1940
1941          if (map(exports, "contents", 1, s, 0))
1942          {
1943             free_map(exports);
1944             return JB_ERR_MEMORY;
1945          }
1946       }
1947
1948       return template_fill_for_cgi(csp, "show-status-file", exports, rsp);
1949    }
1950
1951    return JB_ERR_CGI_PARAMS;
1952 }
1953
1954
1955 /*********************************************************************
1956  *
1957  * Function    :  load_file
1958  *
1959  * Description :  Loads a file into a buffer.
1960  *
1961  * Parameters  :
1962  *          1  :  filename = Name of the file to be loaded.
1963  *          2  :  buffer   = Used to return the file's content.
1964  *          3  :  length   = Used to return the size of the file.
1965  *
1966  * Returns     :  JB_ERR_OK in case of success,
1967  *                JB_ERR_FILE in case of ordinary file loading errors
1968  *                            (fseek() and ftell() errors are fatal)
1969  *                JB_ERR_MEMORY in case of out-of-memory.
1970  *
1971  *********************************************************************/
1972 static jb_err load_file(const char *filename, char **buffer, size_t *length)
1973 {
1974    FILE *fp;
1975    long ret;
1976    jb_err err = JB_ERR_OK;
1977
1978    fp = fopen(filename, "rb");
1979    if (NULL == fp)
1980    {
1981       log_error(LOG_LEVEL_ERROR, "Failed to open %s: %E", filename);
1982       return JB_ERR_FILE;
1983    }
1984
1985    /* Get file length */
1986    if (fseek(fp, 0, SEEK_END))
1987    {
1988       log_error(LOG_LEVEL_FATAL,
1989          "Unexpected error while fseek()ing to the end of %s: %E",
1990          filename);
1991    }
1992    ret = ftell(fp);
1993    if (-1 == ret)
1994    {
1995       log_error(LOG_LEVEL_FATAL,
1996          "Unexpected ftell() error while loading %s: %E",
1997          filename);
1998    }
1999    *length = (size_t)ret;
2000
2001    /* Go back to the beginning. */
2002    if (fseek(fp, 0, SEEK_SET))
2003    {
2004       log_error(LOG_LEVEL_FATAL,
2005          "Unexpected error while fseek()ing to the beginning of %s: %E",
2006          filename);
2007    }
2008
2009    *buffer = (char *)zalloc(*length + 1);
2010    if (NULL == *buffer)
2011    {
2012       err = JB_ERR_MEMORY;
2013    }
2014    else if (!fread(*buffer, *length, 1, fp))
2015    {
2016       /*
2017        * May happen if the file size changes between fseek() and
2018        * fread(). If it does, we just log it and serve what we got.
2019        */
2020       log_error(LOG_LEVEL_ERROR,
2021          "Couldn't completely read file %s.", filename);
2022       err = JB_ERR_FILE;
2023    }
2024
2025    fclose(fp);
2026
2027    return err;
2028
2029 }
2030
2031
2032 /*
2033   Local Variables:
2034   tab-width: 3
2035   end:
2036 */