filters.c

   1 const char filters_rcs[] = "$Id: filters.c,v 1.205 2017/06/04 14:42:54 fabiankeil Exp $";
   2 /*********************************************************************
   3  *
   4  * File        :  $Source: /cvsroot/ijbswa/current/filters.c,v $
   5  *
   6  * Purpose     :  Declares functions to parse/crunch headers and pages.
   7  *
   8  * Copyright   :  Written by and Copyright (C) 2001-2016 the
   9  *                Privoxy team. http://www.privoxy.org/
  10  *
  11  *                Based on the Internet Junkbuster originally written
  12  *                by and Copyright (C) 1997 Anonymous Coders and
  13  *                Junkbusters Corporation.  http://www.junkbusters.com
  14  *
  15  *                This program is free software; you can redistribute it
  16  *                and/or modify it under the terms of the GNU General
  17  *                Public License as published by the Free Software
  18  *                Foundation; either version 2 of the License, or (at
  19  *                your option) any later version.
  20  *
  21  *                This program is distributed in the hope that it will
  22  *                be useful, but WITHOUT ANY WARRANTY; without even the
  23  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
  24  *                PARTICULAR PURPOSE.  See the GNU General Public
  25  *                License for more details.
  26  *
  27  *                The GNU General Public License should be included with
  28  *                this file.  If not, you can view it at
  29  *                http://www.gnu.org/copyleft/gpl.html
  30  *                or write to the Free Software Foundation, Inc., 59
  31  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  32  *
  33  *********************************************************************/
  34
  35
  36 #include "config.h"
  37
  38 #include <stdio.h>
  39 #include <sys/types.h>
  40 #include <stdlib.h>
  41 #include <ctype.h>
  42 #include <string.h>
  43 #include <assert.h>
  44
  45 #ifndef _WIN32
  46 #ifndef __OS2__
  47 #include <unistd.h>
  48 #endif /* ndef __OS2__ */
  49 #include <netinet/in.h>
  50 #else
  51 #include <winsock2.h>
  52 #endif /* ndef _WIN32 */
  53
  54 #ifdef __OS2__
  55 #include <utils.h>
  56 #endif /* def __OS2__ */
  57
  58 #include "project.h"
  59 #include "filters.h"
  60 #include "encode.h"
  61 #include "parsers.h"
  62 #include "ssplit.h"
  63 #include "errlog.h"
  64 #include "jbsockets.h"
  65 #include "miscutil.h"
  66 #include "actions.h"
  67 #include "cgi.h"
  68 #include "jcc.h"
  69 #include "list.h"
  70 #include "deanimate.h"
  71 #include "urlmatch.h"
  72 #include "loaders.h"
  73 #ifdef FEATURE_CLIENT_TAGS
  74 #include "client-tags.h"
  75 #endif
  76
  77 #ifdef _WIN32
  78 #include "win32.h"
  79 #endif
  80
  81 const char filters_h_rcs[] = FILTERS_H_VERSION;
  82
  83 typedef char *(*filter_function_ptr)();
  84 static filter_function_ptr get_filter_function(const struct client_state *csp);
  85 static jb_err prepare_for_filtering(struct client_state *csp);
  86 static void apply_url_actions(struct current_action_spec *action,
  87                               struct http_request *http,
  88 #ifdef FEATURE_CLIENT_TAGS
  89                               const struct list *client_tags,
  90 #endif
  91                               struct url_actions *b);
  92
  93 #ifdef FEATURE_ACL
  94 #ifdef HAVE_RFC2553
  95 /*********************************************************************
  96  *
  97  * Function    :  sockaddr_storage_to_ip
  98  *
  99  * Description :  Access internal structure of sockaddr_storage
 100  *
 101  * Parameters  :
 102  *          1  :  addr = socket address
 103  *          2  :  ip   = IP address as array of octets in network order
 104  *                       (it points into addr)
 105  *          3  :  len  = length of IP address in octets
 106  *          4  :  port = port number in network order;
 107  *
 108  * Returns     :  0 = no errror; -1 otherwise.
 109  *
 110  *********************************************************************/
 111 static int sockaddr_storage_to_ip(const struct sockaddr_storage *addr,
 112                                   uint8_t **ip, unsigned int *len,
 113                                   in_port_t **port)
 114 {
 115    assert(NULL != addr);
 116    assert(addr->ss_family == AF_INET || addr->ss_family == AF_INET6);
 117
 118    switch (addr->ss_family)
 119    {
 120       case AF_INET:
 121          if (NULL != len)
 122          {
 123             *len = 4;
 124          }
 125          if (NULL != ip)
 126          {
 127             *ip = (uint8_t *)
 128                &(((struct sockaddr_in *)addr)->sin_addr.s_addr);
 129          }
 130          if (NULL != port)
 131          {
 132             *port = &((struct sockaddr_in *)addr)->sin_port;
 133          }
 134          break;
 135
 136       case AF_INET6:
 137          if (NULL != len)
 138          {
 139             *len = 16;
 140          }
 141          if (NULL != ip)
 142          {
 143             *ip = ((struct sockaddr_in6 *)addr)->sin6_addr.s6_addr;
 144          }
 145          if (NULL != port)
 146          {
 147             *port = &((struct sockaddr_in6 *)addr)->sin6_port;
 148          }
 149          break;
 150
 151       default:
 152          /* Unsupported address family */
 153          return(-1);
 154    }
 155
 156    return(0);
 157 }
 158
 159
 160 /*********************************************************************
 161  *
 162  * Function    :  match_sockaddr
 163  *
 164  * Description :  Check whether address matches network (IP address and port)
 165  *
 166  * Parameters  :
 167  *          1  :  network = socket address of subnework
 168  *          2  :  netmask = network mask as socket address
 169  *          3  :  address = checked socket address against given network
 170  *
 171  * Returns     :  0 = doesn't match; 1 = does match
 172  *
 173  *********************************************************************/
 174 static int match_sockaddr(const struct sockaddr_storage *network,
 175                           const struct sockaddr_storage *netmask,
 176                           const struct sockaddr_storage *address)
 177 {
 178    uint8_t *network_addr, *netmask_addr, *address_addr;
 179    unsigned int addr_len;
 180    in_port_t *network_port, *netmask_port, *address_port;
 181    int i;
 182
 183    if (network->ss_family != netmask->ss_family)
 184    {
 185       /* This should never happen */
 186       assert(network->ss_family == netmask->ss_family);
 187       log_error(LOG_LEVEL_FATAL, "Network and netmask differ in family.");
 188    }
 189
 190    sockaddr_storage_to_ip(network, &network_addr, &addr_len, &network_port);
 191    sockaddr_storage_to_ip(netmask, &netmask_addr, NULL, &netmask_port);
 192    sockaddr_storage_to_ip(address, &address_addr, NULL, &address_port);
 193
 194    /* Check for family */
 195    if ((network->ss_family == AF_INET) && (address->ss_family == AF_INET6)
 196       && IN6_IS_ADDR_V4MAPPED((struct in6_addr *)address_addr))
 197    {
 198       /* Map AF_INET6 V4MAPPED address into AF_INET */
 199       address_addr += 12;
 200       addr_len = 4;
 201    }
 202    else if ((network->ss_family == AF_INET6) && (address->ss_family == AF_INET)
 203       && IN6_IS_ADDR_V4MAPPED((struct in6_addr *)network_addr))
 204    {
 205       /* Map AF_INET6 V4MAPPED network into AF_INET */
 206       network_addr += 12;
 207       netmask_addr += 12;
 208       addr_len = 4;
 209    }
 210
 211    /* XXX: Port check is signaled in netmask */
 212    if (*netmask_port && *network_port != *address_port)
 213    {
 214       return 0;
 215    }
 216
 217    /* TODO: Optimize by checking by words insted of octets */
 218    for (i = 0; (i < addr_len) && netmask_addr[i]; i++)
 219    {
 220       if ((network_addr[i] & netmask_addr[i]) !=
 221           (address_addr[i] & netmask_addr[i]))
 222       {
 223          return 0;
 224       }
 225    }
 226
 227    return 1;
 228 }
 229 #endif /* def HAVE_RFC2553 */
 230
 231
 232 /*********************************************************************
 233  *
 234  * Function    :  block_acl
 235  *
 236  * Description :  Block this request?
 237  *                Decide yes or no based on ACL file.
 238  *
 239  * Parameters  :
 240  *          1  :  dst = The proxy or gateway address this is going to.
 241  *                      Or NULL to check all possible targets.
 242  *          2  :  csp = Current client state (buffers, headers, etc...)
 243  *                      Also includes the client IP address.
 244  *
 245  * Returns     : 0 = FALSE (don't block) and 1 = TRUE (do block)
 246  *
 247  *********************************************************************/
 248 int block_acl(const struct access_control_addr *dst, const struct client_state *csp)
 249 {
 250    struct access_control_list *acl = csp->config->acl;
 251
 252    /* if not using an access control list, then permit the connection */
 253    if (acl == NULL)
 254    {
 255       return(0);
 256    }
 257
 258    /* search the list */
 259    while (acl != NULL)
 260    {
 261       if (
 262 #ifdef HAVE_RFC2553
 263             match_sockaddr(&acl->src->addr, &acl->src->mask, &csp->tcp_addr)
 264 #else
 265             (csp->ip_addr_long & acl->src->mask) == acl->src->addr
 266 #endif
 267             )
 268       {
 269          if (dst == NULL)
 270          {
 271             /* Just want to check if they have any access */
 272             if (acl->action == ACL_PERMIT)
 273             {
 274                return(0);
 275             }
 276             else
 277             {
 278                return(1);
 279             }
 280          }
 281          else if (
 282 #ifdef HAVE_RFC2553
 283                /*
 284                 * XXX: An undefined acl->dst is full of zeros and should be
 285                 * considered a wildcard address. sockaddr_storage_to_ip()
 286                 * fails on such destinations because of unknown sa_familly
 287                 * (glibc only?). However this test is not portable.
 288                 *
 289                 * So, we signal the acl->dst is wildcard in wildcard_dst.
 290                 */
 291                acl->wildcard_dst ||
 292                   match_sockaddr(&acl->dst->addr, &acl->dst->mask, &dst->addr)
 293 #else
 294                ((dst->addr & acl->dst->mask) == acl->dst->addr)
 295            && ((dst->port == acl->dst->port) || (acl->dst->port == 0))
 296 #endif
 297            )
 298          {
 299             if (acl->action == ACL_PERMIT)
 300             {
 301                return(0);
 302             }
 303             else
 304             {
 305                return(1);
 306             }
 307          }
 308       }
 309       acl = acl->next;
 310    }
 311
 312    return(1);
 313
 314 }
 315
 316
 317 /*********************************************************************
 318  *
 319  * Function    :  acl_addr
 320  *
 321  * Description :  Called from `load_config' to parse an ACL address.
 322  *
 323  * Parameters  :
 324  *          1  :  aspec = String specifying ACL address.
 325  *          2  :  aca = struct access_control_addr to fill in.
 326  *
 327  * Returns     :  0 => Ok, everything else is an error.
 328  *
 329  *********************************************************************/
 330 int acl_addr(const char *aspec, struct access_control_addr *aca)
 331 {
 332    int i, masklength;
 333 #ifdef HAVE_RFC2553
 334    struct addrinfo hints, *result;
 335    uint8_t *mask_data;
 336    in_port_t *mask_port;
 337    unsigned int addr_len;
 338 #else
 339    long port;
 340 #endif /* def HAVE_RFC2553 */
 341    char *p;
 342    char *acl_spec = NULL;
 343
 344 #ifdef HAVE_RFC2553
 345    /* XXX: Depend on ai_family */
 346    masklength = 128;
 347 #else
 348    masklength = 32;
 349    port       =  0;
 350 #endif
 351
 352    /*
 353     * Use a temporary acl spec copy so we can log
 354     * the unmodified original in case of parse errors.
 355     */
 356    acl_spec = strdup_or_die(aspec);
 357
 358    if ((p = strchr(acl_spec, '/')) != NULL)
 359    {
 360       *p++ = '\0';
 361       if (privoxy_isdigit(*p) == 0)
 362       {
 363          freez(acl_spec);
 364          return(-1);
 365       }
 366       masklength = atoi(p);
 367    }
 368
 369    if ((masklength < 0) ||
 370 #ifdef HAVE_RFC2553
 371          (masklength > 128)
 372 #else
 373          (masklength > 32)
 374 #endif
 375          )
 376    {
 377       freez(acl_spec);
 378       return(-1);
 379    }
 380
 381    if ((*acl_spec == '[') && (NULL != (p = strchr(acl_spec, ']'))))
 382    {
 383       *p = '\0';
 384       memmove(acl_spec, acl_spec + 1, (size_t)(p - acl_spec));
 385
 386       if (*++p != ':')
 387       {
 388          p = NULL;
 389       }
 390    }
 391    else
 392    {
 393       p = strchr(acl_spec, ':');
 394    }
 395    if (p != NULL)
 396    {
 397       assert(*p == ':');
 398       *p = '\0';
 399       p++;
 400    }
 401
 402 #ifdef HAVE_RFC2553
 403    memset(&hints, 0, sizeof(struct addrinfo));
 404    hints.ai_family = AF_UNSPEC;
 405    hints.ai_socktype = SOCK_STREAM;
 406
 407    i = getaddrinfo(acl_spec, p, &hints, &result);
 408
 409    if (i != 0)
 410    {
 411       log_error(LOG_LEVEL_ERROR, "Can not resolve [%s]:%s: %s",
 412          acl_spec, p, gai_strerror(i));
 413       freez(acl_spec);
 414       return(-1);
 415    }
 416    freez(acl_spec);
 417
 418    /* TODO: Allow multihomed hostnames */
 419    memcpy(&(aca->addr), result->ai_addr, result->ai_addrlen);
 420    freeaddrinfo(result);
 421 #else
 422    if (p != NULL)
 423    {
 424       char *endptr;
 425
 426       port = strtol(p, &endptr, 10);
 427
 428       if (port <= 0 || port > 65535 || *endptr != '\0')
 429       {
 430          freez(acl_spec);
 431          return(-1);
 432       }
 433    }
 434
 435    aca->port = (unsigned long)port;
 436
 437    aca->addr = ntohl(resolve_hostname_to_ip(acl_spec));
 438    freez(acl_spec);
 439
 440    if (aca->addr == INADDR_NONE)
 441    {
 442       /* XXX: This will be logged as parse error. */
 443       return(-1);
 444    }
 445 #endif /* def HAVE_RFC2553 */
 446
 447    /* build the netmask */
 448 #ifdef HAVE_RFC2553
 449    /* Clip masklength according to current family. */
 450    if ((aca->addr.ss_family == AF_INET) && (masklength > 32))
 451    {
 452       masklength = 32;
 453    }
 454
 455    aca->mask.ss_family = aca->addr.ss_family;
 456    if (sockaddr_storage_to_ip(&aca->mask, &mask_data, &addr_len, &mask_port))
 457    {
 458       return(-1);
 459    }
 460
 461    if (p)
 462    {
 463       /* ACL contains a port number, check ports in the future. */
 464       *mask_port = 1;
 465    }
 466
 467    /*
 468     * XXX: This could be optimized to operate on whole words instead
 469     * of octets (128-bit CPU could do it in one iteration).
 470     */
 471    /*
 472     * Octets after prefix can be omitted because of
 473     * previous initialization to zeros.
 474     */
 475    for (i = 0; (i < addr_len) && masklength; i++)
 476    {
 477       if (masklength >= 8)
 478       {
 479          mask_data[i] = 0xFF;
 480          masklength -= 8;
 481       }
 482       else
 483       {
 484          /*
 485           * XXX: This assumes MSB of octet is on the left side.
 486           * This should be true for all architectures or solved
 487           * by the link layer.
 488           */
 489          mask_data[i] = (uint8_t)~((1 << (8 - masklength)) - 1);
 490          masklength = 0;
 491       }
 492    }
 493
 494 #else
 495    aca->mask = 0;
 496    for (i=1; i <= masklength ; i++)
 497    {
 498       aca->mask |= (1U << (32 - i));
 499    }
 500
 501    /* now mask off the host portion of the ip address
 502     * (i.e. save on the network portion of the address).
 503     */
 504    aca->addr = aca->addr & aca->mask;
 505 #endif /* def HAVE_RFC2553 */
 506
 507    return(0);
 508
 509 }
 510 #endif /* def FEATURE_ACL */
 511
 512
 513 /*********************************************************************
 514  *
 515  * Function    :  connect_port_is_forbidden
 516  *
 517  * Description :  Check to see if CONNECT requests to the destination
 518  *                port of this request are forbidden. The check is
 519  *                independend of the actual request method.
 520  *
 521  * Parameters  :
 522  *          1  :  csp = Current client state (buffers, headers, etc...)
 523  *
 524  * Returns     :  True if yes, false otherwise.
 525  *
 526  *********************************************************************/
 527 int connect_port_is_forbidden(const struct client_state *csp)
 528 {
 529    return ((csp->action->flags & ACTION_LIMIT_CONNECT) &&
 530      !match_portlist(csp->action->string[ACTION_STRING_LIMIT_CONNECT],
 531         csp->http->port));
 532 }
 533
 534
 535 /*********************************************************************
 536  *
 537  * Function    :  block_url
 538  *
 539  * Description :  Called from `chat'.  Check to see if we need to block this.
 540  *
 541  * Parameters  :
 542  *          1  :  csp = Current client state (buffers, headers, etc...)
 543  *
 544  * Returns     :  NULL => unblocked, else HTTP block response
 545  *
 546  *********************************************************************/
 547 struct http_response *block_url(struct client_state *csp)
 548 {
 549    struct http_response *rsp;
 550    const char *new_content_type = NULL;
 551
 552    /*
 553     * If it's not blocked, don't block it ;-)
 554     */
 555    if ((csp->action->flags & ACTION_BLOCK) == 0)
 556    {
 557       return NULL;
 558    }
 559    if (csp->action->flags & ACTION_REDIRECT)
 560    {
 561       log_error(LOG_LEVEL_ERROR, "redirect{} overruled by block.");
 562    }
 563    /*
 564     * Else, prepare a response
 565     */
 566    if (NULL == (rsp = alloc_http_response()))
 567    {
 568       return cgi_error_memory();
 569    }
 570
 571    /*
 572     * If it's an image-url, send back an image or redirect
 573     * as specified by the relevant +image action
 574     */
 575 #ifdef FEATURE_IMAGE_BLOCKING
 576    if (((csp->action->flags & ACTION_IMAGE_BLOCKER) != 0)
 577         && is_imageurl(csp))
 578    {
 579       char *p;
 580       /* determine HOW images should be blocked */
 581       p = csp->action->string[ACTION_STRING_IMAGE_BLOCKER];
 582
 583       if (csp->action->flags & ACTION_HANDLE_AS_EMPTY_DOCUMENT)
 584       {
 585          log_error(LOG_LEVEL_ERROR, "handle-as-empty-document overruled by handle-as-image.");
 586       }
 587
 588       /* and handle accordingly: */
 589       if ((p == NULL) || (0 == strcmpic(p, "pattern")))
 590       {
 591          rsp->status = strdup_or_die("403 Request blocked by Privoxy");
 592          rsp->body = bindup(image_pattern_data, image_pattern_length);
 593          if (rsp->body == NULL)
 594          {
 595             free_http_response(rsp);
 596             return cgi_error_memory();
 597          }
 598          rsp->content_length = image_pattern_length;
 599
 600          if (enlist_unique_header(rsp->headers, "Content-Type", BUILTIN_IMAGE_MIMETYPE))
 601          {
 602             free_http_response(rsp);
 603             return cgi_error_memory();
 604          }
 605       }
 606       else if (0 == strcmpic(p, "blank"))
 607       {
 608          rsp->status = strdup_or_die("403 Request blocked by Privoxy");
 609          rsp->body = bindup(image_blank_data, image_blank_length);
 610          if (rsp->body == NULL)
 611          {
 612             free_http_response(rsp);
 613             return cgi_error_memory();
 614          }
 615          rsp->content_length = image_blank_length;
 616
 617          if (enlist_unique_header(rsp->headers, "Content-Type", BUILTIN_IMAGE_MIMETYPE))
 618          {
 619             free_http_response(rsp);
 620             return cgi_error_memory();
 621          }
 622       }
 623       else
 624       {
 625          rsp->status = strdup_or_die("302 Local Redirect from Privoxy");
 626
 627          if (enlist_unique_header(rsp->headers, "Location", p))
 628          {
 629             free_http_response(rsp);
 630             return cgi_error_memory();
 631          }
 632       }
 633
 634    }
 635    else
 636 #endif /* def FEATURE_IMAGE_BLOCKING */
 637    if (csp->action->flags & ACTION_HANDLE_AS_EMPTY_DOCUMENT)
 638    {
 639      /*
 640       *  Send empty document.
 641       */
 642       new_content_type = csp->action->string[ACTION_STRING_CONTENT_TYPE];
 643
 644       freez(rsp->body);
 645       rsp->body = strdup_or_die(" ");
 646       rsp->content_length = 1;
 647
 648       if (csp->config->feature_flags & RUNTIME_FEATURE_EMPTY_DOC_RETURNS_OK)
 649       {
 650          /*
 651           * Workaround for firefox bug 492459
 652           *   https://bugzilla.mozilla.org/show_bug.cgi?id=492459
 653           * Return a 200 OK status for pages blocked with +handle-as-empty-document
 654           * if the "handle-as-empty-doc-returns-ok" runtime config option is set.
 655           */
 656          rsp->status = strdup_or_die("200 Request blocked by Privoxy");
 657       }
 658       else
 659       {
 660          rsp->status = strdup_or_die("403 Request blocked by Privoxy");
 661       }
 662
 663       if (new_content_type != 0)
 664       {
 665          log_error(LOG_LEVEL_HEADER, "Overwriting Content-Type with %s", new_content_type);
 666          if (enlist_unique_header(rsp->headers, "Content-Type", new_content_type))
 667          {
 668             free_http_response(rsp);
 669             return cgi_error_memory();
 670          }
 671       }
 672    }
 673    else
 674
 675    /*
 676     * Else, generate an HTML "blocked" message:
 677     */
 678    {
 679       jb_err err;
 680       struct map * exports;
 681
 682       rsp->status = strdup_or_die("403 Request blocked by Privoxy");
 683
 684       exports = default_exports(csp, NULL);
 685       if (exports == NULL)
 686       {
 687          free_http_response(rsp);
 688          return cgi_error_memory();
 689       }
 690
 691 #ifdef FEATURE_FORCE_LOAD
 692       err = map(exports, "force-prefix", 1, FORCE_PREFIX, 1);
 693       /*
 694        * Export the force conditional block killer if
 695        *
 696        * - Privoxy was compiled without FEATURE_FORCE_LOAD, or
 697        * - Privoxy is configured to enforce blocks, or
 698        * - it's a CONNECT request and enforcing wouldn't work anyway.
 699        */
 700       if ((csp->config->feature_flags & RUNTIME_FEATURE_ENFORCE_BLOCKS)
 701        || (0 == strcmpic(csp->http->gpc, "connect")))
 702 #endif /* ndef FEATURE_FORCE_LOAD */
 703       {
 704          err = map_block_killer(exports, "force-support");
 705       }
 706
 707       if (!err) err = map(exports, "protocol", 1, csp->http->ssl ? "https://" : "http://", 1);
 708       if (!err) err = map(exports, "hostport", 1, html_encode(csp->http->hostport), 0);
 709       if (!err) err = map(exports, "path", 1, html_encode(csp->http->path), 0);
 710       if (!err) err = map(exports, "path-ue", 1, url_encode(csp->http->path), 0);
 711       if (!err)
 712       {
 713          const char *block_reason;
 714          if (csp->action->string[ACTION_STRING_BLOCK] != NULL)
 715          {
 716             block_reason = csp->action->string[ACTION_STRING_BLOCK];
 717          }
 718          else
 719          {
 720             assert(connect_port_is_forbidden(csp));
 721             block_reason = "Forbidden CONNECT port.";
 722          }
 723          err = map(exports, "block-reason", 1, html_encode(block_reason), 0);
 724       }
 725       if (err)
 726       {
 727          free_map(exports);
 728          free_http_response(rsp);
 729          return cgi_error_memory();
 730       }
 731
 732       err = template_fill_for_cgi(csp, "blocked", exports, rsp);
 733       if (err)
 734       {
 735          free_http_response(rsp);
 736          return cgi_error_memory();
 737       }
 738    }
 739    rsp->crunch_reason = BLOCKED;
 740
 741    return finish_http_response(csp, rsp);
 742
 743 }
 744
 745
 746 #ifdef FEATURE_TRUST
 747 /*********************************************************************
 748  *
 749  * Function    :  trust_url FIXME: I should be called distrust_url
 750  *
 751  * Description :  Calls is_untrusted_url to determine if the URL is trusted
 752  *                and if not, returns a HTTP 403 response with a reject message.
 753  *
 754  * Parameters  :
 755  *          1  :  csp = Current client state (buffers, headers, etc...)
 756  *
 757  * Returns     :  NULL => trusted, else http_response.
 758  *
 759  *********************************************************************/
 760 struct http_response *trust_url(struct client_state *csp)
 761 {
 762    struct http_response *rsp;
 763    struct map * exports;
 764    char buf[BUFFER_SIZE];
 765    char *p;
 766    struct pattern_spec **tl;
 767    struct pattern_spec *t;
 768    jb_err err;
 769
 770    /*
 771     * Don't bother to work on trusted URLs
 772     */
 773    if (!is_untrusted_url(csp))
 774    {
 775       return NULL;
 776    }
 777
 778    /*
 779     * Else, prepare a response:
 780     */
 781    if (NULL == (rsp = alloc_http_response()))
 782    {
 783       return cgi_error_memory();
 784    }
 785
 786    rsp->status = strdup_or_die("403 Request blocked by Privoxy");
 787    exports = default_exports(csp, NULL);
 788    if (exports == NULL)
 789    {
 790       free_http_response(rsp);
 791       return cgi_error_memory();
 792    }
 793
 794    /*
 795     * Export the protocol, host, port, and referrer information
 796     */
 797    err = map(exports, "hostport", 1, csp->http->hostport, 1);
 798    if (!err) err = map(exports, "protocol", 1, csp->http->ssl ? "https://" : "http://", 1);
 799    if (!err) err = map(exports, "path", 1, csp->http->path, 1);
 800
 801    if (NULL != (p = get_header_value(csp->headers, "Referer:")))
 802    {
 803       if (!err) err = map(exports, "referrer", 1, html_encode(p), 0);
 804    }
 805    else
 806    {
 807       if (!err) err = map(exports, "referrer", 1, "none set", 1);
 808    }
 809
 810    if (err)
 811    {
 812       free_map(exports);
 813       free_http_response(rsp);
 814       return cgi_error_memory();
 815    }
 816
 817    /*
 818     * Export the trust list
 819     */
 820    p = strdup_or_die("");
 821    for (tl = csp->config->trust_list; (t = *tl) != NULL ; tl++)
 822    {
 823       snprintf(buf, sizeof(buf), "<li>%s</li>\n", t->spec);
 824       string_append(&p, buf);
 825    }
 826    err = map(exports, "trusted-referrers", 1, p, 0);
 827
 828    if (err)
 829    {
 830       free_map(exports);
 831       free_http_response(rsp);
 832       return cgi_error_memory();
 833    }
 834
 835    /*
 836     * Export the trust info, if available
 837     */
 838    if (csp->config->trust_info->first)
 839    {
 840       struct list_entry *l;
 841
 842       p = strdup_or_die("");
 843       for (l = csp->config->trust_info->first; l ; l = l->next)
 844       {
 845          snprintf(buf, sizeof(buf), "<li> <a href=\"%s\">%s</a><br>\n", l->str, l->str);
 846          string_append(&p, buf);
 847       }
 848       err = map(exports, "trust-info", 1, p, 0);
 849    }
 850    else
 851    {
 852       err = map_block_killer(exports, "have-trust-info");
 853    }
 854
 855    if (err)
 856    {
 857       free_map(exports);
 858       free_http_response(rsp);
 859       return cgi_error_memory();
 860    }
 861
 862    /*
 863     * Export the force conditional block killer if
 864     *
 865     * - Privoxy was compiled without FEATURE_FORCE_LOAD, or
 866     * - Privoxy is configured to enforce blocks, or
 867     * - it's a CONNECT request and enforcing wouldn't work anyway.
 868     */
 869 #ifdef FEATURE_FORCE_LOAD
 870    if ((csp->config->feature_flags & RUNTIME_FEATURE_ENFORCE_BLOCKS)
 871     || (0 == strcmpic(csp->http->gpc, "connect")))
 872    {
 873       err = map_block_killer(exports, "force-support");
 874    }
 875    else
 876    {
 877       err = map(exports, "force-prefix", 1, FORCE_PREFIX, 1);
 878    }
 879 #else /* ifndef FEATURE_FORCE_LOAD */
 880    err = map_block_killer(exports, "force-support");
 881 #endif /* ndef FEATURE_FORCE_LOAD */
 882
 883    if (err)
 884    {
 885       free_map(exports);
 886       free_http_response(rsp);
 887       return cgi_error_memory();
 888    }
 889
 890    /*
 891     * Build the response
 892     */
 893    err = template_fill_for_cgi(csp, "untrusted", exports, rsp);
 894    if (err)
 895    {
 896       free_http_response(rsp);
 897       return cgi_error_memory();
 898    }
 899    rsp->crunch_reason = UNTRUSTED;
 900
 901    return finish_http_response(csp, rsp);
 902 }
 903 #endif /* def FEATURE_TRUST */
 904
 905
 906 /*********************************************************************
 907  *
 908  * Function    :  compile_dynamic_pcrs_job_list
 909  *
 910  * Description :  Compiles a dynamic pcrs job list (one with variables
 911  *                resolved at request time)
 912  *
 913  * Parameters  :
 914  *          1  :  csp = Current client state (buffers, headers, etc...)
 915  *          2  :  b = The filter list to compile
 916  *
 917  * Returns     :  NULL in case of errors, otherwise the
 918  *                pcrs job list.
 919  *
 920  *********************************************************************/
 921 pcrs_job *compile_dynamic_pcrs_job_list(const struct client_state *csp, const struct re_filterfile_spec *b)
 922 {
 923    struct list_entry *pattern;
 924    pcrs_job *job_list = NULL;
 925    pcrs_job *dummy = NULL;
 926    pcrs_job *lastjob = NULL;
 927    int error = 0;
 928
 929    const struct pcrs_variable variables[] =
 930    {
 931       {"url",    csp->http->url,   1},
 932       {"path",   csp->http->path,  1},
 933       {"host",   csp->http->host,  1},
 934       {"origin", csp->ip_addr_str, 1},
 935       {"listen-address", csp->listen_addr_str, 1},
 936       {NULL,     NULL,             1}
 937    };
 938
 939    for (pattern = b->patterns->first; pattern != NULL; pattern = pattern->next)
 940    {
 941       assert(pattern->str != NULL);
 942
 943       dummy = pcrs_compile_dynamic_command(pattern->str, variables, &error);
 944       if (NULL == dummy)
 945       {
 946          log_error(LOG_LEVEL_ERROR,
 947             "Compiling dynamic pcrs job '%s' for '%s' failed with error code %d: %s",
 948             pattern->str, b->name, error, pcrs_strerror(error));
 949          continue;
 950       }
 951       else
 952       {
 953          if (error == PCRS_WARN_TRUNCATION)
 954          {
 955             log_error(LOG_LEVEL_ERROR,
 956                "At least one of the variables in \'%s\' had to "
 957                "be truncated before compilation", pattern->str);
 958          }
 959          if (job_list == NULL)
 960          {
 961             job_list = dummy;
 962          }
 963          else
 964          {
 965             lastjob->next = dummy;
 966          }
 967          lastjob = dummy;
 968       }
 969    }
 970
 971    return job_list;
 972 }
 973
 974
 975 /*********************************************************************
 976  *
 977  * Function    :  rewrite_url
 978  *
 979  * Description :  Rewrites a URL with a single pcrs command
 980  *                and returns the result if it differs from the
 981  *                original and isn't obviously invalid.
 982  *
 983  * Parameters  :
 984  *          1  :  old_url = URL to rewrite.
 985  *          2  :  pcrs_command = pcrs command formatted as string (s@foo@bar@)
 986  *
 987  *
 988  * Returns     :  NULL if the pcrs_command didn't change the url, or
 989  *                the result of the modification.
 990  *
 991  *********************************************************************/
 992 char *rewrite_url(char *old_url, const char *pcrs_command)
 993 {
 994    char *new_url = NULL;
 995    int hits;
 996
 997    assert(old_url);
 998    assert(pcrs_command);
 999
1000    new_url = pcrs_execute_single_command(old_url, pcrs_command, &hits);
1001
1002    if (hits == 0)
1003    {
1004       log_error(LOG_LEVEL_REDIRECTS,
1005          "pcrs command \"%s\" didn't change \"%s\".",
1006          pcrs_command, old_url);
1007       freez(new_url);
1008    }
1009    else if (hits < 0)
1010    {
1011       log_error(LOG_LEVEL_REDIRECTS,
1012          "executing pcrs command \"%s\" to rewrite %s failed: %s",
1013          pcrs_command, old_url, pcrs_strerror(hits));
1014       freez(new_url);
1015    }
1016    else if (strncmpic(new_url, "http://", 7) && strncmpic(new_url, "https://", 8))
1017    {
1018       log_error(LOG_LEVEL_ERROR,
1019          "pcrs command \"%s\" changed \"%s\" to \"%s\" (%u hi%s), "
1020          "but the result doesn't look like a valid URL and will be ignored.",
1021          pcrs_command, old_url, new_url, hits, (hits == 1) ? "t" : "ts");
1022       freez(new_url);
1023    }
1024    else
1025    {
1026       log_error(LOG_LEVEL_REDIRECTS,
1027          "pcrs command \"%s\" changed \"%s\" to \"%s\" (%u hi%s).",
1028          pcrs_command, old_url, new_url, hits, (hits == 1) ? "t" : "ts");
1029    }
1030
1031    return new_url;
1032
1033 }
1034
1035
1036 #ifdef FEATURE_FAST_REDIRECTS
1037 /*********************************************************************
1038  *
1039  * Function    :  get_last_url
1040  *
1041  * Description :  Search for the last URL inside a string.
1042  *                If the string already is a URL, it will
1043  *                be the first URL found.
1044  *
1045  * Parameters  :
1046  *          1  :  subject = the string to check
1047  *          2  :  redirect_mode = +fast-redirect{} mode
1048  *
1049  * Returns     :  NULL if no URL was found, or
1050  *                the last URL found.
1051  *
1052  *********************************************************************/
1053 char *get_last_url(char *subject, const char *redirect_mode)
1054 {
1055    char *new_url = NULL;
1056    char *tmp;
1057
1058    assert(subject);
1059    assert(redirect_mode);
1060
1061    subject = strdup(subject);
1062    if (subject == NULL)
1063    {
1064       log_error(LOG_LEVEL_ERROR, "Out of memory while searching for redirects.");
1065       return NULL;
1066    }
1067
1068    if (0 == strcmpic(redirect_mode, "check-decoded-url") && strchr(subject, '%'))
1069    {
1070       char *url_segment = NULL;
1071       char **url_segments;
1072       size_t max_segments;
1073       int segments;
1074
1075       log_error(LOG_LEVEL_REDIRECTS,
1076          "Checking \"%s\" for encoded redirects.", subject);
1077
1078       /*
1079        * Check each parameter in the URL separately.
1080        * Sectionize the URL at "?" and "&",
1081        * go backwards through the segments, URL-decode them
1082        * and look for a URL in the decoded result.
1083        * Stop the search after the first match.
1084        *
1085        * XXX: This estimate is guaranteed to be high enough as we
1086        *      let ssplit() ignore empty fields, but also a bit wasteful.
1087        */
1088       max_segments = strlen(subject) / 2;
1089       url_segments = malloc(max_segments * sizeof(char *));
1090
1091       if (NULL == url_segments)
1092       {
1093          log_error(LOG_LEVEL_ERROR,
1094             "Out of memory while decoding URL: %s", subject);
1095          freez(subject);
1096          return NULL;
1097       }
1098
1099       segments = ssplit(subject, "?&", url_segments, max_segments);
1100
1101       while (segments-- > 0)
1102       {
1103          char *dtoken = url_decode(url_segments[segments]);
1104          if (NULL == dtoken)
1105          {
1106             log_error(LOG_LEVEL_ERROR, "Unable to decode \"%s\".", url_segments[segments]);
1107             continue;
1108          }
1109          url_segment = strstr(dtoken, "http://");
1110          if (NULL == url_segment)
1111          {
1112             url_segment = strstr(dtoken, "https://");
1113          }
1114          if (NULL != url_segment)
1115          {
1116             url_segment = strdup_or_die(url_segment);
1117             freez(dtoken);
1118             break;
1119          }
1120          freez(dtoken);
1121       }
1122       freez(subject);
1123       freez(url_segments);
1124
1125       if (url_segment == NULL)
1126       {
1127          return NULL;
1128       }
1129       subject = url_segment;
1130    }
1131    else
1132    {
1133       /* Look for a URL inside this one, without decoding anything. */
1134       log_error(LOG_LEVEL_REDIRECTS,
1135          "Checking \"%s\" for unencoded redirects.", subject);
1136    }
1137
1138    /*
1139     * Find the last URL encoded in the request
1140     */
1141    tmp = subject;
1142    while ((tmp = strstr(tmp, "http://")) != NULL)
1143    {
1144       new_url = tmp++;
1145    }
1146    tmp = (new_url != NULL) ? new_url : subject;
1147    while ((tmp = strstr(tmp, "https://")) != NULL)
1148    {
1149       new_url = tmp++;
1150    }
1151
1152    if ((new_url != NULL)
1153       && (  (new_url != subject)
1154          || (0 == strncmpic(subject, "http://", 7))
1155          || (0 == strncmpic(subject, "https://", 8))
1156          ))
1157    {
1158       /*
1159        * Return new URL if we found a redirect
1160        * or if the subject already was a URL.
1161        *
1162        * The second case makes sure that we can
1163        * chain get_last_url after another redirection check
1164        * (like rewrite_url) without losing earlier redirects.
1165        */
1166       new_url = strdup(new_url);
1167       freez(subject);
1168       return new_url;
1169    }
1170
1171    freez(subject);
1172    return NULL;
1173
1174 }
1175 #endif /* def FEATURE_FAST_REDIRECTS */
1176
1177
1178 /*********************************************************************
1179  *
1180  * Function    :  redirect_url
1181  *
1182  * Description :  Checks if Privoxy should answer the request with
1183  *                a HTTP redirect and generates the redirect if
1184  *                necessary.
1185  *
1186  * Parameters  :
1187  *          1  :  csp = Current client state (buffers, headers, etc...)
1188  *
1189  * Returns     :  NULL if the request can pass, HTTP redirect otherwise.
1190  *
1191  *********************************************************************/
1192 struct http_response *redirect_url(struct client_state *csp)
1193 {
1194    struct http_response *rsp;
1195 #ifdef FEATURE_FAST_REDIRECTS
1196    /*
1197     * XXX: Do we still need FEATURE_FAST_REDIRECTS
1198     * as compile-time option? The user can easily disable
1199     * it in his action file.
1200     */
1201    char * redirect_mode;
1202 #endif /* def FEATURE_FAST_REDIRECTS */
1203    char *old_url = NULL;
1204    char *new_url = NULL;
1205    char *redirection_string;
1206
1207    if ((csp->action->flags & ACTION_REDIRECT))
1208    {
1209       redirection_string = csp->action->string[ACTION_STRING_REDIRECT];
1210
1211       /*
1212        * If the redirection string begins with 's',
1213        * assume it's a pcrs command, otherwise treat it as
1214        * properly formatted URL and use it for the redirection
1215        * directly.
1216        *
1217        * According to (the now obsolete) RFC 2616 section 14.30
1218        * the URL has to be absolute and if the user tries:
1219        * +redirect{sadly/this/will/be/parsed/as/pcrs_command.html}
1220        * she would get undefined results anyway.
1221        *
1222        * RFC 7231 7.1.2 actually allows relative references,
1223        * but those start with a leading slash (RFC 3986 4.2) and
1224        * thus can't be mistaken for pcrs commands either.
1225        */
1226
1227       if (*redirection_string == 's')
1228       {
1229          old_url = csp->http->url;
1230          new_url = rewrite_url(old_url, redirection_string);
1231       }
1232       else
1233       {
1234          log_error(LOG_LEVEL_REDIRECTS,
1235             "No pcrs command recognized, assuming that \"%s\" is already properly formatted.",
1236             redirection_string);
1237          new_url = strdup(redirection_string);
1238       }
1239    }
1240
1241 #ifdef FEATURE_FAST_REDIRECTS
1242    if ((csp->action->flags & ACTION_FAST_REDIRECTS))
1243    {
1244       redirect_mode = csp->action->string[ACTION_STRING_FAST_REDIRECTS];
1245
1246       /*
1247        * If it exists, use the previously rewritten URL as input
1248        * otherwise just use the old path.
1249        */
1250       old_url = (new_url != NULL) ? new_url : strdup(csp->http->path);
1251       new_url = get_last_url(old_url, redirect_mode);
1252       freez(old_url);
1253    }
1254
1255    /*
1256     * Disable redirect checkers, so that they
1257     * will be only run more than once if the user
1258     * also enables them through tags.
1259     *
1260     * From a performance point of view
1261     * it doesn't matter, but the duplicated
1262     * log messages are annoying.
1263     */
1264    csp->action->flags &= ~ACTION_FAST_REDIRECTS;
1265 #endif /* def FEATURE_FAST_REDIRECTS */
1266    csp->action->flags &= ~ACTION_REDIRECT;
1267
1268    /* Did any redirect action trigger? */
1269    if (new_url)
1270    {
1271       if (url_requires_percent_encoding(new_url))
1272       {
1273          char *encoded_url;
1274          log_error(LOG_LEVEL_REDIRECTS, "Percent-encoding redirect URL: %N",
1275             strlen(new_url), new_url);
1276          encoded_url = percent_encode_url(new_url);
1277          freez(new_url);
1278          if (encoded_url == NULL)
1279          {
1280             return cgi_error_memory();
1281          }
1282          new_url = encoded_url;
1283          assert(FALSE == url_requires_percent_encoding(new_url));
1284       }
1285
1286       if (0 == strcmpic(new_url, csp->http->url))
1287       {
1288          log_error(LOG_LEVEL_ERROR,
1289             "New URL \"%s\" and old URL \"%s\" are the same. Redirection loop prevented.",
1290             csp->http->url, new_url);
1291             freez(new_url);
1292       }
1293       else
1294       {
1295          log_error(LOG_LEVEL_REDIRECTS, "New URL is: %s", new_url);
1296
1297          if (NULL == (rsp = alloc_http_response()))
1298          {
1299             freez(new_url);
1300             return cgi_error_memory();
1301          }
1302
1303          rsp->status = strdup_or_die("302 Local Redirect from Privoxy");
1304          if (enlist_unique_header(rsp->headers, "Location", new_url))
1305          {
1306             freez(new_url);
1307             free_http_response(rsp);
1308             return cgi_error_memory();
1309          }
1310          rsp->crunch_reason = REDIRECTED;
1311          freez(new_url);
1312
1313          return finish_http_response(csp, rsp);
1314       }
1315    }
1316
1317    /* Only reached if no redirect is required */
1318    return NULL;
1319
1320 }
1321
1322
1323 #ifdef FEATURE_IMAGE_BLOCKING
1324 /*********************************************************************
1325  *
1326  * Function    :  is_imageurl
1327  *
1328  * Description :  Given a URL, decide whether it should be treated
1329  *                as image URL or not.
1330  *
1331  * Parameters  :
1332  *          1  :  csp = Current client state (buffers, headers, etc...)
1333  *
1334  * Returns     :  True (nonzero) if URL is an image URL, false (0)
1335  *                otherwise
1336  *
1337  *********************************************************************/
1338 int is_imageurl(const struct client_state *csp)
1339 {
1340    return ((csp->action->flags & ACTION_IMAGE) != 0);
1341
1342 }
1343 #endif /* def FEATURE_IMAGE_BLOCKING */
1344
1345
1346 #ifdef FEATURE_TRUST
1347 /*********************************************************************
1348  *
1349  * Function    :  is_untrusted_url
1350  *
1351  * Description :  Should we "distrust" this URL (and block it)?
1352  *
1353  *                Yes if it matches a line in the trustfile, or if the
1354  *                    referrer matches a line starting with "+" in the
1355  *                    trustfile.
1356  *                No  otherwise.
1357  *
1358  * Parameters  :
1359  *          1  :  csp = Current client state (buffers, headers, etc...)
1360  *
1361  * Returns     :  0 => trusted, 1 => untrusted
1362  *
1363  *********************************************************************/
1364 int is_untrusted_url(const struct client_state *csp)
1365 {
1366    struct file_list *fl;
1367    struct block_spec *b;
1368    struct pattern_spec **trusted_url;
1369    struct http_request rhttp[1];
1370    const char * referer;
1371    jb_err err;
1372
1373    /*
1374     * If we don't have a trustlist, we trust everybody
1375     */
1376    if (((fl = csp->tlist) == NULL) || ((b  = fl->f) == NULL))
1377    {
1378       return 0;
1379    }
1380
1381    memset(rhttp, '\0', sizeof(*rhttp));
1382
1383    /*
1384     * Do we trust the request URL itself?
1385     */
1386    for (b = b->next; b ; b = b->next)
1387    {
1388       if (url_match(b->url, csp->http))
1389       {
1390          return b->reject;
1391       }
1392    }
1393
1394    if (NULL == (referer = get_header_value(csp->headers, "Referer:")))
1395    {
1396       /* no referrer was supplied */
1397       return 1;
1398    }
1399
1400
1401    /*
1402     * If not, do we maybe trust its referrer?
1403     */
1404    err = parse_http_url(referer, rhttp, REQUIRE_PROTOCOL);
1405    if (err)
1406    {
1407       return 1;
1408    }
1409
1410    for (trusted_url = csp->config->trust_list; *trusted_url != NULL; trusted_url++)
1411    {
1412       if (url_match(*trusted_url, rhttp))
1413       {
1414          /* if the URL's referrer is from a trusted referrer, then
1415           * add the target spec to the trustfile as an unblocked
1416           * domain and return 0 (which means it's OK).
1417           */
1418
1419          FILE *fp;
1420
1421          if (NULL != (fp = fopen(csp->config->trustfile, "a")))
1422          {
1423             char * path;
1424             char * path_end;
1425             char * new_entry = strdup_or_die("~");
1426
1427             string_append(&new_entry, csp->http->hostport);
1428
1429             path = csp->http->path;
1430             if ( (path[0] == '/')
1431               && (path[1] == '~')
1432               && ((path_end = strchr(path + 2, '/')) != NULL))
1433             {
1434                /* since this path points into a user's home space
1435                 * be sure to include this spec in the trustfile.
1436                 */
1437                long path_len = path_end - path; /* save offset */
1438                path = strdup(path); /* Copy string */
1439                if (path != NULL)
1440                {
1441                   path_end = path + path_len; /* regenerate ptr to new buffer */
1442                   *(path_end + 1) = '\0'; /* Truncate path after '/' */
1443                }
1444                string_join(&new_entry, path);
1445             }
1446
1447             /*
1448              * Give a reason for generating this entry.
1449              */
1450             string_append(&new_entry, " # Trusted referrer was: ");
1451             string_append(&new_entry, referer);
1452
1453             if (new_entry != NULL)
1454             {
1455                if (-1 == fprintf(fp, "%s\n", new_entry))
1456                {
1457                   log_error(LOG_LEVEL_ERROR, "Failed to append \'%s\' to trustfile \'%s\': %E",
1458                      new_entry, csp->config->trustfile);
1459                }
1460                freez(new_entry);
1461             }
1462             else
1463             {
1464                /* FIXME: No way to handle out-of memory, so mostly ignoring it */
1465                log_error(LOG_LEVEL_ERROR, "Out of memory adding pattern to trust file");
1466             }
1467
1468             fclose(fp);
1469          }
1470          else
1471          {
1472             log_error(LOG_LEVEL_ERROR, "Failed to append new entry for \'%s\' to trustfile \'%s\': %E",
1473                csp->http->hostport, csp->config->trustfile);
1474          }
1475          return 0;
1476       }
1477    }
1478
1479    return 1;
1480 }
1481 #endif /* def FEATURE_TRUST */
1482
1483
1484 /*********************************************************************
1485  *
1486  * Function    :  get_filter
1487  *
1488  * Description :  Get a filter with a given name and type.
1489  *                Note that taggers are filters, too.
1490  *
1491  * Parameters  :
1492  *          1  :  csp = Current client state (buffers, headers, etc...)
1493  *          2  :  requested_name = Name of the content filter to get
1494  *          3  :  requested_type = Type of the filter to tagger to lookup
1495  *
1496  * Returns     :  A pointer to the requested filter
1497  *                or NULL if the filter wasn't found
1498  *
1499  *********************************************************************/
1500 struct re_filterfile_spec *get_filter(const struct client_state *csp,
1501                                       const char *requested_name,
1502                                       enum filter_type requested_type)
1503 {
1504    int i;
1505    struct re_filterfile_spec *b;
1506    struct file_list *fl;
1507
1508    for (i = 0; i < MAX_AF_FILES; i++)
1509    {
1510      fl = csp->rlist[i];
1511      if ((NULL == fl) || (NULL == fl->f))
1512      {
1513         /*
1514          * Either there are no filter files left or this
1515          * filter file just contains no valid filters.
1516          *
1517          * Continue to be sure we don't miss valid filter
1518          * files that are chained after empty or invalid ones.
1519          */
1520         continue;
1521      }
1522
1523      for (b = fl->f; b != NULL; b = b->next)
1524      {
1525         if (b->type != requested_type)
1526         {
1527            /* The callers isn't interested in this filter type. */
1528            continue;
1529         }
1530         if (strcmp(b->name, requested_name) == 0)
1531         {
1532            /* The requested filter has been found. Abort search. */
1533            return b;
1534         }
1535      }
1536    }
1537
1538    /* No filter with the given name and type exists. */
1539    return NULL;
1540
1541 }
1542
1543
1544 /*********************************************************************
1545  *
1546  * Function    :  pcrs_filter_response
1547  *
1548  * Description :  Execute all text substitutions from all applying
1549  *                +filter actions on the text buffer that's been
1550  *                accumulated in csp->iob->buf.
1551  *
1552  * Parameters  :
1553  *          1  :  csp = Current client state (buffers, headers, etc...)
1554  *
1555  * Returns     :  a pointer to the (newly allocated) modified buffer.
1556  *                or NULL if there were no hits or something went wrong
1557  *
1558  *********************************************************************/
1559 static char *pcrs_filter_response(struct client_state *csp)
1560 {
1561    int hits = 0;
1562    size_t size, prev_size;
1563
1564    char *old = NULL;
1565    char *new = NULL;
1566    pcrs_job *job;
1567
1568    struct re_filterfile_spec *b;
1569    struct list_entry *filtername;
1570
1571    /*
1572     * Sanity first
1573     */
1574    if (csp->iob->cur >= csp->iob->eod)
1575    {
1576       return(NULL);
1577    }
1578
1579    if (filters_available(csp) == FALSE)
1580    {
1581       log_error(LOG_LEVEL_ERROR, "Inconsistent configuration: "
1582          "content filtering enabled, but no content filters available.");
1583       return(NULL);
1584    }
1585
1586    size = (size_t)(csp->iob->eod - csp->iob->cur);
1587    old = csp->iob->cur;
1588
1589    /*
1590     * For all applying +filter actions, look if a filter by that
1591     * name exists and if yes, execute it's pcrs_joblist on the
1592     * buffer.
1593     */
1594    for (filtername = csp->action->multi[ACTION_MULTI_FILTER]->first;
1595         filtername != NULL; filtername = filtername->next)
1596    {
1597       int current_hits = 0; /* Number of hits caused by this filter */
1598       int job_number   = 0; /* Which job we're currently executing  */
1599       int job_hits     = 0; /* How many hits the current job caused */
1600       pcrs_job *joblist;
1601
1602       b = get_filter(csp, filtername->str, FT_CONTENT_FILTER);
1603       if (b == NULL)
1604       {
1605          continue;
1606       }
1607
1608       joblist = b->joblist;
1609
1610       if (b->dynamic) joblist = compile_dynamic_pcrs_job_list(csp, b);
1611
1612       if (NULL == joblist)
1613       {
1614          log_error(LOG_LEVEL_RE_FILTER, "Filter %s has empty joblist. Nothing to do.", b->name);
1615          continue;
1616       }
1617
1618       prev_size = size;
1619       /* Apply all jobs from the joblist */
1620       for (job = joblist; NULL != job; job = job->next)
1621       {
1622          job_number++;
1623          job_hits = pcrs_execute(job, old, size, &new, &size);
1624
1625          if (job_hits >= 0)
1626          {
1627             /*
1628              * That went well. Continue filtering
1629              * and use the result of this job as
1630              * input for the next one.
1631              */
1632             current_hits += job_hits;
1633             if (old != csp->iob->cur)
1634             {
1635                freez(old);
1636             }
1637             old = new;
1638          }
1639          else
1640          {
1641             /*
1642              * This job caused an unexpected error. Inform the user
1643              * and skip the rest of the jobs in this filter. We could
1644              * continue with the next job, but usually the jobs
1645              * depend on each other or are similar enough to
1646              * fail for the same reason.
1647              *
1648              * At the moment our pcrs expects the error codes of pcre 3.4,
1649              * but newer pcre versions can return additional error codes.
1650              * As a result pcrs_strerror()'s error message might be
1651              * "Unknown error ...", therefore we print the numerical value
1652              * as well.
1653              *
1654              * XXX: Is this important enough for LOG_LEVEL_ERROR or
1655              * should we use LOG_LEVEL_RE_FILTER instead?
1656              */
1657             log_error(LOG_LEVEL_ERROR, "Skipped filter \'%s\' after job number %u: %s (%d)",
1658                b->name, job_number, pcrs_strerror(job_hits), job_hits);
1659             break;
1660          }
1661       }
1662
1663       if (b->dynamic) pcrs_free_joblist(joblist);
1664
1665       log_error(LOG_LEVEL_RE_FILTER,
1666          "filtering %s%s (size %d) with \'%s\' produced %d hits (new size %d).",
1667          csp->http->hostport, csp->http->path, prev_size, b->name, current_hits, size);
1668
1669       hits += current_hits;
1670    }
1671
1672    /*
1673     * If there were no hits, destroy our copy and let
1674     * chat() use the original in csp->iob
1675     */
1676    if (!hits)
1677    {
1678       freez(new);
1679       return(NULL);
1680    }
1681
1682    csp->flags |= CSP_FLAG_MODIFIED;
1683    csp->content_length = size;
1684    clear_iob(csp->iob);
1685
1686    return(new);
1687
1688 }
1689
1690
1691 #ifdef FEATURE_EXTERNAL_FILTERS
1692 /*********************************************************************
1693  *
1694  * Function    :  get_external_filter
1695  *
1696  * Description :  Lookup the code to execute for an external filter.
1697  *                Masks the misuse of the re_filterfile_spec.
1698  *
1699  * Parameters  :
1700  *          1  :  csp = Current client state (buffers, headers, etc...)
1701  *          2  :  name = Name of the content filter to get
1702  *
1703  * Returns     :  A pointer to the requested code
1704  *                or NULL if the filter wasn't found
1705  *
1706  *********************************************************************/
1707 static const char *get_external_filter(const struct client_state *csp,
1708                                 const char *name)
1709 {
1710    struct re_filterfile_spec *external_filter;
1711
1712    external_filter = get_filter(csp, name, FT_EXTERNAL_CONTENT_FILTER);
1713    if (external_filter == NULL)
1714    {
1715       log_error(LOG_LEVEL_FATAL,
1716          "Didn't find stuff to execute for external filter: %s",
1717          name);
1718    }
1719
1720    return external_filter->patterns->first->str;
1721
1722 }
1723
1724
1725 /*********************************************************************
1726  *
1727  * Function    :  set_privoxy_variables
1728  *
1729  * Description :  Sets a couple of privoxy-specific environment variables
1730  *
1731  * Parameters  :
1732  *          1  :  csp = Current client state (buffers, headers, etc...)
1733  *
1734  * Returns     :  N/A
1735  *
1736  *********************************************************************/
1737 static void set_privoxy_variables(const struct client_state *csp)
1738 {
1739    int i;
1740    struct {
1741       const char *name;
1742       const char *value;
1743    } env[] = {
1744       { "PRIVOXY_URL",    csp->http->url   },
1745       { "PRIVOXY_PATH",   csp->http->path  },
1746       { "PRIVOXY_HOST",   csp->http->host  },
1747       { "PRIVOXY_ORIGIN", csp->ip_addr_str },
1748       { "PRIVOXY_LISTEN_ADDRESS", csp->listen_addr_str },
1749    };
1750
1751    for (i = 0; i < SZ(env); i++)
1752    {
1753       if (setenv(env[i].name, env[i].value, 1))
1754       {
1755          log_error(LOG_LEVEL_ERROR, "Failed to set %s=%s: %E",
1756             env[i].name, env[i].value);
1757       }
1758    }
1759 }
1760
1761
1762 /*********************************************************************
1763  *
1764  * Function    :  execute_external_filter
1765  *
1766  * Description :  Pipe content into external filter and return the output
1767  *
1768  * Parameters  :
1769  *          1  :  csp = Current client state (buffers, headers, etc...)
1770  *          2  :  name = Name of the external filter to execute
1771  *          3  :  content = The original content to filter
1772  *          4  :  size = The size of the content buffer
1773  *
1774  * Returns     :  a pointer to the (newly allocated) modified buffer.
1775  *                or NULL if there were no hits or something went wrong
1776  *
1777  *********************************************************************/
1778 static char *execute_external_filter(const struct client_state *csp,
1779    const char *name, char *content, size_t *size)
1780 {
1781    char cmd[200];
1782    char file_name[FILENAME_MAX];
1783    FILE *fp;
1784    char *filter_output;
1785    int fd;
1786    int ret;
1787    size_t new_size;
1788    const char *external_filter;
1789
1790    if (csp->config->temporary_directory == NULL)
1791    {
1792       log_error(LOG_LEVEL_ERROR,
1793          "No temporary-directory configured. Can't execute filter: %s",
1794          name);
1795       return NULL;
1796    }
1797
1798    external_filter = get_external_filter(csp, name);
1799
1800    if (sizeof(file_name) < snprintf(file_name, sizeof(file_name),
1801          "%s/privoxy-XXXXXXXX", csp->config->temporary_directory))
1802    {
1803       log_error(LOG_LEVEL_ERROR, "temporary-directory path too long");
1804       return NULL;
1805    }
1806
1807    fd = mkstemp(file_name);
1808    if (fd == -1)
1809    {
1810       log_error(LOG_LEVEL_ERROR, "mkstemp() failed to create %s: %E", file_name);
1811       return NULL;
1812    }
1813
1814    fp = fdopen(fd, "w");
1815    if (fp == NULL)
1816    {
1817       log_error(LOG_LEVEL_ERROR, "fdopen() failed: %E");
1818       unlink(file_name);
1819       return NULL;
1820    }
1821
1822    /*
1823     * The size may be zero if a previous filter discarded everything.
1824     *
1825     * This isn't necessary unintentional, so we just don't try
1826     * to fwrite() nothing and let the user deal with the rest.
1827     */
1828    if ((*size != 0) && fwrite(content, *size, 1, fp) != 1)
1829    {
1830       log_error(LOG_LEVEL_ERROR, "fwrite(..., %d, 1, ..) failed: %E", *size);
1831       unlink(file_name);
1832       fclose(fp);
1833       return NULL;
1834    }
1835    fclose(fp);
1836
1837    if (sizeof(cmd) < snprintf(cmd, sizeof(cmd), "%s < %s", external_filter, file_name))
1838    {
1839       log_error(LOG_LEVEL_ERROR,
1840          "temporary-directory or external filter path too long");
1841       unlink(file_name);
1842       return NULL;
1843    }
1844
1845    log_error(LOG_LEVEL_RE_FILTER, "Executing '%s': %s", name, cmd);
1846
1847    /*
1848     * The locking is necessary to prevent other threads
1849     * from overwriting the environment variables before
1850     * the popen fork. Afterwards this no longer matters.
1851     */
1852    privoxy_mutex_lock(&external_filter_mutex);
1853    set_privoxy_variables(csp);
1854    fp = popen(cmd, "r");
1855    privoxy_mutex_unlock(&external_filter_mutex);
1856    if (fp == NULL)
1857    {
1858       log_error(LOG_LEVEL_ERROR, "popen(\"%s\", \"r\") failed: %E", cmd);
1859       unlink(file_name);
1860       return NULL;
1861    }
1862
1863    /* Allocate at least one byte */
1864    filter_output = malloc_or_die(*size + 1);
1865
1866    new_size = 0;
1867    while (!feof(fp) && !ferror(fp))
1868    {
1869       size_t len;
1870       /* Could be bigger ... */
1871       enum { READ_LENGTH = 2048 };
1872
1873       if (new_size + READ_LENGTH >= *size)
1874       {
1875          char *p;
1876
1877          /* Could be considered wasteful if the content is 'large'. */
1878          *size += (*size >= READ_LENGTH) ? *size : READ_LENGTH;
1879
1880          p = realloc(filter_output, *size);
1881          if (p == NULL)
1882          {
1883             log_error(LOG_LEVEL_ERROR, "Out of memory while reading "
1884                "external filter output. Using what we got so far.");
1885             break;
1886          }
1887          filter_output = p;
1888       }
1889       assert(new_size + READ_LENGTH < *size);
1890       len = fread(&filter_output[new_size], 1, READ_LENGTH, fp);
1891       if (len > 0)
1892       {
1893          new_size += len;
1894       }
1895    }
1896
1897    ret = pclose(fp);
1898    if (ret == -1)
1899    {
1900       log_error(LOG_LEVEL_ERROR, "Executing %s failed: %E", cmd);
1901    }
1902    else
1903    {
1904       log_error(LOG_LEVEL_RE_FILTER,
1905          "Executing '%s' resulted in return value %d. "
1906          "Read %d of up to %d bytes.", name, (ret >> 8), new_size, *size);
1907    }
1908
1909    unlink(file_name);
1910    *size = new_size;
1911
1912    return filter_output;
1913
1914 }
1915 #endif /* def FEATURE_EXTERNAL_FILTERS */
1916
1917
1918 /*********************************************************************
1919  *
1920  * Function    :  gif_deanimate_response
1921  *
1922  * Description :  Deanimate the GIF image that has been accumulated in
1923  *                csp->iob->buf, set csp->content_length to the modified
1924  *                size and raise the CSP_FLAG_MODIFIED flag.
1925  *
1926  * Parameters  :
1927  *          1  :  csp = Current client state (buffers, headers, etc...)
1928  *
1929  * Returns     :  a pointer to the (newly allocated) modified buffer.
1930  *                or NULL in case something went wrong.
1931  *
1932  *********************************************************************/
1933 #ifdef FUZZ
1934 char *gif_deanimate_response(struct client_state *csp)
1935 #else
1936 static char *gif_deanimate_response(struct client_state *csp)
1937 #endif
1938 {
1939    struct binbuffer *in, *out;
1940    char *p;
1941    size_t size;
1942
1943    size = (size_t)(csp->iob->eod - csp->iob->cur);
1944
1945    in =  zalloc_or_die(sizeof(*in));
1946    out = zalloc_or_die(sizeof(*out));
1947
1948    in->buffer = csp->iob->cur;
1949    in->size = size;
1950
1951    if (gif_deanimate(in, out, strncmp("last", csp->action->string[ACTION_STRING_DEANIMATE], 4)))
1952    {
1953       log_error(LOG_LEVEL_DEANIMATE, "failed! (gif parsing)");
1954       freez(in);
1955       buf_free(out);
1956       return(NULL);
1957    }
1958    else
1959    {
1960       if ((int)size == out->offset)
1961       {
1962          log_error(LOG_LEVEL_DEANIMATE, "GIF not changed.");
1963       }
1964       else
1965       {
1966          log_error(LOG_LEVEL_DEANIMATE, "Success! GIF shrunk from %d bytes to %d.", size, out->offset);
1967       }
1968       csp->content_length = out->offset;
1969       csp->flags |= CSP_FLAG_MODIFIED;
1970       p = out->buffer;
1971       freez(in);
1972       freez(out);
1973       return(p);
1974    }
1975
1976 }
1977
1978
1979 /*********************************************************************
1980  *
1981  * Function    :  get_filter_function
1982  *
1983  * Description :  Decides which content filter function has
1984  *                to be applied (if any). Only considers functions
1985  *                for internal filters which are mutually-exclusive.
1986  *
1987  * Parameters  :
1988  *          1  :  csp = Current client state (buffers, headers, etc...)
1989  *
1990  * Returns     :  The content filter function to run, or
1991  *                NULL if no content filter is active
1992  *
1993  *********************************************************************/
1994 static filter_function_ptr get_filter_function(const struct client_state *csp)
1995 {
1996    filter_function_ptr filter_function = NULL;
1997
1998    /*
1999     * Choose the applying filter function based on
2000     * the content type and action settings.
2001     */
2002    if ((csp->content_type & CT_TEXT) &&
2003        (!list_is_empty(csp->action->multi[ACTION_MULTI_FILTER])))
2004    {
2005       filter_function = pcrs_filter_response;
2006    }
2007    else if ((csp->content_type & CT_GIF) &&
2008             (csp->action->flags & ACTION_DEANIMATE))
2009    {
2010       filter_function = gif_deanimate_response;
2011    }
2012
2013    return filter_function;
2014 }
2015
2016
2017 /*********************************************************************
2018  *
2019  * Function    :  remove_chunked_transfer_coding
2020  *
2021  * Description :  In-situ remove the "chunked" transfer coding as defined
2022  *                in RFC 7230 4.1 from a buffer. XXX: The implementation
2023  *                is neither complete nor compliant (TODO #129).
2024  *
2025  * Parameters  :
2026  *          1  :  buffer = Pointer to the text buffer
2027  *          2  :  size =  In: Number of bytes to be processed,
2028  *                       Out: Number of bytes after de-chunking.
2029  *                       (undefined in case of errors)
2030  *
2031  * Returns     :  JB_ERR_OK for success,
2032  *                JB_ERR_PARSE otherwise
2033  *
2034  *********************************************************************/
2035 #ifdef FUZZ
2036 extern jb_err remove_chunked_transfer_coding(char *buffer, size_t *size)
2037 #else
2038 static jb_err remove_chunked_transfer_coding(char *buffer, size_t *size)
2039 #endif
2040 {
2041    size_t newsize = 0;
2042    unsigned int chunksize = 0;
2043    char *from_p, *to_p;
2044    const char *end_of_buffer = buffer + *size;
2045
2046    if (*size == 0)
2047    {
2048       log_error(LOG_LEVEL_FATAL, "Invalid chunked input. Buffer is empty.");
2049       return JB_ERR_PARSE;
2050    }
2051
2052    assert(buffer);
2053    from_p = to_p = buffer;
2054
2055    if (sscanf(buffer, "%x", &chunksize) != 1)
2056    {
2057       log_error(LOG_LEVEL_ERROR, "Invalid first chunksize while stripping \"chunked\" transfer coding");
2058       return JB_ERR_PARSE;
2059    }
2060
2061    while (chunksize > 0U)
2062    {
2063       /*
2064        * If the chunk-size is valid, we should have at least
2065        * chunk-size bytes of chunk-data and five bytes of
2066        * meta data (chunk-size, CRLF, CRLF) left in the buffer.
2067        */
2068       if (chunksize + 5 >= *size - newsize)
2069       {
2070          log_error(LOG_LEVEL_ERROR,
2071             "Chunk size %u exceeds buffered data left. "
2072             "Already digested %u of %u buffered bytes.",
2073             chunksize, (unsigned int)newsize, (unsigned int)*size);
2074          return JB_ERR_PARSE;
2075       }
2076
2077       /*
2078        * Skip the chunk-size, the optional chunk-ext and the CRLF
2079        * that is supposed to be located directly before the start
2080        * of chunk-data.
2081        */
2082       if (NULL == (from_p = strstr(from_p, "\r\n")))
2083       {
2084          log_error(LOG_LEVEL_ERROR, "Parse error while stripping \"chunked\" transfer coding");
2085          return JB_ERR_PARSE;
2086       }
2087       from_p += 2;
2088
2089       /*
2090        * The previous strstr() does not enforce chunk-validity
2091        * and is sattisfied as long a CRLF is left in the buffer.
2092        *
2093        * Make sure the bytes we consider chunk-data are within
2094        * the valid range.
2095        */
2096       if (from_p + chunksize >= end_of_buffer)
2097       {
2098          log_error(LOG_LEVEL_ERROR,
2099             "End of chunk is beyond the end of the buffer.");
2100          return JB_ERR_PARSE;
2101       }
2102
2103       memmove(to_p, from_p, (size_t) chunksize);
2104       newsize += chunksize;
2105       to_p = buffer + newsize;
2106       from_p += chunksize;
2107
2108       /*
2109        * Not merging this check with the previous one allows us
2110        * to keep chunks without trailing CRLF. It's not clear
2111        * if we actually have to care about those, though.
2112        */
2113       if (from_p + 2 >= end_of_buffer)
2114       {
2115          log_error(LOG_LEVEL_ERROR, "Not enough room for trailing CRLF.");
2116          return JB_ERR_PARSE;
2117       }
2118       from_p += 2;
2119       if (sscanf(from_p, "%x", &chunksize) != 1)
2120       {
2121          log_error(LOG_LEVEL_INFO, "Invalid \"chunked\" transfer encoding detected and ignored.");
2122          break;
2123       }
2124    }
2125
2126    /* XXX: Should get its own loglevel. */
2127    log_error(LOG_LEVEL_RE_FILTER, "De-chunking successful. Shrunk from %d to %d", *size, newsize);
2128
2129    *size = newsize;
2130
2131    return JB_ERR_OK;
2132
2133 }
2134
2135
2136 /*********************************************************************
2137  *
2138  * Function    :  prepare_for_filtering
2139  *
2140  * Description :  If necessary, de-chunks and decompresses
2141  *                the content so it can get filterd.
2142  *
2143  * Parameters  :
2144  *          1  :  csp = Current client state (buffers, headers, etc...)
2145  *
2146  * Returns     :  JB_ERR_OK for success,
2147  *                JB_ERR_PARSE otherwise
2148  *
2149  *********************************************************************/
2150 static jb_err prepare_for_filtering(struct client_state *csp)
2151 {
2152    jb_err err = JB_ERR_OK;
2153
2154    /*
2155     * If the body has a "chunked" transfer-encoding,
2156     * get rid of it, adjusting size and iob->eod
2157     */
2158    if (csp->flags & CSP_FLAG_CHUNKED)
2159    {
2160       size_t size = (size_t)(csp->iob->eod - csp->iob->cur);
2161
2162       log_error(LOG_LEVEL_RE_FILTER, "Need to de-chunk first");
2163       err = remove_chunked_transfer_coding(csp->iob->cur, &size);
2164       if (JB_ERR_OK == err)
2165       {
2166          csp->iob->eod = csp->iob->cur + size;
2167          csp->flags |= CSP_FLAG_MODIFIED;
2168       }
2169       else
2170       {
2171          return JB_ERR_PARSE;
2172       }
2173    }
2174
2175 #ifdef FEATURE_ZLIB
2176    /*
2177     * If the body has a supported transfer-encoding,
2178     * decompress it, adjusting size and iob->eod.
2179     */
2180    if (csp->content_type & (CT_GZIP|CT_DEFLATE))
2181    {
2182       if (0 == csp->iob->eod - csp->iob->cur)
2183       {
2184          /* Nothing left after de-chunking. */
2185          return JB_ERR_OK;
2186       }
2187
2188       err = decompress_iob(csp);
2189
2190       if (JB_ERR_OK == err)
2191       {
2192          csp->flags |= CSP_FLAG_MODIFIED;
2193          csp->content_type &= ~CT_TABOO;
2194       }
2195       else
2196       {
2197          /*
2198           * Unset CT_GZIP and CT_DEFLATE to remember not
2199           * to modify the Content-Encoding header later.
2200           */
2201          csp->content_type &= ~CT_GZIP;
2202          csp->content_type &= ~CT_DEFLATE;
2203       }
2204    }
2205 #endif
2206
2207    return err;
2208 }
2209
2210
2211 /*********************************************************************
2212  *
2213  * Function    :  execute_content_filters
2214  *
2215  * Description :  Executes a given content filter.
2216  *
2217  * Parameters  :
2218  *          1  :  csp = Current client state (buffers, headers, etc...)
2219  *
2220  * Returns     :  Pointer to the modified buffer, or
2221  *                NULL if filtering failed or wasn't necessary.
2222  *
2223  *********************************************************************/
2224 char *execute_content_filters(struct client_state *csp)
2225 {
2226    char *content;
2227    filter_function_ptr content_filter;
2228
2229    assert(content_filters_enabled(csp->action));
2230
2231    if (0 == csp->iob->eod - csp->iob->cur)
2232    {
2233       /*
2234        * No content (probably status code 301, 302 ...),
2235        * no filtering necessary.
2236        */
2237       return NULL;
2238    }
2239
2240    if (JB_ERR_OK != prepare_for_filtering(csp))
2241    {
2242       /*
2243        * failed to de-chunk or decompress.
2244        */
2245       return NULL;
2246    }
2247
2248    if (0 == csp->iob->eod - csp->iob->cur)
2249    {
2250       /*
2251        * Clown alarm: chunked and/or compressed nothing delivered.
2252        */
2253       return NULL;
2254    }
2255
2256    content_filter = get_filter_function(csp);
2257    content = (content_filter != NULL) ? (*content_filter)(csp) : NULL;
2258
2259 #ifdef FEATURE_EXTERNAL_FILTERS
2260    if ((csp->content_type & CT_TEXT) &&
2261        !list_is_empty(csp->action->multi[ACTION_MULTI_EXTERNAL_FILTER]))
2262    {
2263       struct list_entry *filtername;
2264       size_t size = (size_t)csp->content_length;
2265
2266       if (content == NULL)
2267       {
2268          content = csp->iob->cur;
2269          size = (size_t)(csp->iob->eod - csp->iob->cur);
2270       }
2271
2272       for (filtername = csp->action->multi[ACTION_MULTI_EXTERNAL_FILTER]->first;
2273            filtername ; filtername = filtername->next)
2274       {
2275          char *result = execute_external_filter(csp, filtername->str, content, &size);
2276          if (result != NULL)
2277          {
2278             if (content != csp->iob->cur)
2279             {
2280                free(content);
2281             }
2282             content = result;
2283          }
2284       }
2285       csp->flags |= CSP_FLAG_MODIFIED;
2286       csp->content_length = size;
2287    }
2288 #endif /* def FEATURE_EXTERNAL_FILTERS */
2289
2290    return content;
2291
2292 }
2293
2294
2295 /*********************************************************************
2296  *
2297  * Function    :  get_url_actions
2298  *
2299  * Description :  Gets the actions for this URL.
2300  *
2301  * Parameters  :
2302  *          1  :  csp = Current client state (buffers, headers, etc...)
2303  *          2  :  http = http_request request for blocked URLs
2304  *
2305  * Returns     :  N/A
2306  *
2307  *********************************************************************/
2308 void get_url_actions(struct client_state *csp, struct http_request *http)
2309 {
2310    struct file_list *fl;
2311    struct url_actions *b;
2312    int i;
2313
2314    init_current_action(csp->action);
2315
2316    for (i = 0; i < MAX_AF_FILES; i++)
2317    {
2318       if (((fl = csp->actions_list[i]) == NULL) || ((b = fl->f) == NULL))
2319       {
2320          return;
2321       }
2322
2323 #ifdef FEATURE_CLIENT_TAGS
2324       apply_url_actions(csp->action, http, csp->client_tags, b);
2325 #else
2326       apply_url_actions(csp->action, http, b);
2327 #endif
2328    }
2329
2330    return;
2331 }
2332
2333 /*********************************************************************
2334  *
2335  * Function    :  apply_url_actions
2336  *
2337  * Description :  Applies a list of URL actions.
2338  *
2339  * Parameters  :
2340  *          1  :  action = Destination.
2341  *          2  :  http = Current URL
2342  *          3  :  client_tags = list of client tags
2343  *          4  :  b = list of URL actions to apply
2344  *
2345  * Returns     :  N/A
2346  *
2347  *********************************************************************/
2348 static void apply_url_actions(struct current_action_spec *action,
2349                               struct http_request *http,
2350 #ifdef FEATURE_CLIENT_TAGS
2351                               const struct list *client_tags,
2352 #endif
2353                               struct url_actions *b)
2354 {
2355    if (b == NULL)
2356    {
2357       /* Should never happen */
2358       return;
2359    }
2360
2361    for (b = b->next; NULL != b; b = b->next)
2362    {
2363       if (url_match(b->url, http))
2364       {
2365          merge_current_action(action, b->action);
2366       }
2367 #ifdef FEATURE_CLIENT_TAGS
2368       if (client_tag_match(b->url, client_tags))
2369       {
2370          merge_current_action(action, b->action);
2371       }
2372 #endif
2373    }
2374 }
2375
2376
2377 /*********************************************************************
2378  *
2379  * Function    :  get_forward_override_settings
2380  *
2381  * Description :  Returns forward settings as specified with the
2382  *                forward-override{} action. forward-override accepts
2383  *                forward lines similar to the one used in the
2384  *                configuration file, but without the URL pattern.
2385  *
2386  *                For example:
2387  *
2388  *                   forward / .
2389  *
2390  *                in the configuration file can be replaced with
2391  *                the action section:
2392  *
2393  *                 {+forward-override{forward .}}
2394  *                 /
2395  *
2396  * Parameters  :
2397  *          1  :  csp = Current client state (buffers, headers, etc...)
2398  *
2399  * Returns     :  Pointer to forwarding structure in case of success.
2400  *                Invalid syntax is fatal.
2401  *
2402  *********************************************************************/
2403 static const struct forward_spec *get_forward_override_settings(struct client_state *csp)
2404 {
2405    const char *forward_override_line = csp->action->string[ACTION_STRING_FORWARD_OVERRIDE];
2406    char forward_settings[BUFFER_SIZE];
2407    char *http_parent = NULL;
2408    /* variable names were chosen for consistency reasons. */
2409    struct forward_spec *fwd = NULL;
2410    int vec_count;
2411    char *vec[3];
2412
2413    assert(csp->action->flags & ACTION_FORWARD_OVERRIDE);
2414    /* Should be enforced by load_one_actions_file() */
2415    assert(strlen(forward_override_line) < sizeof(forward_settings) - 1);
2416
2417    /* Create a copy ssplit can modify */
2418    strlcpy(forward_settings, forward_override_line, sizeof(forward_settings));
2419
2420    if (NULL != csp->fwd)
2421    {
2422       /*
2423        * XXX: Currently necessary to prevent memory
2424        * leaks when the show-url-info cgi page is visited.
2425        */
2426       unload_forward_spec(csp->fwd);
2427    }
2428
2429    /*
2430     * allocate a new forward node, valid only for
2431     * the lifetime of this request. Save its location
2432     * in csp as well, so sweep() can free it later on.
2433     */
2434    fwd = csp->fwd = zalloc_or_die(sizeof(*fwd));
2435
2436    vec_count = ssplit(forward_settings, " \t", vec, SZ(vec));
2437    if ((vec_count == 2) && !strcasecmp(vec[0], "forward"))
2438    {
2439       fwd->type = SOCKS_NONE;
2440
2441       /* Parse the parent HTTP proxy host:port */
2442       http_parent = vec[1];
2443
2444    }
2445    else if ((vec_count == 2) && !strcasecmp(vec[0], "forward-webserver"))
2446    {
2447       fwd->type = FORWARD_WEBSERVER;
2448
2449       /* Parse the parent HTTP server host:port */
2450       http_parent = vec[1];
2451
2452    }
2453    else if (vec_count == 3)
2454    {
2455       char *socks_proxy = NULL;
2456
2457       if  (!strcasecmp(vec[0], "forward-socks4"))
2458       {
2459          fwd->type = SOCKS_4;
2460          socks_proxy = vec[1];
2461       }
2462       else if (!strcasecmp(vec[0], "forward-socks4a"))
2463       {
2464          fwd->type = SOCKS_4A;
2465          socks_proxy = vec[1];
2466       }
2467       else if (!strcasecmp(vec[0], "forward-socks5"))
2468       {
2469          fwd->type = SOCKS_5;
2470          socks_proxy = vec[1];
2471       }
2472       else if (!strcasecmp(vec[0], "forward-socks5t"))
2473       {
2474          fwd->type = SOCKS_5T;
2475          socks_proxy = vec[1];
2476       }
2477
2478       if (NULL != socks_proxy)
2479       {
2480          /* Parse the SOCKS proxy host[:port] */
2481          fwd->gateway_port = 1080;
2482          parse_forwarder_address(socks_proxy,
2483             &fwd->gateway_host, &fwd->gateway_port);
2484
2485          http_parent = vec[2];
2486       }
2487    }
2488
2489    if (NULL == http_parent)
2490    {
2491       log_error(LOG_LEVEL_FATAL,
2492          "Invalid forward-override syntax in: %s", forward_override_line);
2493       /* Never get here - LOG_LEVEL_FATAL causes program exit */
2494    }
2495
2496    /* Parse http forwarding settings */
2497    if (strcmp(http_parent, ".") != 0)
2498    {
2499       fwd->forward_port = 8000;
2500       parse_forwarder_address(http_parent,
2501          &fwd->forward_host, &fwd->forward_port);
2502    }
2503
2504    assert (NULL != fwd);
2505
2506    log_error(LOG_LEVEL_CONNECT,
2507       "Overriding forwarding settings based on \'%s\'", forward_override_line);
2508
2509    return fwd;
2510 }
2511
2512
2513 /*********************************************************************
2514  *
2515  * Function    :  forward_url
2516  *
2517  * Description :  Should we forward this to another proxy?
2518  *
2519  * Parameters  :
2520  *          1  :  csp = Current client state (buffers, headers, etc...)
2521  *          2  :  http = http_request request for current URL
2522  *
2523  * Returns     :  Pointer to forwarding information.
2524  *
2525  *********************************************************************/
2526 const struct forward_spec *forward_url(struct client_state *csp,
2527                                        const struct http_request *http)
2528 {
2529    static const struct forward_spec fwd_default[1]; /* Zero'ed due to being static. */
2530    struct forward_spec *fwd = csp->config->forward;
2531
2532    if (csp->action->flags & ACTION_FORWARD_OVERRIDE)
2533    {
2534       return get_forward_override_settings(csp);
2535    }
2536
2537    if (fwd == NULL)
2538    {
2539       return fwd_default;
2540    }
2541
2542    while (fwd != NULL)
2543    {
2544       if (url_match(fwd->url, http))
2545       {
2546          return fwd;
2547       }
2548       fwd = fwd->next;
2549    }
2550
2551    return fwd_default;
2552 }
2553
2554
2555 /*********************************************************************
2556  *
2557  * Function    :  direct_response
2558  *
2559  * Description :  Check if Max-Forwards == 0 for an OPTIONS or TRACE
2560  *                request and if so, return a HTTP 501 to the client.
2561  *
2562  *                FIXME: I have a stupid name and I should handle the
2563  *                requests properly. Still, what we do here is rfc-
2564  *                compliant, whereas ignoring or forwarding are not.
2565  *
2566  * Parameters  :
2567  *          1  :  csp = Current client state (buffers, headers, etc...)
2568  *
2569  * Returns     :  http_response if , NULL if nonmatch or handler fail
2570  *
2571  *********************************************************************/
2572 struct http_response *direct_response(struct client_state *csp)
2573 {
2574    struct http_response *rsp;
2575    struct list_entry *p;
2576
2577    if ((0 == strcmpic(csp->http->gpc, "trace"))
2578       || (0 == strcmpic(csp->http->gpc, "options")))
2579    {
2580       for (p = csp->headers->first; (p != NULL) ; p = p->next)
2581       {
2582          if (!strncmpic(p->str, "Max-Forwards:", 13))
2583          {
2584             unsigned int max_forwards;
2585
2586             /*
2587              * If it's a Max-Forwards value of zero,
2588              * we have to intercept the request.
2589              */
2590             if (1 == sscanf(p->str+12, ": %u", &max_forwards) && max_forwards == 0)
2591             {
2592                /*
2593                 * FIXME: We could handle at least TRACE here,
2594                 * but that would require a verbatim copy of
2595                 * the request which we don't have anymore
2596                 */
2597                 log_error(LOG_LEVEL_HEADER,
2598                   "Detected header \'%s\' in OPTIONS or TRACE request. Returning 501.",
2599                   p->str);
2600
2601                /* Get mem for response or fail*/
2602                if (NULL == (rsp = alloc_http_response()))
2603                {
2604                   return cgi_error_memory();
2605                }
2606
2607                rsp->status = strdup_or_die("501 Not Implemented");
2608                rsp->is_static = 1;
2609                rsp->crunch_reason = UNSUPPORTED;
2610
2611                return(finish_http_response(csp, rsp));
2612             }
2613          }
2614       }
2615    }
2616    return NULL;
2617 }
2618
2619
2620 /*********************************************************************
2621  *
2622  * Function    :  content_requires_filtering
2623  *
2624  * Description :  Checks whether there are any content filters
2625  *                enabled for the current request and if they
2626  *                can actually be applied..
2627  *
2628  * Parameters  :
2629  *          1  :  csp = Current client state (buffers, headers, etc...)
2630  *
2631  * Returns     :  TRUE for yes, FALSE otherwise
2632  *
2633  *********************************************************************/
2634 int content_requires_filtering(struct client_state *csp)
2635 {
2636    if ((csp->content_type & CT_TABOO)
2637       && !(csp->action->flags & ACTION_FORCE_TEXT_MODE))
2638    {
2639       return FALSE;
2640    }
2641
2642    /*
2643     * Are we enabling text mode by force?
2644     */
2645    if (csp->action->flags & ACTION_FORCE_TEXT_MODE)
2646    {
2647       /*
2648        * Do we really have to?
2649        */
2650       if (csp->content_type & CT_TEXT)
2651       {
2652          log_error(LOG_LEVEL_HEADER, "Text mode is already enabled.");
2653       }
2654       else
2655       {
2656          csp->content_type |= CT_TEXT;
2657          log_error(LOG_LEVEL_HEADER, "Text mode enabled by force. Take cover!");
2658       }
2659    }
2660
2661    if (!(csp->content_type & CT_DECLARED))
2662    {
2663       /*
2664        * The server didn't bother to declare a MIME-Type.
2665        * Assume it's text that can be filtered.
2666        *
2667        * This also regulary happens with 304 responses,
2668        * therefore logging anything here would cause
2669        * too much noise.
2670        */
2671       csp->content_type |= CT_TEXT;
2672    }
2673
2674    /*
2675     * Choose the applying filter function based on
2676     * the content type and action settings.
2677     */
2678    if ((csp->content_type & CT_TEXT) &&
2679        (!list_is_empty(csp->action->multi[ACTION_MULTI_FILTER]) ||
2680         !list_is_empty(csp->action->multi[ACTION_MULTI_EXTERNAL_FILTER])))
2681    {
2682       return TRUE;
2683    }
2684    else if ((csp->content_type & CT_GIF)  &&
2685             (csp->action->flags & ACTION_DEANIMATE))
2686    {
2687       return TRUE;
2688    }
2689
2690    return FALSE;
2691
2692 }
2693
2694
2695 /*********************************************************************
2696  *
2697  * Function    :  content_filters_enabled
2698  *
2699  * Description :  Checks whether there are any content filters
2700  *                enabled for the current request.
2701  *
2702  * Parameters  :
2703  *          1  :  action = Action spec to check.
2704  *
2705  * Returns     :  TRUE for yes, FALSE otherwise
2706  *
2707  *********************************************************************/
2708 int content_filters_enabled(const struct current_action_spec *action)
2709 {
2710    return ((action->flags & ACTION_DEANIMATE) ||
2711       !list_is_empty(action->multi[ACTION_MULTI_FILTER]) ||
2712       !list_is_empty(action->multi[ACTION_MULTI_EXTERNAL_FILTER]));
2713 }
2714
2715
2716 /*********************************************************************
2717  *
2718  * Function    :  filters_available
2719  *
2720  * Description :  Checks whether there are any filters available.
2721  *
2722  * Parameters  :
2723  *          1  :  csp = Current client state (buffers, headers, etc...)
2724  *
2725  * Returns     :  TRUE for yes, FALSE otherwise.
2726  *
2727  *********************************************************************/
2728 int filters_available(const struct client_state *csp)
2729 {
2730    int i;
2731    for (i = 0; i < MAX_AF_FILES; i++)
2732    {
2733       const struct file_list *fl = csp->rlist[i];
2734       if ((NULL != fl) && (NULL != fl->f))
2735       {
2736          return TRUE;
2737       }
2738    }
2739    return FALSE;
2740 }
2741
2742
2743 /*
2744   Local Variables:
2745   tab-width: 3
2746   end:
2747 */