urlmatch.c

   1 const char urlmatch_rcs[] = "$Id: urlmatch.c,v 1.76 2013/11/24 14:22:51 fabiankeil Exp $";
   2 /*********************************************************************
   3  *
   4  * File        :  $Source: /cvsroot/ijbswa/current/urlmatch.c,v $
   5  *
   6  * Purpose     :  Declares functions to match URLs against URL
   7  *                patterns.
   8  *
   9  * Copyright   :  Written by and Copyright (C) 2001-2011
  10  *                the 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 #ifndef _WIN32
  40 #include <stdio.h>
  41 #include <sys/types.h>
  42 #endif
  43
  44 #include <stdlib.h>
  45 #include <ctype.h>
  46 #include <assert.h>
  47 #include <string.h>
  48
  49 #if !defined(_WIN32) && !defined(__OS2__)
  50 #include <unistd.h>
  51 #endif
  52
  53 #include "project.h"
  54 #include "urlmatch.h"
  55 #include "ssplit.h"
  56 #include "miscutil.h"
  57 #include "errlog.h"
  58
  59 const char urlmatch_h_rcs[] = URLMATCH_H_VERSION;
  60
  61 enum regex_anchoring
  62 {
  63    NO_ANCHORING,
  64    LEFT_ANCHORED,
  65    RIGHT_ANCHORED,
  66    RIGHT_ANCHORED_HOST
  67 };
  68 static jb_err compile_host_pattern(struct pattern_spec *url, const char *host_pattern);
  69
  70 /*********************************************************************
  71  *
  72  * Function    :  free_http_request
  73  *
  74  * Description :  Freez a http_request structure
  75  *
  76  * Parameters  :
  77  *          1  :  http = points to a http_request structure to free
  78  *
  79  * Returns     :  N/A
  80  *
  81  *********************************************************************/
  82 void free_http_request(struct http_request *http)
  83 {
  84    assert(http);
  85
  86    freez(http->cmd);
  87    freez(http->ocmd);
  88    freez(http->gpc);
  89    freez(http->host);
  90    freez(http->url);
  91    freez(http->hostport);
  92    freez(http->path);
  93    freez(http->ver);
  94    freez(http->host_ip_addr_str);
  95 #ifndef FEATURE_EXTENDED_HOST_PATTERNS
  96    freez(http->dbuffer);
  97    freez(http->dvec);
  98    http->dcount = 0;
  99 #endif
 100 }
 101
 102
 103 #ifndef FEATURE_EXTENDED_HOST_PATTERNS
 104 /*********************************************************************
 105  *
 106  * Function    :  init_domain_components
 107  *
 108  * Description :  Splits the domain name so we can compare it
 109  *                against wildcards. It used to be part of
 110  *                parse_http_url, but was separated because the
 111  *                same code is required in chat in case of
 112  *                intercepted requests.
 113  *
 114  * Parameters  :
 115  *          1  :  http = pointer to the http structure to hold elements.
 116  *
 117  * Returns     :  JB_ERR_OK on success
 118  *                JB_ERR_PARSE on malformed command/URL
 119  *                             or >100 domains deep.
 120  *
 121  *********************************************************************/
 122 jb_err init_domain_components(struct http_request *http)
 123 {
 124    char *vec[BUFFER_SIZE];
 125    size_t size;
 126    char *p;
 127
 128    http->dbuffer = strdup_or_die(http->host);
 129
 130    /* map to lower case */
 131    for (p = http->dbuffer; *p ; p++)
 132    {
 133       *p = (char)privoxy_tolower(*p);
 134    }
 135
 136    /* split the domain name into components */
 137    http->dcount = ssplit(http->dbuffer, ".", vec, SZ(vec));
 138
 139    if (http->dcount <= 0)
 140    {
 141       /*
 142        * Error: More than SZ(vec) components in domain
 143        *    or: no components in domain
 144        */
 145       log_error(LOG_LEVEL_ERROR, "More than SZ(vec) components in domain or none at all.");
 146       return JB_ERR_PARSE;
 147    }
 148
 149    /* save a copy of the pointers in dvec */
 150    size = (size_t)http->dcount * sizeof(*http->dvec);
 151
 152    http->dvec = malloc_or_die(size);
 153
 154    memcpy(http->dvec, vec, size);
 155
 156    return JB_ERR_OK;
 157 }
 158 #endif /* ndef FEATURE_EXTENDED_HOST_PATTERNS */
 159
 160
 161 /*********************************************************************
 162  *
 163  * Function    :  url_requires_percent_encoding
 164  *
 165  * Description :  Checks if an URL contains invalid characters
 166  *                according to RFC 3986 that should be percent-encoded.
 167  *                Does not verify whether or not the passed string
 168  *                actually is a valid URL.
 169  *
 170  * Parameters  :
 171  *          1  :  url = URL to check
 172  *
 173  * Returns     :  True in case of valid URLs, false otherwise
 174  *
 175  *********************************************************************/
 176 int url_requires_percent_encoding(const char *url)
 177 {
 178    static const char allowed_characters[128] = {
 179       '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
 180       '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
 181       '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
 182       '\0', '\0', '\0', '!',  '\0', '#',  '$',  '%',  '&',  '\'',
 183       '(',  ')',  '*',  '+',  ',',  '-',  '.',  '/',  '0',  '1',
 184       '2',  '3',  '4',  '5',  '6',  '7',  '8',  '9',  ':',  ';',
 185       '\0', '=',  '\0', '?',  '@',  'A',  'B',  'C',  'D',  'E',
 186       'F',  'G',  'H',  'I',  'J',  'K',  'L',  'M',  'N',  'O',
 187       'P',  'Q',  'R',  'S',  'T',  'U',  'V',  'W',  'X',  'Y',
 188       'Z',  '[',  '\0', ']',  '\0', '_',  '\0', 'a',  'b',  'c',
 189       'd',  'e',  'f',  'g',  'h',  'i',  'j',  'k',  'l',  'm',
 190       'n',  'o',  'p',  'q',  'r',  's',  't',  'u',  'v',  'w',
 191       'x',  'y',  'z',  '\0', '\0', '\0', '~',  '\0'
 192    };
 193
 194    while (*url != '\0')
 195    {
 196       const unsigned int i = (unsigned char)*url++;
 197       if (i >= sizeof(allowed_characters) || '\0' == allowed_characters[i])
 198       {
 199          return TRUE;
 200       }
 201    }
 202
 203    return FALSE;
 204
 205 }
 206
 207
 208 /*********************************************************************
 209  *
 210  * Function    :  parse_http_url
 211  *
 212  * Description :  Parse out the host and port from the URL.  Find the
 213  *                hostname & path, port (if ':'), and/or password (if '@')
 214  *
 215  * Parameters  :
 216  *          1  :  url = URL (or is it URI?) to break down
 217  *          2  :  http = pointer to the http structure to hold elements.
 218  *                       Must be initialized with valid values (like NULLs).
 219  *          3  :  require_protocol = Whether or not URLs without
 220  *                                   protocol are acceptable.
 221  *
 222  * Returns     :  JB_ERR_OK on success
 223  *                JB_ERR_PARSE on malformed command/URL
 224  *                             or >100 domains deep.
 225  *
 226  *********************************************************************/
 227 jb_err parse_http_url(const char *url, struct http_request *http, int require_protocol)
 228 {
 229    int host_available = 1; /* A proxy can dream. */
 230
 231    /*
 232     * Save our initial URL
 233     */
 234    http->url = strdup_or_die(url);
 235
 236    /*
 237     * Check for * URI. If found, we're done.
 238     */
 239    if (*http->url == '*')
 240    {
 241       http->path = strdup_or_die("*");
 242       http->hostport = strdup_or_die("");
 243       if (http->url[1] != '\0')
 244       {
 245          return JB_ERR_PARSE;
 246       }
 247       return JB_ERR_OK;
 248    }
 249
 250
 251    /*
 252     * Split URL into protocol,hostport,path.
 253     */
 254    {
 255       char *buf;
 256       char *url_noproto;
 257       char *url_path;
 258
 259       buf = strdup_or_die(url);
 260
 261       /* Find the start of the URL in our scratch space */
 262       url_noproto = buf;
 263       if (strncmpic(url_noproto, "http://",  7) == 0)
 264       {
 265          url_noproto += 7;
 266       }
 267       else if (strncmpic(url_noproto, "https://", 8) == 0)
 268       {
 269          /*
 270           * Should only happen when called from cgi_show_url_info().
 271           */
 272          url_noproto += 8;
 273          http->ssl = 1;
 274       }
 275       else if (*url_noproto == '/')
 276       {
 277         /*
 278          * Short request line without protocol and host.
 279          * Most likely because the client's request
 280          * was intercepted and redirected into Privoxy.
 281          */
 282          http->host = NULL;
 283          host_available = 0;
 284       }
 285       else if (require_protocol)
 286       {
 287          freez(buf);
 288          return JB_ERR_PARSE;
 289       }
 290
 291       url_path = strchr(url_noproto, '/');
 292       if (url_path != NULL)
 293       {
 294          /*
 295           * Got a path.
 296           *
 297           * NOTE: The following line ignores the path for HTTPS URLS.
 298           * This means that you get consistent behaviour if you type a
 299           * https URL in and it's parsed by the function.  (When the
 300           * URL is actually retrieved, SSL hides the path part).
 301           */
 302          http->path = strdup_or_die(http->ssl ? "/" : url_path);
 303          *url_path = '\0';
 304          http->hostport = strdup_or_die(url_noproto);
 305       }
 306       else
 307       {
 308          /*
 309           * Repair broken HTTP requests that don't contain a path,
 310           * or CONNECT requests
 311           */
 312          http->path = strdup_or_die("/");
 313          http->hostport = strdup_or_die(url_noproto);
 314       }
 315
 316       freez(buf);
 317    }
 318
 319    if (!host_available)
 320    {
 321       /* Without host, there is nothing left to do here */
 322       return JB_ERR_OK;
 323    }
 324
 325    /*
 326     * Split hostport into user/password (ignored), host, port.
 327     */
 328    {
 329       char *buf;
 330       char *host;
 331       char *port;
 332
 333       buf = strdup_or_die(http->hostport);
 334
 335       /* check if url contains username and/or password */
 336       host = strchr(buf, '@');
 337       if (host != NULL)
 338       {
 339          /* Contains username/password, skip it and the @ sign. */
 340          host++;
 341       }
 342       else
 343       {
 344          /* No username or password. */
 345          host = buf;
 346       }
 347
 348       /* Move after hostname before port number */
 349       if (*host == '[')
 350       {
 351          /* Numeric IPv6 address delimited by brackets */
 352          host++;
 353          port = strchr(host, ']');
 354
 355          if (port == NULL)
 356          {
 357             /* Missing closing bracket */
 358             freez(buf);
 359             return JB_ERR_PARSE;
 360          }
 361
 362          *port++ = '\0';
 363
 364          if (*port == '\0')
 365          {
 366             port = NULL;
 367          }
 368          else if (*port != ':')
 369          {
 370             /* Garbage after closing bracket */
 371             freez(buf);
 372             return JB_ERR_PARSE;
 373          }
 374       }
 375       else
 376       {
 377          /* Plain non-escaped hostname */
 378          port = strchr(host, ':');
 379       }
 380
 381       /* check if url contains port */
 382       if (port != NULL)
 383       {
 384          /* Contains port */
 385          char *endptr;
 386          long parsed_port;
 387          /* Terminate hostname and point to start of port string */
 388          *port++ = '\0';
 389          parsed_port = strtol(port, &endptr, 10);
 390          if ((parsed_port <= 0) || (parsed_port > 65535) || (*endptr != '\0'))
 391          {
 392             log_error(LOG_LEVEL_ERROR, "Invalid port in URL: %s.", url);
 393             freez(buf);
 394             return JB_ERR_PARSE;
 395          }
 396          http->port = (int)parsed_port;
 397       }
 398       else
 399       {
 400          /* No port specified. */
 401          http->port = (http->ssl ? 443 : 80);
 402       }
 403
 404       http->host = strdup_or_die(host);
 405
 406       freez(buf);
 407    }
 408
 409 #ifdef FEATURE_EXTENDED_HOST_PATTERNS
 410    return JB_ERR_OK;
 411 #else
 412    /* Split domain name so we can compare it against wildcards */
 413    return init_domain_components(http);
 414 #endif /* def FEATURE_EXTENDED_HOST_PATTERNS */
 415
 416 }
 417
 418
 419 /*********************************************************************
 420  *
 421  * Function    :  unknown_method
 422  *
 423  * Description :  Checks whether a method is unknown.
 424  *
 425  * Parameters  :
 426  *          1  :  method = points to a http method
 427  *
 428  * Returns     :  TRUE if it's unknown, FALSE otherwise.
 429  *
 430  *********************************************************************/
 431 static int unknown_method(const char *method)
 432 {
 433    static const char * const known_http_methods[] = {
 434       /* Basic HTTP request type */
 435       "GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS", "TRACE", "CONNECT",
 436       /* webDAV extensions (RFC2518) */
 437       "PROPFIND", "PROPPATCH", "MOVE", "COPY", "MKCOL", "LOCK", "UNLOCK",
 438       /*
 439        * Microsoft webDAV extension for Exchange 2000.  See:
 440        * http://lists.w3.org/Archives/Public/w3c-dist-auth/2002JanMar/0001.html
 441        * http://msdn.microsoft.com/library/en-us/wss/wss/_webdav_methods.asp
 442        */
 443       "BCOPY", "BMOVE", "BDELETE", "BPROPFIND", "BPROPPATCH",
 444       /*
 445        * Another Microsoft webDAV extension for Exchange 2000.  See:
 446        * http://systems.cs.colorado.edu/grunwald/MobileComputing/Papers/draft-cohen-gena-p-base-00.txt
 447        * http://lists.w3.org/Archives/Public/w3c-dist-auth/2002JanMar/0001.html
 448        * http://msdn.microsoft.com/library/en-us/wss/wss/_webdav_methods.asp
 449        */
 450       "SUBSCRIBE", "UNSUBSCRIBE", "NOTIFY", "POLL",
 451       /*
 452        * Yet another WebDAV extension, this time for
 453        * Web Distributed Authoring and Versioning (RFC3253)
 454        */
 455       "VERSION-CONTROL", "REPORT", "CHECKOUT", "CHECKIN", "UNCHECKOUT",
 456       "MKWORKSPACE", "UPDATE", "LABEL", "MERGE", "BASELINE-CONTROL", "MKACTIVITY",
 457    };
 458    int i;
 459
 460    for (i = 0; i < SZ(known_http_methods); i++)
 461    {
 462       if (0 == strcmpic(method, known_http_methods[i]))
 463       {
 464          return FALSE;
 465       }
 466    }
 467
 468    return TRUE;
 469
 470 }
 471
 472
 473 /*********************************************************************
 474  *
 475  * Function    :  parse_http_request
 476  *
 477  * Description :  Parse out the host and port from the URL.  Find the
 478  *                hostname & path, port (if ':'), and/or password (if '@')
 479  *
 480  * Parameters  :
 481  *          1  :  req = HTTP request line to break down
 482  *          2  :  http = pointer to the http structure to hold elements
 483  *
 484  * Returns     :  JB_ERR_OK on success
 485  *                JB_ERR_CGI_PARAMS on malformed command/URL
 486  *                                  or >100 domains deep.
 487  *
 488  *********************************************************************/
 489 jb_err parse_http_request(const char *req, struct http_request *http)
 490 {
 491    char *buf;
 492    char *v[10]; /* XXX: Why 10? We should only need three. */
 493    int n;
 494    jb_err err;
 495
 496    memset(http, '\0', sizeof(*http));
 497
 498    buf = strdup_or_die(req);
 499
 500    n = ssplit(buf, " \r\n", v, SZ(v));
 501    if (n != 3)
 502    {
 503       freez(buf);
 504       return JB_ERR_PARSE;
 505    }
 506
 507    /*
 508     * Fail in case of unknown methods
 509     * which we might not handle correctly.
 510     *
 511     * XXX: There should be a config option
 512     * to forward requests with unknown methods
 513     * anyway. Most of them don't need special
 514     * steps.
 515     */
 516    if (unknown_method(v[0]))
 517    {
 518       log_error(LOG_LEVEL_ERROR, "Unknown HTTP method detected: %s", v[0]);
 519       freez(buf);
 520       return JB_ERR_PARSE;
 521    }
 522
 523    if (strcmpic(v[2], "HTTP/1.1") && strcmpic(v[2], "HTTP/1.0"))
 524    {
 525       log_error(LOG_LEVEL_ERROR, "The only supported HTTP "
 526          "versions are 1.0 and 1.1. This rules out: %s", v[2]);
 527       freez(buf);
 528       return JB_ERR_PARSE;
 529    }
 530
 531    http->ssl = !strcmpic(v[0], "CONNECT");
 532
 533    err = parse_http_url(v[1], http, !http->ssl);
 534    if (err)
 535    {
 536       freez(buf);
 537       return err;
 538    }
 539
 540    /*
 541     * Copy the details into the structure
 542     */
 543    http->cmd = strdup_or_die(req);
 544    http->gpc = strdup_or_die(v[0]);
 545    http->ver = strdup_or_die(v[2]);
 546
 547    freez(buf);
 548
 549    return JB_ERR_OK;
 550
 551 }
 552
 553
 554 /*********************************************************************
 555  *
 556  * Function    :  compile_pattern
 557  *
 558  * Description :  Compiles a host, domain or TAG pattern.
 559  *
 560  * Parameters  :
 561  *          1  :  pattern = The pattern to compile.
 562  *          2  :  anchoring = How the regex should be modified
 563  *                            before compilation. Can be either
 564  *                            one of NO_ANCHORING, LEFT_ANCHORED,
 565  *                            RIGHT_ANCHORED or RIGHT_ANCHORED_HOST.
 566  *          3  :  url     = In case of failures, the spec member is
 567  *                          logged and the structure freed.
 568  *          4  :  regex   = Where the compiled regex should be stored.
 569  *
 570  * Returns     :  JB_ERR_OK - Success
 571  *                JB_ERR_MEMORY - Out of memory
 572  *                JB_ERR_PARSE - Cannot parse regex
 573  *
 574  *********************************************************************/
 575 static jb_err compile_pattern(const char *pattern, enum regex_anchoring anchoring,
 576                               struct pattern_spec *url, regex_t **regex)
 577 {
 578    int errcode;
 579    char rebuf[BUFFER_SIZE];
 580    const char *fmt = NULL;
 581
 582    assert(pattern);
 583    assert(strlen(pattern) < sizeof(rebuf) - 2);
 584
 585    if (pattern[0] == '\0')
 586    {
 587       *regex = NULL;
 588       return JB_ERR_OK;
 589    }
 590
 591    switch (anchoring)
 592    {
 593       case NO_ANCHORING:
 594          fmt = "%s";
 595          break;
 596       case RIGHT_ANCHORED:
 597          fmt = "%s$";
 598          break;
 599       case RIGHT_ANCHORED_HOST:
 600          fmt = "%s\\.?$";
 601          break;
 602       case LEFT_ANCHORED:
 603          fmt = "^%s";
 604          break;
 605       default:
 606          log_error(LOG_LEVEL_FATAL,
 607             "Invalid anchoring in compile_pattern %d", anchoring);
 608    }
 609
 610    *regex = zalloc(sizeof(**regex));
 611    if (NULL == *regex)
 612    {
 613       free_url_spec(url);
 614       return JB_ERR_MEMORY;
 615    }
 616
 617    snprintf(rebuf, sizeof(rebuf), fmt, pattern);
 618
 619    errcode = regcomp(*regex, rebuf, (REG_EXTENDED|REG_NOSUB|REG_ICASE));
 620
 621    if (errcode)
 622    {
 623       size_t errlen = regerror(errcode, *regex, rebuf, sizeof(rebuf));
 624       if (errlen > (sizeof(rebuf) - (size_t)1))
 625       {
 626          errlen = sizeof(rebuf) - (size_t)1;
 627       }
 628       rebuf[errlen] = '\0';
 629       log_error(LOG_LEVEL_ERROR, "error compiling %s from %s: %s",
 630          pattern, url->spec, rebuf);
 631       free_url_spec(url);
 632
 633       return JB_ERR_PARSE;
 634    }
 635
 636    return JB_ERR_OK;
 637
 638 }
 639
 640
 641 /*********************************************************************
 642  *
 643  * Function    :  compile_url_pattern
 644  *
 645  * Description :  Compiles the three parts of an URL pattern.
 646  *
 647  * Parameters  :
 648  *          1  :  url = Target pattern_spec to be filled in.
 649  *          2  :  buf = The url pattern to compile. Will be messed up.
 650  *
 651  * Returns     :  JB_ERR_OK - Success
 652  *                JB_ERR_MEMORY - Out of memory
 653  *                JB_ERR_PARSE - Cannot parse regex
 654  *
 655  *********************************************************************/
 656 static jb_err compile_url_pattern(struct pattern_spec *url, char *buf)
 657 {
 658    char *p;
 659
 660    p = strchr(buf, '/');
 661    if (NULL != p)
 662    {
 663       /*
 664        * Only compile the regex if it consists of more than
 665        * a single slash, otherwise it wouldn't affect the result.
 666        */
 667       if (p[1] != '\0')
 668       {
 669          /*
 670           * XXX: does it make sense to compile the slash at the beginning?
 671           */
 672          jb_err err = compile_pattern(p, LEFT_ANCHORED, url, &url->pattern.url_spec.preg);
 673
 674          if (JB_ERR_OK != err)
 675          {
 676             return err;
 677          }
 678       }
 679       *p = '\0';
 680    }
 681
 682    /*
 683     * IPv6 numeric hostnames can contain colons, thus we need
 684     * to delimit the hostname before the real port separator.
 685     * As brackets are already used in the hostname pattern,
 686     * we use angle brackets ('<', '>') instead.
 687     */
 688    if ((buf[0] == '<') && (NULL != (p = strchr(buf + 1, '>'))))
 689    {
 690       *p++ = '\0';
 691       buf++;
 692
 693       if (*p == '\0')
 694       {
 695          /* IPv6 address without port number */
 696          p = NULL;
 697       }
 698       else if (*p != ':')
 699       {
 700          /* Garbage after address delimiter */
 701          return JB_ERR_PARSE;
 702       }
 703    }
 704    else
 705    {
 706       p = strchr(buf, ':');
 707    }
 708
 709    if (NULL != p)
 710    {
 711       *p++ = '\0';
 712       url->pattern.url_spec.port_list = strdup_or_die(p);
 713    }
 714    else
 715    {
 716       url->pattern.url_spec.port_list = NULL;
 717    }
 718
 719    if (buf[0] != '\0')
 720    {
 721       return compile_host_pattern(url, buf);
 722    }
 723
 724    return JB_ERR_OK;
 725
 726 }
 727
 728
 729 #ifdef FEATURE_EXTENDED_HOST_PATTERNS
 730 /*********************************************************************
 731  *
 732  * Function    :  compile_host_pattern
 733  *
 734  * Description :  Parses and compiles a host pattern.
 735  *
 736  * Parameters  :
 737  *          1  :  url = Target pattern_spec to be filled in.
 738  *          2  :  host_pattern = Host pattern to compile.
 739  *
 740  * Returns     :  JB_ERR_OK - Success
 741  *                JB_ERR_MEMORY - Out of memory
 742  *                JB_ERR_PARSE - Cannot parse regex
 743  *
 744  *********************************************************************/
 745 static jb_err compile_host_pattern(struct pattern_spec *url, const char *host_pattern)
 746 {
 747    return compile_pattern(host_pattern, RIGHT_ANCHORED_HOST, url, &url->pattern.url_spec.host_regex);
 748 }
 749
 750 #else
 751
 752 /*********************************************************************
 753  *
 754  * Function    :  compile_host_pattern
 755  *
 756  * Description :  Parses and "compiles" an old-school host pattern.
 757  *
 758  * Parameters  :
 759  *          1  :  url = Target pattern_spec to be filled in.
 760  *          2  :  host_pattern = Host pattern to parse.
 761  *
 762  * Returns     :  JB_ERR_OK - Success
 763  *                JB_ERR_PARSE - Cannot parse regex
 764  *
 765  *********************************************************************/
 766 static jb_err compile_host_pattern(struct pattern_spec *url, const char *host_pattern)
 767 {
 768    char *v[150];
 769    size_t size;
 770    char *p;
 771
 772    /*
 773     * Parse domain part
 774     */
 775    if (host_pattern[strlen(host_pattern) - 1] == '.')
 776    {
 777       url->unanchored |= ANCHOR_RIGHT;
 778    }
 779    if (host_pattern[0] == '.')
 780    {
 781       url->unanchored |= ANCHOR_LEFT;
 782    }
 783
 784    /*
 785     * Split domain into components
 786     */
 787    url->dbuffer = strdup_or_die(host_pattern);
 788
 789    /*
 790     * Map to lower case
 791     */
 792    for (p = url->dbuffer; *p ; p++)
 793    {
 794       *p = (char)privoxy_tolower(*p);
 795    }
 796
 797    /*
 798     * Split the domain name into components
 799     */
 800    url->dcount = ssplit(url->dbuffer, ".", v, SZ(v));
 801
 802    if (url->dcount < 0)
 803    {
 804       free_url_spec(url);
 805       return JB_ERR_PARSE;
 806    }
 807    else if (url->dcount != 0)
 808    {
 809       /*
 810        * Save a copy of the pointers in dvec
 811        */
 812       size = (size_t)url->dcount * sizeof(*url->dvec);
 813
 814       url->dvec = malloc_or_die(size);
 815
 816       memcpy(url->dvec, v, size);
 817    }
 818    /*
 819     * else dcount == 0 in which case we needn't do anything,
 820     * since dvec will never be accessed and the pattern will
 821     * match all domains.
 822     */
 823    return JB_ERR_OK;
 824 }
 825
 826
 827 /*********************************************************************
 828  *
 829  * Function    :  simplematch
 830  *
 831  * Description :  String matching, with a (greedy) '*' wildcard that
 832  *                stands for zero or more arbitrary characters and
 833  *                character classes in [], which take both enumerations
 834  *                and ranges.
 835  *
 836  * Parameters  :
 837  *          1  :  pattern = pattern for matching
 838  *          2  :  text    = text to be matched
 839  *
 840  * Returns     :  0 if match, else nonzero
 841  *
 842  *********************************************************************/
 843 static int simplematch(const char *pattern, const char *text)
 844 {
 845    const unsigned char *pat = (const unsigned char *)pattern;
 846    const unsigned char *txt = (const unsigned char *)text;
 847    const unsigned char *fallback = pat;
 848    int wildcard = 0;
 849
 850    unsigned char lastchar = 'a';
 851    unsigned i;
 852    unsigned char charmap[32];
 853
 854    while (*txt)
 855    {
 856
 857       /* EOF pattern but !EOF text? */
 858       if (*pat == '\0')
 859       {
 860          if (wildcard)
 861          {
 862             pat = fallback;
 863          }
 864          else
 865          {
 866             return 1;
 867          }
 868       }
 869
 870       /* '*' in the pattern?  */
 871       if (*pat == '*')
 872       {
 873
 874          /* The pattern ends afterwards? Speed up the return. */
 875          if (*++pat == '\0')
 876          {
 877             return 0;
 878          }
 879
 880          /* Else, set wildcard mode and remember position after '*' */
 881          wildcard = 1;
 882          fallback = pat;
 883       }
 884
 885       /* Character range specification? */
 886       if (*pat == '[')
 887       {
 888          memset(charmap, '\0', sizeof(charmap));
 889
 890          while (*++pat != ']')
 891          {
 892             if (!*pat)
 893             {
 894                return 1;
 895             }
 896             else if (*pat == '-')
 897             {
 898                if ((*++pat == ']') || *pat == '\0')
 899                {
 900                   return(1);
 901                }
 902                for (i = lastchar; i <= *pat; i++)
 903                {
 904                   charmap[i / 8] |= (unsigned char)(1 << (i % 8));
 905                }
 906             }
 907             else
 908             {
 909                charmap[*pat / 8] |= (unsigned char)(1 << (*pat % 8));
 910                lastchar = *pat;
 911             }
 912          }
 913       } /* -END- if Character range specification */
 914
 915
 916       /*
 917        * Char match, or char range match?
 918        */
 919       if ((*pat == *txt)
 920        || (*pat == '?')
 921        || ((*pat == ']') && (charmap[*txt / 8] & (1 << (*txt % 8)))))
 922       {
 923          /*
 924           * Success: Go ahead
 925           */
 926          pat++;
 927       }
 928       else if (!wildcard)
 929       {
 930          /*
 931           * No match && no wildcard: No luck
 932           */
 933          return 1;
 934       }
 935       else if (pat != fallback)
 936       {
 937          /*
 938           * Increment text pointer if in char range matching
 939           */
 940          if (*pat == ']')
 941          {
 942             txt++;
 943          }
 944          /*
 945           * Wildcard mode && nonmatch beyond fallback: Rewind pattern
 946           */
 947          pat = fallback;
 948          /*
 949           * Restart matching from current text pointer
 950           */
 951          continue;
 952       }
 953       txt++;
 954    }
 955
 956    /* Cut off extra '*'s */
 957    if (*pat == '*') pat++;
 958
 959    /* If this is the pattern's end, fine! */
 960    return(*pat);
 961
 962 }
 963
 964
 965 /*********************************************************************
 966  *
 967  * Function    :  simple_domaincmp
 968  *
 969  * Description :  Domain-wise Compare fqdn's.  The comparison is
 970  *                both left- and right-anchored.  The individual
 971  *                domain names are compared with simplematch().
 972  *                This is only used by domain_match.
 973  *
 974  * Parameters  :
 975  *          1  :  pv = array of patterns to compare
 976  *          2  :  fv = array of domain components to compare
 977  *          3  :  len = length of the arrays (both arrays are the
 978  *                      same length - if they weren't, it couldn't
 979  *                      possibly be a match).
 980  *
 981  * Returns     :  0 => domains are equivalent, else no match.
 982  *
 983  *********************************************************************/
 984 static int simple_domaincmp(char **pv, char **fv, int len)
 985 {
 986    int n;
 987
 988    for (n = 0; n < len; n++)
 989    {
 990       if (simplematch(pv[n], fv[n]))
 991       {
 992          return 1;
 993       }
 994    }
 995
 996    return 0;
 997
 998 }
 999
