parsers.c

   1 /*********************************************************************
   2  *
   3  * File        :  $Source: /cvsroot/ijbswa/current/parsers.c,v $
   4  *
   5  * Purpose     :  Declares functions to parse/crunch headers and pages.
   6  *
   7  * Copyright   :  Written by and Copyright (C) 2001-2020 the
   8  *                Privoxy team. https://www.privoxy.org/
   9  *
  10  *                Based on the Internet Junkbuster originally written
  11  *                by and Copyright (C) 1997 Anonymous Coders and
  12  *                Junkbusters Corporation.  http://www.junkbusters.com
  13  *
  14  *                This program is free software; you can redistribute it
  15  *                and/or modify it under the terms of the GNU General
  16  *                Public License as published by the Free Software
  17  *                Foundation; either version 2 of the License, or (at
  18  *                your option) any later version.
  19  *
  20  *                This program is distributed in the hope that it will
  21  *                be useful, but WITHOUT ANY WARRANTY; without even the
  22  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
  23  *                PARTICULAR PURPOSE.  See the GNU General Public
  24  *                License for more details.
  25  *
  26  *                The GNU General Public License should be included with
  27  *                this file.  If not, you can view it at
  28  *                http://www.gnu.org/copyleft/gpl.html
  29  *                or write to the Free Software Foundation, Inc., 59
  30  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  31  *
  32  *********************************************************************/
  33
  34
  35 #include "config.h"
  36
  37 #ifndef _WIN32
  38 #include <stdio.h>
  39 #include <sys/types.h>
  40 #endif
  41
  42 #include <stdlib.h>
  43 #include <ctype.h>
  44 #include <assert.h>
  45 #include <string.h>
  46
  47 #ifdef __GLIBC__
  48 /*
  49  * Convince GNU's libc to provide a strptime prototype.
  50  */
  51 #define __USE_XOPEN
  52 #endif /*__GLIBC__ */
  53 #include <time.h>
  54
  55 #ifdef FEATURE_ZLIB
  56 #include <zlib.h>
  57
  58 #define GZIP_IDENTIFIER_1       0x1f
  59 #define GZIP_IDENTIFIER_2       0x8b
  60
  61 #define GZIP_FLAG_CHECKSUM      0x02
  62 #define GZIP_FLAG_EXTRA_FIELDS  0x04
  63 #define GZIP_FLAG_FILE_NAME     0x08
  64 #define GZIP_FLAG_COMMENT       0x10
  65 #define GZIP_FLAG_RESERVED_BITS 0xe0
  66 #endif
  67 #ifdef FEATURE_BROTLI
  68 #include <brotli/decode.h>
  69 #endif
  70
  71 #if !defined(_WIN32)
  72 #include <unistd.h>
  73 #endif
  74
  75 #include "project.h"
  76
  77 #ifdef FEATURE_PTHREAD
  78 #include "jcc.h"
  79 /* jcc.h is for mutex semapores only */
  80 #endif /* def FEATURE_PTHREAD */
  81 #include "list.h"
  82 #include "parsers.h"
  83 #include "ssplit.h"
  84 #include "errlog.h"
  85 #include "jbsockets.h"
  86 #include "miscutil.h"
  87 #include "list.h"
  88 #include "actions.h"
  89 #include "filters.h"
  90 #ifdef FEATURE_HTTPS_INSPECTION
  91 #include "ssl.h"
  92 #endif
  93
  94 #ifndef HAVE_STRPTIME
  95 #include "strptime.h"
  96 #endif
  97
  98 static char *get_header_line(struct iob *iob);
  99 static jb_err scan_headers(struct client_state *csp);
 100 static jb_err header_tagger(struct client_state *csp, char *header);
 101 static jb_err parse_header_time(const char *header_time, time_t *result);
 102 static jb_err parse_time_header(const char *header, time_t *result);
 103
 104 static jb_err crumble                   (struct client_state *csp, char **header);
 105 static jb_err filter_header             (struct client_state *csp, char **header);
 106 static jb_err client_connection         (struct client_state *csp, char **header);
 107 static jb_err client_referrer           (struct client_state *csp, char **header);
 108 static jb_err client_uagent             (struct client_state *csp, char **header);
 109 static jb_err client_ua                 (struct client_state *csp, char **header);
 110 static jb_err client_from               (struct client_state *csp, char **header);
 111 static jb_err client_send_cookie        (struct client_state *csp, char **header);
 112 static jb_err client_x_forwarded        (struct client_state *csp, char **header);
 113 static jb_err client_accept_encoding    (struct client_state *csp, char **header);
 114 static jb_err client_te                 (struct client_state *csp, char **header);
 115 static jb_err client_max_forwards       (struct client_state *csp, char **header);
 116 static jb_err client_host               (struct client_state *csp, char **header);
 117 static jb_err client_if_modified_since  (struct client_state *csp, char **header);
 118 static jb_err client_accept_language    (struct client_state *csp, char **header);
 119 static jb_err client_if_none_match      (struct client_state *csp, char **header);
 120 static jb_err crunch_client_header      (struct client_state *csp, char **header);
 121 static jb_err client_x_filter           (struct client_state *csp, char **header);
 122 static jb_err client_range              (struct client_state *csp, char **header);
 123 static jb_err client_expect             (struct client_state *csp, char **header);
 124 static jb_err server_set_cookie         (struct client_state *csp, char **header);
 125 static jb_err server_connection         (struct client_state *csp, char **header);
 126 static jb_err server_content_type       (struct client_state *csp, char **header);
 127 static jb_err server_adjust_content_length(struct client_state *csp, char **header);
 128 static jb_err server_content_md5        (struct client_state *csp, char **header);
 129 static jb_err server_content_encoding   (struct client_state *csp, char **header);
 130 static jb_err server_transfer_coding    (struct client_state *csp, char **header);
 131 static jb_err server_http               (struct client_state *csp, char **header);
 132 static jb_err crunch_server_header      (struct client_state *csp, char **header);
 133 static jb_err server_last_modified      (struct client_state *csp, char **header);
 134 static jb_err server_content_disposition(struct client_state *csp, char **header);
 135 #ifdef FEATURE_ZLIB
 136 static jb_err server_adjust_content_encoding(struct client_state *csp, char **header);
 137 #endif
 138
 139 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
 140 static jb_err server_save_content_length(struct client_state *csp, char **header);
 141 static jb_err server_keep_alive(struct client_state *csp, char **header);
 142 static jb_err server_proxy_connection(struct client_state *csp, char **header);
 143 static jb_err client_keep_alive(struct client_state *csp, char **header);
 144 static jb_err client_proxy_connection(struct client_state *csp, char **header);
 145 #endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
 146
 147 static jb_err client_save_content_length(struct client_state *csp, char **header);
 148 static jb_err client_host_adder       (struct client_state *csp);
 149 static jb_err client_xtra_adder       (struct client_state *csp);
 150 static jb_err client_x_forwarded_for_adder(struct client_state *csp);
 151 static jb_err client_connection_header_adder(struct client_state *csp);
 152 static jb_err server_connection_adder(struct client_state *csp);
 153 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
 154 static jb_err server_proxy_connection_adder(struct client_state *csp);
 155 #endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
 156 static jb_err proxy_authentication(struct client_state *csp, char **header);
 157
 158 static jb_err create_forged_referrer(char **header, const char *hostport);
 159 static jb_err create_fake_referrer(char **header, const char *fake_referrer);
 160 static jb_err handle_conditional_hide_referrer_parameter(char **header,
 161    const char *host, const int parameter_conditional_block);
 162 static void create_content_length_header(unsigned long long content_length,
 163                                          char *header, size_t buffer_length);
 164
 165 /*
 166  * List of functions to run on a list of headers.
 167  */
 168 struct parsers
 169 {
 170    /** The header prefix to match */
 171    const char *str;
 172
 173    /** The length of the prefix to match */
 174    const size_t len;
 175
 176    /** The function to apply to this line */
 177    const parser_func_ptr parser;
 178 };
 179
 180 static const struct parsers client_patterns[] = {
 181    { "referer:",                  8,   client_referrer },
 182    { "user-agent:",              11,   client_uagent },
 183    { "ua-",                       3,   client_ua },
 184    { "from:",                     5,   client_from },
 185    { "cookie:",                   7,   client_send_cookie },
 186    { "x-forwarded-for:",         16,   client_x_forwarded },
 187    { "Accept-Encoding:",         16,   client_accept_encoding },
 188    { "TE:",                       3,   client_te },
 189    { "Host:",                     5,   client_host },
 190    { "if-modified-since:",       18,   client_if_modified_since },
 191    { "Content-Length:",          15,   client_save_content_length },
 192 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
 193    { "Keep-Alive:",              11,   client_keep_alive },
 194    { "Proxy-Connection:",        17,   client_proxy_connection },
 195 #else
 196    { "Keep-Alive:",              11,   crumble },
 197    { "Proxy-Connection:",        17,   crumble },
 198 #endif
 199    { "connection:",              11,   client_connection },
 200    { "max-forwards:",            13,   client_max_forwards },
 201    { "Accept-Language:",         16,   client_accept_language },
 202    { "if-none-match:",           14,   client_if_none_match },
 203    { "Range:",                    6,   client_range },
 204    { "Request-Range:",           14,   client_range },
 205    { "If-Range:",                 9,   client_range },
 206    { "X-Filter:",                 9,   client_x_filter },
 207    { "Proxy-Authorization:",     20,   proxy_authentication },
 208 #if 0
 209    { "Transfer-Encoding:",       18,   client_transfer_encoding },
 210 #endif
 211    { "Expect:",                   7,   client_expect },
 212    { "*",                         0,   crunch_client_header },
 213    { "*",                         0,   filter_header },
 214    { NULL,                        0,   NULL }
 215 };
 216
 217 static const struct parsers server_patterns[] = {
 218    { "HTTP/",                     5, server_http },
 219    { "set-cookie:",              11, server_set_cookie },
 220    { "connection:",              11, server_connection },
 221    { "Content-Type:",            13, server_content_type },
 222    { "Content-MD5:",             12, server_content_md5 },
 223    { "Content-Encoding:",        17, server_content_encoding },
 224 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
 225    { "Content-Length:",          15, server_save_content_length },
 226    { "Keep-Alive:",              11, server_keep_alive },
 227    { "Proxy-Connection:",        17, server_proxy_connection },
 228 #else
 229    { "Keep-Alive:",              11, crumble },
 230 #endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
 231    { "Transfer-Encoding:",       18, server_transfer_coding },
 232    { "content-disposition:",     20, server_content_disposition },
 233    { "Last-Modified:",           14, server_last_modified },
 234    { "Proxy-Authenticate:",      19, proxy_authentication },
 235    { "*",                         0, crunch_server_header },
 236    { "*",                         0, filter_header },
 237    { NULL,                        0, NULL }
 238 };
 239
 240 static const add_header_func_ptr add_client_headers[] = {
 241    client_host_adder,
 242    client_x_forwarded_for_adder,
 243    client_xtra_adder,
 244    client_connection_header_adder,
 245    NULL
 246 };
 247
 248 static const add_header_func_ptr add_server_headers[] = {
 249    server_connection_adder,
 250 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
 251    server_proxy_connection_adder,
 252 #endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
 253    NULL
 254 };
 255
 256 /*********************************************************************
 257  *
 258  * Function    :  flush_iob
 259  *
 260  * Description :  Write any pending "buffered" content.
 261  *
 262  * Parameters  :
 263  *          1  :  fd = file descriptor of the socket to read
 264  *          2  :  iob = The I/O buffer to flush, usually csp->iob.
 265  *          3  :  delay = Number of milliseconds to delay the writes
 266  *
 267  * Returns     :  On success, the number of bytes written are returned (zero
 268  *                indicates nothing was written).  On error, -1 is returned,
 269  *                and errno is set appropriately.  If count is zero and the
 270  *                file descriptor refers to a regular file, 0 will be
 271  *                returned without causing any other effect.  For a special
 272  *                file, the results are not portable.
 273  *
 274  *********************************************************************/
 275 long flush_iob(jb_socket fd, struct iob *iob, unsigned int delay)
 276 {
 277    long len = iob->eod - iob->cur;
 278
 279    if (len <= 0)
 280    {
 281       return(0);
 282    }
 283
 284    if (write_socket_delayed(fd, iob->cur, (size_t)len, delay))
 285    {
 286       return(-1);
 287    }
 288    iob->eod = iob->cur = iob->buf;
 289    return(len);
 290
 291 }
 292
 293
 294 /*********************************************************************
 295  *
 296  * Function    :  can_add_to_iob
 297  *
 298  * Description :  Checks if the given number of bytes can be added to the given iob
 299  *                without exceeding the given buffer limit.
 300  *
 301  * Parameters  :
 302  *          1  :  iob = Destination buffer.
 303  *          2  :  buffer_limit = Limit to which the destination may grow
 304  *          3  :  n = number of bytes to be added
 305  *
 306  * Returns     :  TRUE if the given iob can handle given number of bytes
 307  *                FALSE buffer limit will be exceeded
 308  *
 309  *********************************************************************/
 310 int can_add_to_iob(const struct iob *iob, const size_t buffer_limit, size_t n)
 311 {
 312    return ((size_t)(iob->eod - iob->buf) + n + 1) > buffer_limit ? FALSE : TRUE;
 313 }
 314
 315 /*********************************************************************
 316  *
 317  * Function    :  add_to_iob
 318  *
 319  * Description :  Add content to the buffer, expanding the
 320  *                buffer if necessary.
 321  *
 322  * Parameters  :
 323  *          1  :  iob = Destination buffer.
 324  *          2  :  buffer_limit = Limit to which the destination may grow
 325  *          3  :  src = holds the content to be added
 326  *          4  :  n = number of bytes to be added
 327  *
 328  * Returns     :  JB_ERR_OK on success, JB_ERR_MEMORY if out-of-memory
 329  *                or buffer limit reached.
 330  *
 331  *********************************************************************/
 332 jb_err add_to_iob(struct iob *iob, const size_t buffer_limit, const char *src, long n)
 333 {
 334    size_t used, offset, need;
 335    char *p;
 336
 337    if (n <= 0) return JB_ERR_OK;
 338
 339    used   = (size_t)(iob->eod - iob->buf);
 340    offset = (size_t)(iob->cur - iob->buf);
 341    need   = used + (size_t)n + 1;
 342
 343    /*
 344     * If the buffer can't hold the new data, extend it first.
 345     * Use the next power of two if possible, else use the actual need.
 346     */
 347    if (need > buffer_limit)
 348    {
 349       log_error(LOG_LEVEL_INFO,
 350          "Buffer limit reached while extending the buffer (iob). Needed: %lu. Limit: %lu",
 351          need, buffer_limit);
 352       return JB_ERR_MEMORY;
 353    }
 354
 355    if (need > iob->size)
 356    {
 357       size_t want = iob->size ? iob->size : 512;
 358
 359       while (want <= need)
 360       {
 361          want *= 2;
 362       }
 363
 364       if (want <= buffer_limit && NULL != (p = (char *)realloc(iob->buf, want)))
 365       {
 366          iob->size = want;
 367       }
 368       else if (NULL != (p = (char *)realloc(iob->buf, need)))
 369       {
 370          iob->size = need;
 371       }
 372       else
 373       {
 374          log_error(LOG_LEVEL_ERROR, "Extending the buffer (iob) failed: %E");
 375          return JB_ERR_MEMORY;
 376       }
 377
 378       /* Update the iob pointers */
 379       iob->cur = p + offset;
 380       iob->eod = p + used;
 381       iob->buf = p;
 382    }
 383
 384    /* copy the new data into the iob buffer */
 385    memcpy(iob->eod, src, (size_t)n);
 386
 387    /* point to the end of the data */
 388    iob->eod += n;
 389