1000
1001 /*********************************************************************
1002  *
1003  * Function    :  domain_match
1004  *
1005  * Description :  Domain-wise Compare fqdn's. Governed by the bimap in
1006  *                pattern->unachored, the comparison is un-, left-,
1007  *                right-anchored, or both.
1008  *                The individual domain names are compared with
1009  *                simplematch().
1010  *
1011  * Parameters  :
1012  *          1  :  pattern = a domain that may contain a '*' as a wildcard.
1013  *          2  :  fqdn = domain name against which the patterns are compared.
1014  *
1015  * Returns     :  0 => domains are equivalent, else no match.
1016  *
1017  *********************************************************************/
1018 static int domain_match(const struct pattern_spec *pattern, const struct http_request *fqdn)
1019 {
1020    char **pv, **fv;  /* vectors  */
1021    int    plen, flen;
1022    int unanchored = pattern->unanchored & (ANCHOR_RIGHT | ANCHOR_LEFT);
1023
1024    plen = pattern->dcount;
1025    flen = fqdn->dcount;
1026
1027    if (flen < plen)
1028    {
1029       /* fqdn is too short to match this pattern */
1030       return 1;
1031    }
1032
1033    pv   = pattern->dvec;
1034    fv   = fqdn->dvec;
1035
1036    if (unanchored == ANCHOR_LEFT)
1037    {
1038       /*
1039        * Right anchored.
1040        *
1041        * Convert this into a fully anchored pattern with
1042        * the fqdn and pattern the same length
1043        */
1044       fv += (flen - plen); /* flen - plen >= 0 due to check above */
1045       return simple_domaincmp(pv, fv, plen);
1046    }
1047    else if (unanchored == 0)
1048    {
1049       /* Fully anchored, check length */
1050       if (flen != plen)
1051       {
1052          return 1;
1053       }
1054       return simple_domaincmp(pv, fv, plen);
1055    }
1056    else if (unanchored == ANCHOR_RIGHT)
1057    {
1058       /* Left anchored, ignore all extra in fqdn */
1059       return simple_domaincmp(pv, fv, plen);
1060    }
1061    else
1062    {
1063       /* Unanchored */
1064       int n;
1065       int maxn = flen - plen;
1066       for (n = 0; n <= maxn; n++)
1067       {
1068          if (!simple_domaincmp(pv, fv, plen))
1069          {
1070             return 0;
1071          }
1072          /*
1073           * Doesn't match from start of fqdn
1074           * Try skipping first part of fqdn
1075           */
1076          fv++;
1077       }
1078       return 1;
1079    }
1080
1081 }
1082 #endif /* def FEATURE_EXTENDED_HOST_PATTERNS */
1083
1084
1085 /*********************************************************************
1086  *
1087  * Function    :  create_url_spec
1088  *
1089  * Description :  Creates a "url_spec" structure from a string.
1090  *                When finished, free with free_url_spec().
1091  *
1092  * Parameters  :
1093  *          1  :  url = Target url_spec to be filled in.  Will be
1094  *                      zeroed before use.
1095  *          2  :  buf = Source pattern, null terminated.  NOTE: The
1096  *                      contents of this buffer are destroyed by this
1097  *                      function.  If this function succeeds, the
1098  *                      buffer is copied to url->spec.  If this
1099  *                      function fails, the contents of the buffer
1100  *                      are lost forever.
1101  *
1102  * Returns     :  JB_ERR_OK - Success
1103  *                JB_ERR_PARSE - Cannot parse regex (Detailed message
1104  *                               written to system log)
1105  *
1106  *********************************************************************/
1107 jb_err create_url_spec(struct pattern_spec *url, char *buf)
1108 {
1109    assert(url);
1110    assert(buf);
1111
1112    memset(url, '\0', sizeof(*url));
1113
1114    /* Remember the original specification for the CGI pages. */
1115    url->spec = strdup_or_die(buf);
1116
1117    /* Is it a positive tag pattern? */
1118    if (0 == strncmpic(url->spec, "TAG:", 4))
1119    {
1120       /* The pattern starts with the first character after "TAG:" */
1121       const char *tag_pattern = buf + 4;
1122       url->flags |= PATTERN_SPEC_TAG_PATTERN;
1123       return compile_pattern(tag_pattern, NO_ANCHORING, url, &url->pattern.tag_regex);
1124    }
1125    /* Is it a negative tag pattern? */
1126    if (0 == strncmpic(url->spec, "NO-REQUEST-TAG:", 15))
1127    {
1128       /* The pattern starts with the first character after "NO-REQUEST-TAG:" */
1129       const char *tag_pattern = buf + 15;
1130       url->flags |= PATTERN_SPEC_NO_REQUEST_TAG_PATTERN;
1131       return compile_pattern(tag_pattern, NO_ANCHORING, url, &url->pattern.tag_regex);
1132    }
1133    if (0 == strncmpic(url->spec, "NO-RESPONSE-TAG:", 16))
1134    {
1135       /* The pattern starts with the first character after "NO-RESPONSE-TAG:" */
1136       const char *tag_pattern = buf + 16;
1137       url->flags |= PATTERN_SPEC_NO_RESPONSE_TAG_PATTERN;
1138       return compile_pattern(tag_pattern, NO_ANCHORING, url, &url->pattern.tag_regex);
1139    }
1140
1141    url->flags |= PATTERN_SPEC_URL_PATTERN;
1142
1143    /* If it isn't a tag pattern it must be an URL pattern. */
1144    return compile_url_pattern(url, buf);
1145 }
1146
1147
1148 /*********************************************************************
1149  *
1150  * Function    :  free_url_spec
1151  *
1152  * Description :  Called from the "unloaders".  Freez the url
1153  *                structure elements.
1154  *
1155  * Parameters  :
1156  *          1  :  url = pointer to a pattern_spec structure.
1157  *
1158  * Returns     :  N/A
1159  *
1160  *********************************************************************/
1161 void free_url_spec(struct pattern_spec *url)
1162 {
1163    if (url == NULL) return;
1164
1165    freez(url->spec);
1166 #ifdef FEATURE_EXTENDED_HOST_PATTERNS
1167    if (url->pattern.url_spec.host_regex)
1168    {
1169       regfree(url->pattern.url_spec.host_regex);
1170       freez(url->pattern.url_spec.host_regex);
1171    }
1172 #else
1173    freez(url->pattern.url_spec.dbuffer);
1174    freez(url->pattern.url_spec.dvec);
1175    url->pattern.url_spec.dcount = 0;
1176 #endif /* ndef FEATURE_EXTENDED_HOST_PATTERNS */
1177    freez(url->pattern.url_spec.port_list);
1178    if (url->pattern.url_spec.preg)
1179    {
1180       regfree(url->pattern.url_spec.preg);
1181       freez(url->pattern.url_spec.preg);
1182    }
1183    if (url->pattern.tag_regex)
1184    {
1185       regfree(url->pattern.tag_regex);
1186       freez(url->pattern.tag_regex);
1187    }
1188 }
1189
1190
1191 /*********************************************************************
1192  *
1193  * Function    :  port_matches
1194  *
1195  * Description :  Compares a port against a port list.
1196  *
1197  * Parameters  :
1198  *          1  :  port      = The port to check.
1199  *          2  :  port_list = The list of port to compare with.
1200  *
1201  * Returns     :  TRUE for yes, FALSE otherwise.
1202  *
1203  *********************************************************************/
1204 static int port_matches(const int port, const char *port_list)
1205 {
1206    return ((NULL == port_list) || match_portlist(port_list, port));
1207 }
1208
1209
1210 /*********************************************************************
1211  *
1212  * Function    :  host_matches
1213  *
1214  * Description :  Compares a host against a host pattern.
1215  *
1216  * Parameters  :
1217  *          1  :  url = The URL to match
1218  *          2  :  pattern = The URL pattern
1219  *
1220  * Returns     :  TRUE for yes, FALSE otherwise.
1221  *
1222  *********************************************************************/
1223 static int host_matches(const struct http_request *http,
1224                         const struct pattern_spec *pattern)
1225 {
1226 #ifdef FEATURE_EXTENDED_HOST_PATTERNS
1227    return ((NULL == pattern->pattern.url_spec.host_regex)
1228       || (0 == regexec(pattern->pattern.url_spec.host_regex, http->host, 0, NULL, 0)));
1229 #else
1230    return ((NULL == pattern->pattern.url_spec.dbuffer) || (0 == domain_match(pattern, http)));
1231 #endif
1232 }
1233
1234
1235 /*********************************************************************
1236  *
1237  * Function    :  path_matches
1238  *
1239  * Description :  Compares a path against a path pattern.
1240  *
1241  * Parameters  :
1242  *          1  :  path = The path to match
1243  *          2  :  pattern = The URL pattern
1244  *
1245  * Returns     :  TRUE for yes, FALSE otherwise.
1246  *
1247  *********************************************************************/
1248 static int path_matches(const char *path, const struct pattern_spec *pattern)
1249 {
1250    return ((NULL == pattern->pattern.url_spec.preg)
1251       || (0 == regexec(pattern->pattern.url_spec.preg, path, 0, NULL, 0)));
1252 }
1253
1254
1255 /*********************************************************************
1256  *
1257  * Function    :  url_match
1258  *
1259  * Description :  Compare a URL against a URL pattern.
1260  *
1261  * Parameters  :
1262  *          1  :  pattern = a URL pattern
1263  *          2  :  url = URL to match
1264  *
1265  * Returns     :  Nonzero if the URL matches the pattern, else 0.
1266  *
1267  *********************************************************************/
1268 int url_match(const struct pattern_spec *pattern,
1269               const struct http_request *http)
1270 {
1271    if (!(pattern->flags & PATTERN_SPEC_URL_PATTERN))
1272    {
1273       /* It's not an URL pattern and thus shouldn't be matched against URLs */
1274       return 0;
1275    }
1276
1277    return (port_matches(http->port, pattern->pattern.url_spec.port_list)
1278       && host_matches(http, pattern) && path_matches(http->path, pattern));
1279
1280 }
1281
1282
1283 /*********************************************************************
1284  *
1285  * Function    :  match_portlist
1286  *
1287  * Description :  Check if a given number is covered by a comma
1288  *                separated list of numbers and ranges (a,b-c,d,..)
1289  *
1290  * Parameters  :
1291  *          1  :  portlist = String with list
1292  *          2  :  port = port to check
1293  *
1294  * Returns     :  0 => no match
1295  *                1 => match
1296  *
1297  *********************************************************************/
1298 int match_portlist(const char *portlist, int port)
1299 {
1300    char *min, *max, *next, *portlist_copy;
1301
1302    min = portlist_copy = strdup_or_die(portlist);
1303
1304    /*
1305     * Zero-terminate first item and remember offset for next
1306     */
1307    if (NULL != (next = strchr(portlist_copy, (int) ',')))
1308    {
1309       *next++ = '\0';
1310    }
1311
1312    /*
1313     * Loop through all items, checking for match
1314     */
1315    while (NULL != min)
1316    {
1317       if (NULL == (max = strchr(min, (int) '-')))
1318       {
1319          /*
1320           * No dash, check for equality
1321           */
1322          if (port == atoi(min))
1323          {
1324             freez(portlist_copy);
1325             return(1);
1326          }
1327       }
1328       else
1329       {
1330          /*
1331           * This is a range, so check if between min and max,
1332           * or, if max was omitted, between min and 65K
1333           */
1334          *max++ = '\0';
1335          if (port >= atoi(min) && port <= (atoi(max) ? atoi(max) : 65535))
1336          {
1337             freez(portlist_copy);
1338             return(1);
1339          }
1340
1341       }
1342
1343       /*
1344        * Jump to next item
1345        */
1346       min = next;
1347
1348       /*
1349        * Zero-terminate next item and remember offset for n+1
1350        */
1351       if ((NULL != next) && (NULL != (next = strchr(next, (int) ','))))
1352       {
1353          *next++ = '\0';
1354       }
1355    }
1356
1357    freez(portlist_copy);
1358    return 0;
1359
1360 }
1361
1362
1363 /*********************************************************************
1364  *
1365  * Function    :  parse_forwarder_address
1366  *
1367  * Description :  Parse out the host and port from a forwarder address.
1368  *
1369  * Parameters  :
1370  *          1  :  address = The forwarder address to parse.
1371  *          2  :  hostname = Used to return the hostname. NULL on error.
1372  *          3  :  port = Used to return the port. Untouched if no port
1373  *                       is specified.
1374  *
1375  * Returns     :  JB_ERR_OK on success
1376  *                JB_ERR_MEMORY on out of memory
1377  *                JB_ERR_PARSE on malformed address.
1378  *
1379  *********************************************************************/
1380 jb_err parse_forwarder_address(char *address, char **hostname, int *port)
1381 {
1382    char *p = address;
1383
1384    if ((*address == '[') && (NULL == strchr(address, ']')))
1385    {
1386       /* XXX: Should do some more validity checks here. */
1387       return JB_ERR_PARSE;
1388    }
1389
1390    *hostname = strdup_or_die(address);
1391
1392    if ((**hostname == '[') && (NULL != (p = strchr(*hostname, ']'))))
1393    {
1394       *p++ = '\0';
1395       memmove(*hostname, (*hostname + 1), (size_t)(p - *hostname));
1396       if (*p == ':')
1397       {
1398          *port = (int)strtol(++p, NULL, 0);
1399       }
1400    }
1401    else if (NULL != (p = strchr(*hostname, ':')))
1402    {
1403       *p++ = '\0';
1404       *port = (int)strtol(p, NULL, 0);
1405    }
1406
1407    return JB_ERR_OK;
1408
1409 }
1410
1411
1412 /*
1413   Local Variables:
1414   tab-width: 3
1415   end:
1416 */