http_parse.c

   1 /*
   2 Copyright (c) 2003-2006 by Juliusz Chroboczek
   3
   4 Permission is hereby granted, free of charge, to any person obtaining a copy
   5 of this software and associated documentation files (the "Software"), to deal
   6 in the Software without restriction, including without limitation the rights
   7 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8 copies of the Software, and to permit persons to whom the Software is
   9 furnished to do so, subject to the following conditions:
  10
  11 The above copyright notice and this permission notice shall be included in
  12 all copies or substantial portions of the Software.
  13
  14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  17 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  20 THE SOFTWARE.
  21 */
  22
  23 #include "polipo.h"
  24
  25 static int getNextWord(const char *buf, int i, int *x_return, int *y_return);
  26 static int getNextToken(const char *buf, int i, int *x_return, int *y_return);
  27 static int getNextTokenInList(const char *buf, int i,
  28                               int *x_return, int *y_return,
  29                               int *z_return, int *t_return,
  30                               int *end_return);
  31
  32 static AtomPtr atomConnection, atomProxyConnection, atomContentLength,
  33     atomHost, atomAcceptRange, atomTE,
  34     atomReferer, atomProxyAuthenticate, atomProxyAuthorization,
  35     atomKeepAlive, atomTrailer, atomUpgrade, atomDate, atomExpires,
  36     atomIfModifiedSince, atomIfUnmodifiedSince, atomIfRange, atomLastModified,
  37     atomIfMatch, atomIfNoneMatch, atomAge, atomTransferEncoding,
  38     atomETag, atomCacheControl, atomPragma, atomContentRange, atomRange,
  39     atomVia, atomVary, atomExpect, atomAuthorization,
  40     atomSetCookie, atomCookie, atomCookie2,
  41     atomXPolipoDate, atomXPolipoAccess, atomXPolipoLocation,
  42     atomXPolipoBodyOffset;
  43
  44 AtomPtr atomContentType, atomContentEncoding;
  45
  46 int censorReferer = 0;
  47 int laxHttpParser = 1;
  48
  49 static AtomListPtr censoredHeaders;
  50
  51 void
  52 preinitHttpParser()
  53 {
  54     CONFIG_VARIABLE_SETTABLE(censorReferer, CONFIG_TRISTATE, configIntSetter,
  55                              "Censor referer headers.");
  56     censoredHeaders = makeAtomList(NULL, 0);
  57     if(censoredHeaders == NULL) {
  58         do_log(L_ERROR, "Couldn't allocate censored atoms.\n");
  59         exit(1);
  60     }
  61     CONFIG_VARIABLE(censoredHeaders, CONFIG_ATOM_LIST_LOWER,
  62                     "Headers to censor.");
  63     CONFIG_VARIABLE_SETTABLE(laxHttpParser, CONFIG_BOOLEAN, configIntSetter,
  64                              "Ignore unknown HTTP headers.");
  65 }
  66
  67 void
  68 initHttpParser()
  69 {
  70 #define A(name, value) name = internAtom(value); if(!name) goto fail;
  71     /* These must be in lower-case */
  72     A(atomConnection, "connection");
  73     A(atomProxyConnection, "proxy-connection");
  74     A(atomContentLength, "content-length");
  75     A(atomHost, "host");
  76     A(atomAcceptRange, "accept-range");
  77     A(atomTE, "te");
  78     A(atomReferer, "referer");
  79     A(atomProxyAuthenticate, "proxy-authenticate");
  80     A(atomProxyAuthorization, "proxy-authorization");
  81     A(atomKeepAlive, "keep-alive");
  82     A(atomTrailer, "trailer");
  83     A(atomUpgrade, "upgrade");
  84     A(atomDate, "date");
  85     A(atomExpires, "expires");
  86     A(atomIfModifiedSince, "if-modified-since");
  87     A(atomIfUnmodifiedSince, "if-unmodified-since");
  88     A(atomIfRange, "if-range");
  89     A(atomLastModified, "last-modified");
  90     A(atomIfMatch, "if-match");
  91     A(atomIfNoneMatch, "if-none-match");
  92     A(atomAge, "age");
  93     A(atomTransferEncoding, "transfer-encoding");
  94     A(atomETag, "etag");
  95     A(atomCacheControl, "cache-control");
  96     A(atomPragma, "pragma");
  97     A(atomContentRange, "content-range");
  98     A(atomRange, "range");
  99     A(atomVia, "via");
 100     A(atomContentType, "content-type");
 101     A(atomContentEncoding, "content-encoding");
 102     A(atomVary, "vary");
 103     A(atomExpect, "expect");
 104     A(atomAuthorization, "authorization");
 105     A(atomSetCookie, "set-cookie");
 106     A(atomCookie, "cookie");
 107     A(atomCookie2, "cookie2");
 108     A(atomXPolipoDate, "x-polipo-date");
 109     A(atomXPolipoAccess, "x-polipo-access");
 110     A(atomXPolipoLocation, "x-polipo-location");
 111     A(atomXPolipoBodyOffset, "x-polipo-body-offset");
 112 #undef A
 113     return;
 114
 115  fail:
 116     do_log(L_ERROR, "Couldn't allocate atom.\n");
 117     exit(1);
 118 }
 119
 120 static int
 121 getNextWord(const char *restrict buf, int i, int *x_return, int *y_return)
 122 {
 123     int x, y;
 124     while(buf[i] == ' ') i++;
 125     if(buf[i] == '\n' || buf[i] == '\r') return -1;
 126     x = i;
 127     while(buf[i] > 32 && buf[i] < 127) i++;
 128     y = i;
 129
 130     *x_return = x;
 131     *y_return = y;
 132
 133     return 0;
 134 }
 135
 136 static int
 137 skipComment(const char *restrict buf, int i)
 138 {
 139     assert(buf[i] == '(');
 140
 141     i++;
 142     while(1) {
 143         if(buf[i] == '\\' && buf[i + 1] == ')') i+=2;
 144         else if(buf[i] == ')') return i + 1;
 145         else if(buf[i] == '\n') {
 146             if(buf[i + 1] == ' ' || buf[i + 1] == '\t')
 147                 i += 2;
 148             else
 149                 return -1;
 150         } else if(buf[i] == '\r') {
 151             if(buf[i + 1] != '\n') return -1;
 152             if(buf[i + 2] == ' ' || buf[i + 2] == '\t')
 153                 i += 3;
 154             else
 155                 return -1;
 156         } else {
 157             i++;
 158         }
 159     }
 160     return i;
 161 }
 162
 163
 164 static int
 165 skipWhitespace(const char *restrict buf, int i)
 166 {
 167     while(1) {
 168         if(buf[i] == ' ' || buf[i] == '\t')
 169             i++;
 170         else  if(buf[i] == '(') {
 171             i = skipComment(buf, i);
 172             if(i < 0) return -1;
 173         } else if(buf[i] == '\n') {
 174             if(buf[i + 1] == ' ' || buf[i + 1] == '\t')
 175                 i += 2;
 176             else
 177                 return i;
 178         } else if(buf[i] == '\r' && buf[i + 1] == '\n') {
 179             if(buf[i + 2] == ' ' || buf[i + 2] == '\t')
 180                 i += 3;
 181             else
 182                 return i;
 183         } else
 184             return i;
 185     }
 186 }
 187
 188 static int
 189 getNextToken(const char *restrict buf, int i, int *x_return, int *y_return)
 190 {
 191     int x, y;
 192  again:
 193     while(buf[i] == ' ' || buf[i] == '\t')
 194         i++;
 195     if(buf[i] == '(') {
 196         i++;
 197         while(buf[i] != ')') {
 198             if(buf[i] == '\n' || buf[i] == '\r')
 199                 return -1;
 200             if(buf[i] == '\\' && buf[i + 1] != '\n' && buf[i + 1] != '\r')
 201                 buf += 2;
 202             else
 203                 buf++;
 204         }
 205         goto again;
 206     }
 207     if(buf[i] == '\n') {
 208         if(buf[i + 1] == ' ' || buf[i + 1] == '\t') {
 209             i += 2;
 210             goto again;
 211         } else {
 212             return -1;
 213         }
 214     }
 215     if(buf[i] == '\r') {
 216         if(buf[i + 1] == '\n' && (buf[i + 2] == ' ' || buf[i + 2] == '\t')) {
 217             i += 3;
 218             goto again;
 219         } else {
 220             return -1;
 221         }
 222     }
 223     x = i;
 224     while(buf[i] > 32 && buf[i] < 127) {
 225         switch(buf[i]) {
 226         case '(': case ')': case '<': case '>': case '@':
 227         case ',': case ';': case ':': case '\\': case '/':
 228         case '[': case ']': case '?': case '=':
 229         case '{': case '}': case ' ': case '\t':
 230             goto out;
 231         default:
 232             i++;
 233         }
 234     }
 235  out:
 236     y = i;
 237
 238     *x_return = x;
 239     *y_return = y;
 240
 241     return y;
 242 }
 243
 244 static int
 245 getNextETag(const char * restrict buf, int i,
 246             int *x_return, int *y_return, int *weak_return)
 247 {
 248     int weak = 0;
 249     int x, y;
 250     while(buf[i] == ' ' || buf[i] == '\t')
 251         i++;
 252     if(buf[i] == 'W' && buf[i + 1] == '/') {
 253         weak = 1;
 254         i += 2;
 255     }
 256     if(buf[i] == '"')
 257         i++;
 258     else
 259         return -1;
 260
 261     x = i;
 262     while(buf[i] != '"') {
 263         if(buf[i] == '\r' && buf[i] == '\n')
 264             return -1;
 265         i++;
 266     }
 267     y = i;
 268     i++;
 269
 270     *x_return = x;
 271     *y_return = y;
 272     *weak_return = weak;
 273     return i;
 274 }
 275
 276 static int
 277 getNextTokenInList(const char *restrict buf, int i,
 278                    int *x_return, int *y_return,
 279                    int *z_return, int *t_return,
 280                    int *end_return)
 281 {
 282     int j, x, y, z = -1, t = -1, end;
 283     j = getNextToken(buf, i, &x, &y);
 284     if(j < 0)
 285         return -1;
 286     while(buf[j] == ' ' || buf[j] == '\t')
 287         j++;
 288
 289     if(buf[j] == '=') {
 290         j++;
 291         while(buf[j] == ' ' || buf[j] == '\t')
 292             j++;
 293         z = j;
 294         while(buf[j] != ',' && buf[j] != '\n' && buf[j] != '\r')
 295             j++;
 296     }
 297
 298     if(buf[j] == '\n' || buf[j] == '\r') {
 299         if(buf[j] == '\r') {
 300             if(buf[j + 1] != '\n')
 301                 return -1;
 302             j += 2;
 303         } else
 304             j++;
 305         end = 1;
 306         if(buf[j] == ' ' || buf[j] == '\t') {
 307             while(buf[j] == ' ' || buf[j] == '\t')
 308                 j++;
 309             end = 0;
 310         }
 311     } else if(buf[j] == ',') {
 312         j++;
 313         while(buf[j] == ' ' || buf[j] == '\t')
 314             j++;
 315         end = 0;
 316     } else {
 317         return -1;
 318     }
 319
 320     *x_return = x;
 321     *y_return = y;
 322     if(z_return)
 323         *z_return = z;
 324     if(t_return)
 325         *t_return = t;
 326     *end_return = end;
 327     return j;
 328 }
 329
 330 static inline int
 331 token_compare(const char *buf, int start, int end, const char *s)
 332 {
 333     return (strcasecmp_n(s, buf + start, end - start) == 0);
 334 }
 335
 336 static int
 337 skipEol(const char *restrict buf, int i)
 338 {
 339     while(buf[i] == ' ')
 340         i++;
 341     if(buf[i] == '\n')
 342         return i + 1;
 343     else if(buf[i] == '\r') {
 344         if(buf[i + 1] == '\n')
 345             return i + 2;
 346         else
 347             return -1;
 348     } else {
 349         return -1;
 350     }
 351 }
 352
 353 static int
 354 skipToEol(const char *restrict buf, int i, int *start_return)
 355 {
 356     while(buf[i] != '\n' && buf[i] != '\r')
 357         i++;
 358     if(buf[i] == '\n') {
 359         *start_return = i;
 360         return i + 1;
 361     } else if(buf[i] == '\r') {
 362         if(buf[i + 1] == '\n') {
 363             *start_return = i;
 364             return i + 2;
 365         } else {
 366             return -1;
 367         }
 368     }
 369     return -1;
 370 }
 371
 372 static int
 373 getHeaderValue(const char *restrict buf, int start,
 374                int *value_start_return, int *value_end_return)
 375 {
 376     int i, j, k;
 377
 378     while(buf[start] == ' ' || buf[start] == '\t')
 379         start++;
 380     i = start;
 381  again:
 382     j = skipToEol(buf, i, &k);
 383     if(j < 0)
 384         return -1;
 385     if(buf[j] == ' ' || buf[j] == '\t') {
 386         i = j + 1;
 387         goto again;
 388     }
 389     *value_start_return = start;
 390     *value_end_return = k;
 391     return j;
 392 }
 393
 394 int
 395 httpParseClientFirstLine(const char *restrict buf, int offset,
 396                          int *method_return,
 397                          AtomPtr *url_return,
 398                          int *version_return)
 399 {
 400     int i = 0;
 401     int x, y;
 402     int method;
 403     AtomPtr url;
 404     int version = HTTP_UNKNOWN;
 405     int eol;
 406
 407     i = offset;
 408     i = getNextWord(buf, i, &x, &y);
 409     if(i < 0) return -1;
 410     if(y == x + 3 && memcmp(buf + x, "GET", 3) == 0)
 411         method = METHOD_GET;
 412     else if(y == x + 4 && memcmp(buf + x, "HEAD", 4) == 0)
 413         method = METHOD_HEAD;
 414     else if(y == x + 4 && memcmp(buf + x, "POST", 4) == 0)
 415         method = METHOD_POST;
 416     else if(y == x + 3 && memcmp(buf + x, "PUT", 3) == 0)
 417         method = METHOD_PUT;
 418     else if(y == x + 7 && memcmp(buf + x, "CONNECT", 7) == 0)
 419         method = METHOD_CONNECT;
 420     else
 421         method = METHOD_UNKNOWN;
 422
 423     i = getNextWord(buf, y + 1, &x, &y);
 424     if(i < 0) return -1;
 425
 426     url = internAtomN(buf + x, y - x);
 427
 428     i = getNextWord(buf, y + 1, &x, &y);
 429     if(i < 0) {
 430         releaseAtom(url);
 431         return -1;
 432     }
 433
 434     if(y == x + 8) {
 435         if(memcmp(buf + x, "HTTP/1.", 7) != 0)
 436             version = HTTP_UNKNOWN;
 437         else if(buf[x + 7] == '0')
 438             version = HTTP_10;
 439         else if(buf[x + 7] >= '1' && buf[x + 7] <= '9')
 440             version = HTTP_11;
 441         else
 442             version = HTTP_UNKNOWN;
 443     }
 444
 445     eol = skipEol(buf, y);
 446     if(eol < 0) return -1;
 447
 448     *method_return = method;
 449     if(url_return)
 450         *url_return = url;
 451     else
 452         releaseAtom(url);
 453     *version_return = version;
 454     return eol;
 455 }
 456
 457 int
 458 httpParseServerFirstLine(const char *restrict buf,
 459                          int *status_return,
 460                          int *version_return,
 461                          AtomPtr *message_return)
 462 {
 463     int i = 0;
 464     int x, y, eol;
 465     int status;
 466     int version = HTTP_UNKNOWN;
 467
 468     i = getNextWord(buf, 0, &x, &y);
 469     if(i < 0)
 470         return -1;
 471     if(y == x + 8 && memcmp(buf + x, "HTTP/1.0", 8) == 0)
 472         version = HTTP_10;
 473     else if(y >= x + 8 && memcmp(buf + x, "HTTP/1.", 7) == 0)
 474         version = HTTP_11;
 475     else
 476         version = HTTP_UNKNOWN;
 477
 478     i = getNextWord(buf, y + 1, &x, &y);
 479     if(i < 0) return -1;
 480     if(y == x + 3)
 481         status = atol(buf + x);
 482     else return -1;
 483
 484     i = skipToEol(buf, y, &eol);
 485     if(i < 0) return -1;
 486
 487     *status_return = status;
 488     *version_return = version;
 489     if(message_return) {
 490         /* Netscape enterprise bug */
 491         if(eol > y)
 492             *message_return = internAtomN(buf + y + 1, eol - y - 1);
 493         else
 494             *message_return = internAtom("No message");
 495     }
 496     return i;
 497 }
 498
 499 static int
 500 parseInt(const char *restrict buf, int start, int *val_return)
 501 {
 502     int i = start, val = 0;
 503     if(!digit(buf[i]))
 504         return -1;
 505     while(digit(buf[i])) {
 506         val = val * 10 + (buf[i] - '0');
 507         i++;
 508     }
 509     *val_return = val;
 510     return i;
 511 }
 512
 513 /* Returned *name_start_return is -1 at end of headers, -2 if the line
 514    couldn't be parsed. */
 515 static int
 516 parseHeaderLine(const char *restrict buf, int start,
 517                 int *name_start_return, int *name_end_return,
 518                 int *value_start_return, int *value_end_return)
 519 {
 520     int i;
 521     int name_start, name_end, value_start, value_end;
 522
 523     if(buf[start] == '\n') {
 524         *name_start_return = -1;
 525         return start + 1;
 526     }
 527     if(buf[start] == '\r' && buf[start + 1] == '\n') {
 528         *name_start_return = -1;
 529         return start + 2;
 530     }
 531
 532     i = getNextToken(buf, start, &name_start, &name_end);
 533     if(i < 0 || buf[i] != ':')
 534         goto syntax;
 535     i++;
 536     while(buf[i] == ' ' || buf[i] == '\t')
 537         i++;
 538
 539     i = getHeaderValue(buf, i, &value_start, &value_end);
 540     if(i < 0)
 541         goto syntax;
 542
 543     *name_start_return = name_start;
 544     *name_end_return = name_end;
 545     *value_start_return = value_start;
 546     *value_end_return = value_end;
 547     return i;
 548
 549  syntax:
 550     i = start;
 551     while(1) {
 552         if(buf[i] == '\n') {
 553             i++;
 554             break;
 555         }
 556         if(buf[i] == '\r' && buf[i + 1] == '\n') {
 557             i += 2;
 558             break;
 559         }
 560         i++;
 561     }
 562     *name_start_return = -2;
 563     return i;
 564 }
 565
 566 int
 567 findEndOfHeaders(const char *restrict buf, int from, int to, int *body_return)
 568 {
 569     int i = from;
 570     int eol = 0;
 571     while(i < to) {
 572         if(buf[i] == '\n') {
 573             if(eol) {
 574                 *body_return = i + 1;
 575                 return eol;
 576             }
 577             eol = i;
 578             i++;
 579         } else if(buf[i] == '\r') {
 580             if(i < to - 1 && buf[i + 1] == '\n') {
 581                 if(eol) {
 582                     *body_return = eol;
 583                     return i + 2;
 584                 }
 585                 eol = i;
 586                 i += 2;
 587             } else {
 588                 eol = 0;
 589                 i++;
 590             }
 591         } else {
 592             eol = 0;
 593             i++;
 594         }
 595     }
 596     return -1;
 597 }
 598
 599 static int
 600 parseContentRange(const char *restrict buf, int i,
 601                   int *from_return, int *to_return, int *full_len_return)
 602 {
 603     int j;
 604     int from, to, full_len;
 605
 606     i = skipWhitespace(buf, i);
 607     if(i < 0) return -1;
 608     if(!token_compare(buf, i, i + 5, "bytes"))
 609         return -1;
 610     i += 5;
 611     i = skipWhitespace(buf, i);
 612     if(buf[i] == '*') {
 613         from = 0;
 614         to = -1;
 615         i++;
 616     } else {
 617         i = parseInt(buf, i, &from);
 618         if(i < 0) return -1;
 619         if(buf[i] != '-') return -1;
 620         i++;
 621         i = parseInt(buf, i, &to);
 622         if(i < 0) return -1;
 623         to = to + 1;
 624     }
 625     if(buf[i] != '/')
 626         return -1;
 627     i++;
 628     if(buf[i] == '*')
 629         full_len = -1;
 630     else {
 631         i = parseInt(buf, i, &full_len);
 632         if(i < 0) return -1;
 633     }
 634     j = skipEol(buf, i);
 635     if(j < 0)
 636         return -1;
 637
 638     *from_return = from;
 639     *to_return = to;
 640     *full_len_return = full_len;
 641     return i;
 642 }
 643
 644 static int
 645 parseRange(const char *restrict buf, int i,
 646            int *from_return, int *to_return)
 647 {
 648     int j;
 649     int from, to;
 650
 651     i = skipWhitespace(buf, i);
 652     if(i < 0)
 653         return -1;
 654     if(!token_compare(buf, i, i + 6, "bytes="))
 655         return -1;
 656     i += 6;
 657     i = skipWhitespace(buf, i);
 658     if(buf[i] == '-') {
 659         from = 0;
 660     } else {
 661         i = parseInt(buf, i, &from);
 662         if(i < 0) return -1;
 663     }
 664     if(buf[i] != '-')
 665         return -1;
 666     i++;
 667     j = parseInt(buf, i, &to);
 668     if(j < 0)
 669         to = -1;
 670     else {
 671         to = to + 1;
 672         i = j;
 673     }
 674     j = skipEol(buf, i);
 675     if(j < 0) return -1;
 676     *from_return = from;
 677     *to_return = to;
 678     return i;
 679 }
 680
 681 static int
 682 urlSameHost(const char *url1, int len1, const char *url2, int len2)
 683 {
 684     int i;
 685     if(len1 < 7 || len2 < 7)
 686         return 0;
 687     if(memcmp(url1 + 4, "://", 3) != 0 || memcmp(url2 + 4, "://", 3) != 0)
 688         return 0;
 689
 690     i = 7;
 691     while(i < len1 && i < len2 && url1[i] != '/' && url2[i] != '/') {
 692         if((url1[i] | 0x20) != (url2[i] | 0x20))
 693             break;
 694         i++;
 695     }
 696
 697     if((i == len1 || url1[i] == '/') && ((i == len2 || url2[i] == '/')))
 698         return 1;
 699     return 0;
 700 }
 701
 702 static char *
 703 resize_hbuf(char *hbuf, int *size, char *hbuf_small)
 704 {
 705     int new_size = 2 * *size;
 706     char *new_hbuf;
 707
 708     if(new_size <= *size)
 709         goto fail;
 710
 711     if(hbuf == hbuf_small) {
 712         new_hbuf = malloc(new_size);
 713         if(new_hbuf == NULL) goto fail;
 714         memcpy(new_hbuf, hbuf, *size);
 715     } else {
 716         new_hbuf = realloc(hbuf, new_size);
 717         if(new_hbuf == NULL) goto fail;
 718     }
 719     *size = new_size;
 720     return new_hbuf;
 721
 722  fail:
 723     if(hbuf != hbuf_small)
 724         free(hbuf);
 725     *size = 0;
 726     return NULL;
 727 }
 728
 729 int
 730 httpParseHeaders(int client, AtomPtr url,
 731                  const char *buf, int start, HTTPRequestPtr request,
 732                  AtomPtr *headers_return,
 733                  int *len_return, CacheControlPtr cache_control_return,
 734                  HTTPConditionPtr *condition_return, int *te_return,
 735                  time_t *date_return, time_t *last_modified_return,
 736                  time_t *expires_return, time_t *polipo_age_return,
 737                  time_t *polipo_access_return, int *polipo_body_offset_return,
 738                  int *age_return, char **etag_return, AtomPtr *expect_return,
 739                  HTTPRangePtr range_return, HTTPRangePtr content_range_return,
 740                  char **location_return, AtomPtr *via_return,
 741                  AtomPtr *auth_return)
 742 {
 743     int local = url ? urlIsLocal(url->string, url->length) : 0;
 744     char hbuf_small[512];
 745     char *hbuf = hbuf_small;
 746     int hbuf_size = 512, hbuf_length = 0;
 747     int i, j,
 748         name_start, name_end, value_start, value_end,
 749         token_start, token_end, end;
 750     AtomPtr name = NULL;
 751     time_t date = -1, last_modified = -1, expires = -1, polipo_age = -1,
 752         polipo_access = -1, polipo_body_offset = -1;
 753     int len = -1;
 754     CacheControlRec cache_control;
 755     char *endptr;
 756     int te = TE_IDENTITY;
 757     int age = -1;
 758     char *etag = NULL, *ifrange = NULL;
 759     int persistent = (!request || (request->connection->version != HTTP_10));
 760     char *location = NULL;
 761     AtomPtr via = NULL;
 762     AtomPtr auth = NULL;
 763     AtomPtr expect = NULL;
 764     HTTPConditionPtr condition;
 765     time_t ims = -1, inms = -1;
 766     char *im = NULL, *inm = NULL;
 767     AtomListPtr hopToHop = NULL;
 768     HTTPRangeRec range = {-1, -1, -1}, content_range = {-1, -1, -1};
 769     int haveCacheControl = 0;
 770
 771 #define RESIZE_HBUF() \
 772     do { \
 773         hbuf = resize_hbuf(hbuf, &hbuf_size, hbuf_small); \
 774         if(hbuf == NULL) \
 775             goto fail; \
 776     } while(0)
 777
 778     cache_control.flags = 0;
 779     cache_control.max_age = -1;
 780     cache_control.s_maxage = -1;
 781     cache_control.min_fresh = -1;
 782     cache_control.max_stale = -1;
 783
 784     i = start;
 785
 786     while(1) {
 787         i = parseHeaderLine(buf, i,
 788                             &name_start, &name_end, &value_start, &value_end);
 789         if(i < 0) {
 790             do_log(L_ERROR, "Couldn't find end of header line.\n");
 791             goto fail;
 792         }
 793
 794         if(name_start == -1)
 795             break;
 796
 797         if(name_start < 0)
 798             continue;
 799
 800         name = internAtomLowerN(buf + name_start, name_end - name_start);
 801
 802         if(name == atomConnection) {
 803             j = getNextTokenInList(buf, value_start,
 804                                    &token_start, &token_end, NULL, NULL,
 805                                    &end);
 806             while(1) {
 807                 if(j < 0) {
 808                     do_log(L_ERROR, "Couldn't parse Connection: ");
 809                     do_log_n(L_ERROR, buf + value_start,
 810                              value_end - value_start);
 811                     do_log(L_ERROR, ".\n");
 812                     goto fail;
 813                 }
 814                 if(token_compare(buf, token_start, token_end, "close")) {
 815                     persistent = 0;
 816                 } else if(token_compare(buf, token_start, token_end,
 817                                         "keep-alive")) {
 818                     persistent = 1;
 819                 } else {
 820                     if(hopToHop == NULL)
 821                         hopToHop = makeAtomList(NULL, 0);
 822                     if(hopToHop == NULL) {
 823                         do_log(L_ERROR, "Couldn't allocate atom list.\n");
 824                         goto fail;
 825                     }
 826                     atomListCons(internAtomLowerN(buf + token_start,
 827                                                   token_end - token_start),
 828                                  hopToHop);
 829                 }
 830                 if(end)
 831                     break;
 832                 j = getNextTokenInList(buf, j,
 833                                        &token_start, &token_end, NULL, NULL,
 834                                        &end);
 835             }
 836         } else if(name == atomCacheControl)
 837             haveCacheControl = 1;
 838
 839         releaseAtom(name);
 840         name = NULL;
 841     }
 842
 843     i = start;
 844
 845     while(1) {
 846         i = parseHeaderLine(buf, i,
 847                             &name_start, &name_end, &value_start, &value_end);
 848         if(i < 0) {
 849             do_log(L_ERROR, "Couldn't find end of header line.\n");
 850             goto fail;
 851         }
 852
 853         if(name_start == -1)
 854             break;
 855
 856         if(name_start < 0) {
 857             do_log(L_WARN, "Couldn't parse header line.\n");
 858             if(laxHttpParser)
 859                 continue;
 860             else
 861                 goto fail;
 862         }
 863
 864         name = internAtomLowerN(buf + name_start, name_end - name_start);
 865
 866         if(name == atomProxyConnection) {
 867             j = getNextTokenInList(buf, value_start,
 868                                    &token_start, &token_end, NULL, NULL,
 869                                    &end);
 870             while(1) {
 871                 if(j < 0) {
 872                     do_log(L_WARN, "Couldn't parse Proxy-Connection:");
 873                     do_log_n(L_WARN, buf + value_start,
 874                              value_end - value_start);
 875                     do_log(L_WARN, ".\n");
 876                     persistent = 0;
 877                     break;
 878                 }
 879                 if(token_compare(buf, token_start, token_end, "close")) {
 880                     persistent = 0;
 881                 } else if(token_compare(buf, token_start, token_end,
 882                                         "keep-alive")) {
 883                     persistent = 1;
 884                 }
 885                 if(end)
 886                     break;
 887                 j = getNextTokenInList(buf, j,
 888                                        &token_start, &token_end, NULL, NULL,
 889                                        &end);
 890             }
 891         } else if(name == atomContentLength) {
 892             j = skipWhitespace(buf, value_start);
 893             if(j < 0) {
 894                 do_log(L_WARN, "Couldn't parse Content-Length: \n");
 895                 do_log_n(L_WARN, buf + value_start, value_end - value_start);
 896                 do_log(L_WARN, ".\n");
 897                 len = -1;
 898             } else {
 899                 len = strtol(buf + value_start, &endptr, 10);
 900                 if(endptr <= buf + value_start) {
 901                     do_log(L_WARN, "Couldn't parse Content-Length: \n");
 902                     do_log_n(L_WARN, buf + value_start,
 903                              value_end - value_start);
 904                     do_log(L_WARN, ".\n");
 905                     len = -1;
 906                 }
 907             }
 908         } else if((!local && name == atomProxyAuthorization) ||
 909                   (local && name == atomAuthorization)) {
 910             if(auth_return) {
 911                 auth = internAtomN(buf + value_start, value_end - value_start);
 912                 if(auth == NULL) {
 913                     do_log(L_ERROR, "Couldn't allocate authorization.\n");
 914                     goto fail;
 915                 }
 916             }
 917         } else if(name == atomReferer) {
 918             int h;
 919             if(censorReferer == 0 ||
 920                (censorReferer == 1 && url != NULL &&
 921                 urlSameHost(url->string, url->length,
 922                             buf + value_start, value_end - value_start))) {
 923                 while(hbuf_length > hbuf_size - 2)
 924                     RESIZE_HBUF();
 925                 hbuf[hbuf_length++] = '\r';
 926                 hbuf[hbuf_length++] = '\n';
 927                 do {
 928                     h = snnprint_n(hbuf, hbuf_length, hbuf_size,
 929                                    buf + name_start, value_end - name_start);
 930                     if(h < 0) RESIZE_HBUF();
 931                 } while(h < 0);
 932                 hbuf_length = h;
 933             }
 934         } else if(name == atomTrailer || name == atomUpgrade) {
 935             do_log(L_ERROR, "Trailers or upgrade present.\n");
 936             goto fail;
 937         } else if(name == atomDate || name == atomExpires ||
 938                   name == atomIfModifiedSince ||
 939                   name == atomIfUnmodifiedSince ||
 940                   name == atomLastModified ||
 941                   name == atomXPolipoDate || name == atomXPolipoAccess) {
 942             time_t t;
 943             j = parse_time(buf, value_start, value_end, &t);
 944             if(j < 0) {
 945                 if(name != atomExpires) {
 946                     do_log(L_WARN, "Couldn't parse %s: ", name->string);
 947                     do_log_n(L_WARN, buf + value_start,
 948                              value_end - value_start);
 949                     do_log(L_WARN, "\n");
 950                 }
 951                 t = -1;
 952             }
 953             if(name == atomDate) {
 954                 if(t >= 0)
 955                     date = t;
 956             } else if(name == atomExpires) {
 957                 if(t >= 0)
 958                     expires = t;
 959                 else
 960                     expires = 0;
 961             } else if(name == atomLastModified)
 962                 last_modified = t;
 963             else if(name == atomIfModifiedSince)
 964                 ims = t;
 965             else if(name == atomIfUnmodifiedSince)
 966                 inms = t;
 967             else if(name == atomXPolipoDate)
 968                 polipo_age = t;
 969             else if(name == atomXPolipoAccess)
 970                 polipo_access = t;
 971         } else if(name == atomAge) {
 972             j = skipWhitespace(buf, value_start);
 973             if(j < 0) {
 974                 age = -1;
 975             } else {
 976                 age = strtol(buf + value_start, &endptr, 10);
 977                 if(endptr <= buf + value_start)
 978                     age = -1;
 979             }
 980             if(age < 0) {
 981                 do_log(L_WARN, "Couldn't parse age: \n");
 982                 do_log_n(L_WARN, buf + value_start, value_end - value_start);
 983                 do_log(L_WARN, " -- ignored.\n");
 984             }
 985         } else if(name == atomXPolipoBodyOffset) {
 986             j = skipWhitespace(buf, value_start);
 987             if(j < 0) {
 988                 do_log(L_ERROR, "Couldn't parse body offset.\n");
 989                 goto fail;
 990             } else {
 991                 polipo_body_offset = strtol(buf + value_start, &endptr, 10);
 992                 if(endptr <= buf + value_start) {
 993                     do_log(L_ERROR, "Couldn't parse body offset.\n");
 994                     goto fail;
 995                 }
 996             }
 997         } else if(name == atomTransferEncoding) {
 998             if(token_compare(buf, value_start, value_end, "identity"))
 999                 te = TE_IDENTITY;
1000             else if(token_compare(buf, value_start, value_end, "chunked"))
1001                 te = TE_CHUNKED;
1002             else
1003                 te = TE_UNKNOWN;
1004         } else if(name == atomETag ||
1005                   name == atomIfNoneMatch || name == atomIfMatch ||
1006                   name == atomIfRange) {
1007             int x, y;
1008             int weak;
1009             char *e;
1010             j = getNextETag(buf, value_start, &x, &y, &weak);
1011             if(j < 0) {
1012                 if(buf[value_start] != '\r' && buf[value_start] != '\n')
1013                     do_log(L_ERROR, "Couldn't parse ETag.\n");
1014             } else if(weak) {
1015                 do_log(L_WARN, "Server returned weak ETag -- ignored.\n");
1016             } else {
1017                 e = strdup_n(buf + x, y - x);
1018                 if(e == NULL) goto fail;
1019                 if(name == atomETag) {
1020                     if(!etag)
1021                         etag = e;
1022                     else
1023                         free(e);
1024                 } else if(name == atomIfNoneMatch) {
1025                     if(!inm)
1026                         inm = e;
1027                     else
1028                         free(e);
1029                 } else if(name == atomIfMatch) {
1030                     if(!im)
1031                         im = e;
1032                     else
1033                         free(e);
1034                 } else if(name == atomIfRange) {
1035                     if(!ifrange)
1036                         ifrange = e;
1037                     else
1038                         free(e);
1039                 } else {
1040                     abort();
1041                 }
1042             }
1043         } else if(name == atomCacheControl) {
1044             int v_start, v_end;
1045             j = getNextTokenInList(buf, value_start,
1046                                    &token_start, &token_end,
1047                                    &v_start, &v_end,
1048                                    &end);
1049             while(1) {
1050                 if(j < 0) {
1051                     do_log(L_WARN, "Couldn't parse Cache-Control.\n");
1052                     cache_control.flags |= CACHE_NO;
1053                     break;
1054                 }
1055                 if(token_compare(buf, token_start, token_end, "no-cache")) {
1056                     cache_control.flags |= CACHE_NO;
1057                 } else if(token_compare(buf, token_start, token_end,
1058                                         "public")) {
1059                     cache_control.flags |= CACHE_PUBLIC;
1060                 } else if(token_compare(buf, token_start, token_end,
1061                                         "private")) {
1062                     cache_control.flags |= CACHE_PRIVATE;
1063                 } else if(token_compare(buf, token_start, token_end,
1064                                         "no-store")) {
1065                     cache_control.flags |= CACHE_NO_STORE;
1066                 } else if(token_compare(buf, token_start, token_end,
1067                                         "no-transform")) {
1068                     cache_control.flags |= CACHE_NO_TRANSFORM;
1069                 } else if(token_compare(buf, token_start, token_end,
1070                                         "must-revalidate") ||
1071                           token_compare(buf, token_start, token_end,
1072                                         "must-validate")) { /* losers */
1073                     cache_control.flags |= CACHE_MUST_REVALIDATE;
1074                 } else if(token_compare(buf, token_start, token_end,
1075                                         "proxy-revalidate")) {
1076                     cache_control.flags |= CACHE_PROXY_REVALIDATE;
1077                 } else if(token_compare(buf, token_start, token_end,
1078                                         "only-if-cached")) {
1079                     cache_control.flags |= CACHE_ONLY_IF_CACHED;
1080                 } else if(token_compare(buf, token_start, token_end,
1081                                         "max-age") ||
1082                           token_compare(buf, token_start, token_end,
1083                                         "maxage")) { /* losers */
1084                     int a;
1085                     if(v_start <= 0 || !digit(buf[v_start])) {
1086                         do_log(L_WARN, "Couldn't parse Cache-Control: ");
1087                         do_log_n(L_WARN, buf + token_start,
1088                                  (v_end >= 0 ? v_end : token_end) -
1089                                  token_start);
1090                         do_log(L_WARN, "\n");
1091                     }
1092                     a = atoi(buf + v_start);
1093                     cache_control.max_age = a;
1094                 } else if(token_compare(buf, token_start, token_end,
1095                                         "s-maxage")) {
1096                     int a;
1097                     if(v_start <= 0 || !digit(buf[v_start])) {
1098                         do_log(L_WARN, "Couldn't parse Cache-Control: ");
1099                         do_log_n(L_WARN, buf + token_start,
1100                                  (v_end >= 0 ? v_end : token_end) -
1101                                  token_start);
1102                         do_log(L_WARN, "\n");
1103                     }
1104                     a = atoi(buf + v_start);
1105                     cache_control.max_age = a;
1106                 } else if(token_compare(buf, token_start, token_end,
1107                                         "min-fresh")) {
1108                     int a;
1109                     if(v_start <= 0 || !digit(buf[v_start])) {
1110                         do_log(L_WARN, "Couldn't parse Cache-Control: ");
1111                         do_log_n(L_WARN, buf + token_start,
1112                                  (v_end >= 0 ? v_end : token_end) -
1113                                  token_start);
1114                         do_log(L_WARN, "\n");
1115                     }
1116                     a = atoi(buf + v_start);
1117                     cache_control.max_age = a;
1118                 } else if(token_compare(buf, token_start, token_end,
1119                                         "max-stale")) {
1120                     int a;
1121                     if(v_start <= 0 || !digit(buf[v_start])) {
1122                         do_log(L_WARN, "Couldn't parse Cache-Control: ");
1123                         do_log_n(L_WARN, buf + token_start,
1124                                  (v_end >= 0 ? v_end : token_end) -
1125                                  token_start);
1126                         do_log(L_WARN, "\n");
1127                     }
1128                     a = atoi(buf + v_start);
1129                     cache_control.max_stale = a;
1130                 } else {
1131                     do_log(L_WARN, "Unsupported Cache-Control directive ");
1132                     do_log_n(L_WARN, buf + token_start,
1133                              (v_end >= 0 ? v_end : token_end) - token_start);
1134                     do_log(L_WARN, " -- ignored.\n");
1135                 }
1136                 if(end)
1137                     break;
1138                 j = getNextTokenInList(buf, j,
1139                                        &token_start, &token_end,
1140                                        &v_start, &v_end,
1141                                        &end);
1142             }
1143         } else if(name == atomContentRange) {
1144             if(!client) {
1145                 j = parseContentRange(buf, value_start,
1146                                       &content_range.from, &content_range.to,
1147                                       &content_range.full_length);
1148                 if(j < 0) {
1149                     do_log(L_ERROR, "Couldn't parse Content-Range: ");
1150                     do_log_n(L_ERROR, buf + value_start,
1151                              value_end - value_start);
1152                     do_log(L_ERROR, "\n");
1153                     goto fail;
1154                 }
1155             } else {
1156                 do_log(L_ERROR, "Content-Range from client.\n");
1157                 goto fail;
1158             }
1159         } else if(name == atomRange) {
1160             if(client) {
1161                 j = parseRange(buf, value_start, &range.from, &range.to);
1162                 if(j < 0) {
1163                     do_log(L_WARN, "Couldn't parse Range -- ignored.\n");
1164                     range.from = -1;
1165                     range.to = -1;
1166                 }
1167             } else {
1168                 do_log(L_WARN, "Range from server -- ignored\n");
1169             }
1170         } else if(name == atomXPolipoLocation) {
1171             if(location_return) {
1172                 location =
1173                     strdup_n(buf + value_start, value_end - value_start);
1174                 if(location == NULL) {
1175                     do_log(L_ERROR, "Couldn't allocate location.\n");
1176                     goto fail;
1177                 }
1178             }
1179         } else if(name == atomVia) {
1180             if(via_return) {
1181                 AtomPtr new_via, full_via;
1182                 new_via =
1183                     internAtomN(buf + value_start, value_end - value_start);
1184                 if(new_via == NULL) {
1185                     do_log(L_ERROR, "Couldn't allocate via.\n");
1186                     goto fail;
1187                 }
1188                 if(via) {
1189                     full_via =
1190                         internAtomF("%s, %s", via->string, new_via->string);
1191                     releaseAtom(new_via);
1192                     if(full_via == NULL) {
1193                         do_log(L_ERROR, "Couldn't allocate via");
1194                         goto fail;
1195                     }
1196                     releaseAtom(via);
1197                     via = full_via;
1198                 } else {
1199                     via = new_via;
1200                 }
1201             }
1202         } else if(name == atomExpect) {
1203             if(expect_return) {
1204                 expect = internAtomLowerN(buf + value_start,
1205                                           value_end - value_start);
1206                 if(expect == NULL) {
1207                     do_log(L_ERROR, "Couldn't allocate expect.\n");
1208                     goto fail;
1209                 }
1210             }
1211         } else {
1212             if(!client && name == atomContentType) {
1213                 if(token_compare(buf, value_start, value_end,
1214                                  "multipart/byteranges")) {
1215                     do_log(L_ERROR,
1216                            "Server returned multipart/byteranges -- yuck!\n");
1217                     goto fail;
1218                 }
1219             }
1220             if(name == atomVary) {
1221                 if(!token_compare(buf, value_start, value_end, "host") &&
1222                    !token_compare(buf, value_start, value_end, "*")) {
1223                     /* What other vary headers should be ignored? */
1224                     do_log(L_VARY, "Vary header present (");
1225                     do_log_n(L_VARY,
1226                              buf + value_start, value_end - value_start);
1227                     do_log(L_VARY, ").\n");
1228                 }
1229                 cache_control.flags |= CACHE_VARY;
1230             } else if(name == atomAuthorization) {
1231                 cache_control.flags |= CACHE_AUTHORIZATION;
1232             }
1233
1234             if(name == atomPragma) {
1235                 /* Pragma is only defined for the client, and the only
1236                    standard value is no-cache (RFC 1945, 10.12).
1237                    However, we honour a Pragma: no-cache for both the client
1238                    and the server when there's no Cache-Control header.  In
1239                    all cases, we pass the Pragma header to the next hop. */
1240                 if(!haveCacheControl) {
1241                     j = getNextTokenInList(buf, value_start,
1242                                            &token_start, &token_end, NULL, NULL,
1243                                            &end);
1244                     while(1) {
1245                         if(j < 0) {
1246                             do_log(L_WARN, "Couldn't parse Pragma.\n");
1247                             cache_control.flags |= CACHE_NO;
1248                             break;
1249                         }
1250                         if(token_compare(buf, token_start, token_end,
1251                                          "no-cache"))
1252                             cache_control.flags = CACHE_NO;
1253                         if(end)
1254                             break;
1255                         j = getNextTokenInList(buf, j, &token_start, &token_end,
1256                                                NULL, NULL, &end);
1257                     }
1258                 }
1259             }
1260             if(!client &&
1261                (name == atomSetCookie ||
1262                 name == atomCookie || name == atomCookie2))
1263                 cache_control.flags |= CACHE_COOKIE;
1264
1265             if(hbuf) {
1266                 if(name != atomConnection && name != atomHost &&
1267                    name != atomAcceptRange && name != atomTE &&
1268                    name != atomProxyAuthenticate &&
1269                    name != atomKeepAlive &&
1270                    (!hopToHop || !atomListMember(name, hopToHop)) &&
1271                    !atomListMember(name, censoredHeaders)) {
1272                     int h;
1273                     while(hbuf_length > hbuf_size - 2)
1274                         RESIZE_HBUF();
1275                     hbuf[hbuf_length++] = '\r';
1276                     hbuf[hbuf_length++] = '\n';
1277                     do {
1278                         h = snnprint_n(hbuf, hbuf_length, hbuf_size,
1279                                        buf + name_start,
1280                                        value_end - name_start);
1281                         if(h < 0) RESIZE_HBUF();
1282                     } while(h < 0);
1283                     hbuf_length = h;
1284                 }
1285             }
1286         }
1287         releaseAtom(name);
1288         name = NULL;
1289     }
1290
1291     if(headers_return) {
1292         AtomPtr pheaders = NULL;
1293         pheaders = internAtomN(hbuf, hbuf_length);
1294         if(!pheaders)
1295             goto fail;
1296         *headers_return = pheaders;
1297     }
1298     if(hbuf != hbuf_small)
1299         free(hbuf);
1300     hbuf = NULL;
1301     hbuf_size = 0;
1302
1303     if(request)
1304         if(!persistent)
1305             request->flags &= ~REQUEST_PERSISTENT;
1306
1307     if(te != TE_IDENTITY) len = -1;
1308     if(len_return) *len_return = len;
1309     if(cache_control_return) *cache_control_return = cache_control;
1310     if(condition_return) {
1311         if(ims >= 0 || inms >= 0 || im || inm || ifrange) {
1312             condition = httpMakeCondition();
1313             if(condition) {
1314                 condition->ims = ims;
1315                 condition->inms = inms;
1316                 condition->im = im;
1317                 condition->inm = inm;
1318                 condition->ifrange = ifrange;
1319             } else {
1320                 do_log(L_ERROR, "Couldn't allocate condition.\n");
1321                 if(im) free(im);
1322                 if(inm) free(inm);
1323             }
1324         } else {
1325             condition = NULL;
1326         }
1327         *condition_return = condition;
1328     } else {
1329         assert(!im && !inm);
1330     }
1331
1332     if(te_return) *te_return = te;
1333     if(date_return) *date_return = date;
1334     if(last_modified_return) *last_modified_return = last_modified;
1335     if(expires_return) *expires_return = expires;
1336     if(polipo_age_return) *polipo_age_return = polipo_age;
1337     if(polipo_access_return) *polipo_access_return = polipo_access;
1338     if(polipo_body_offset_return)
1339         *polipo_body_offset_return = polipo_body_offset;
1340     if(age_return) *age_return = age;
1341     if(etag_return)
1342         *etag_return = etag;
1343     else {
1344         if(etag) free(etag);
1345     }
1346     if(range_return) *range_return = range;
1347     if(content_range_return) *content_range_return = content_range;
1348     if(location_return) {
1349         *location_return = location;
1350     } else {
1351         if(location)
1352             free(location);
1353     }
1354     if(via_return)
1355         *via_return = via;
1356     else {
1357         if(via)
1358             releaseAtom(via);
1359     }
1360     if(expect_return)
1361         *expect_return = expect;
1362     else {
1363         if(expect)
1364             releaseAtom(expect);
1365     }
1366     if(auth_return)
1367         *auth_return = auth;
1368     else {
1369         if(auth)
1370             releaseAtom(auth);
1371     }
1372     if(hopToHop) destroyAtomList(hopToHop);
1373     return i;
1374
1375  fail:
1376     if(hbuf && hbuf != hbuf_small) free(hbuf);
1377     if(name) releaseAtom(name);
1378     if(etag) free(etag);
1379     if(location) free(location);
1380     if(via) releaseAtom(via);
1381     if(expect) releaseAtom(expect);
1382     if(auth) releaseAtom(auth);
1383     if(hopToHop) destroyAtomList(hopToHop);
1384
1385     return -1;
1386 #undef RESIZE_HBUF
1387 }
1388
1389 int
1390 httpFindHeader(AtomPtr header, const char *headers, int hlen,
1391                int *value_begin_return, int *value_end_return)
1392 {
1393     int len = header->length;
1394     int i = 0;
1395
1396     while(i + len + 1 < hlen) {
1397         if(headers[i + len] == ':' &&
1398            lwrcmp(headers + i, header->string, len) == 0) {
1399             int j = i + len + 1, k;
1400             while(j < hlen && headers[j] == ' ')
1401                 j++;
1402             k = j;
1403             while(k < hlen && headers[k] != '\n' && headers[k] != '\r')
1404                 k++;
1405             *value_begin_return = j;
1406             *value_end_return = k;
1407             return 1;
1408         } else {
1409             while(i < hlen && headers[i] != '\n' && headers[i] != '\r')
1410                 i++;
1411             i++;
1412             if(i < hlen && headers[i] == '\n')
1413                 i++;
1414         }
1415     }
1416     return 0;
1417 }
1418
1419 int
1420 parseUrl(const char *url, int len,
1421          int *x_return, int *y_return, int *port_return, int *z_return)
1422 {
1423     int x, y, z, port = -1, i = 0;
1424
1425     if(len >= 7 && lwrcmp(url, "http://", 7) == 0) {
1426         x = 7;
1427         if(x < len && url[x] == '[') {
1428             /* RFC 2732 */
1429             for(i = x + 1; i < len; i++) {
1430                 if(url[i] == ']') {
1431                     i++;
1432                     break;
1433                 }
1434                 if((url[i] != ':') && !letter(url[i]) && !digit(url[i]))
1435                     break;
1436             }
1437         } else {
1438             for(i = x; i < len; i++)
1439                 if(url[i] == ':' || url[i] == '/')
1440                     break;
1441         }
1442         y = i;
1443
1444         if(i < len && url[i] == ':') {
1445             int j;
1446             j = atoi_n(url, i + 1, len, &port);
1447             if(j < 0) {
1448                 port = 80;
1449             } else {
1450                     i = j;
1451             }
1452         } else {
1453             port = 80;
1454         }
1455     } else {
1456         x = -1;
1457         y = -1;
1458     }
1459
1460     z = i;
1461
1462     *x_return = x;
1463     *y_return = y;
1464     *port_return = port;
1465     *z_return = z;
1466     return 0;
1467 }
1468
1469 int
1470 urlIsLocal(const char *url, int len)
1471 {
1472     return (len > 0 && url[0] == '/');
1473 }
1474
1475 int
1476 urlIsSpecial(const char *url, int len)
1477 {
1478     return (len >= 8 && memcmp(url, "/polipo/", 8) == 0);
1479 }
1480
1481 int
1482 parseChunkSize(const char *restrict buf, int i, int end,
1483                int *chunk_size_return)
1484 {
1485     int v, d;
1486     v = h2i(buf[i]);
1487     if(v < 0)
1488         return -1;
1489
1490     i++;
1491
1492     while(i < end) {
1493         d = h2i(buf[i]);
1494         if(d < 0)
1495             break;
1496         v = v * 16 + d;
1497         i++;
1498     }
1499
1500     while(i < end) {
1501         if(buf[i] == ' ' || buf[i] == '\t')
1502             i++;
1503         else
1504             break;
1505     }
1506
1507     if(i >= end - 1)
1508         return 0;
1509
1510     if(buf[i] != '\r' || buf[i + 1] != '\n')
1511         return -1;
1512
1513     i += 2;
1514
1515     if(v == 0) {
1516         if(i >= end - 1)
1517             return 0;
1518         if(buf[i] != '\r') {
1519             do_log(L_ERROR, "Trailers present!\n");
1520             return -1;
1521         }
1522         i++;
1523         if(buf[i] != '\n')
1524             return -1;
1525         i++;
1526     }
1527
1528     *chunk_size_return = v;
1529     return i;
1530 }
1531
1532
1533 int
1534 checkVia(AtomPtr name, AtomPtr via)
1535 {
1536     int i;
1537     char *v;
1538     if(via == NULL || via->length == 0)
1539         return 1;
1540
1541     v = via->string;
1542
1543     i = 0;
1544     while(i < via->length) {
1545         while(v[i] == ' ' || v[i] == '\t' || v[i] == ',' ||
1546               v[i] == '\r' || v[i] == '\n' ||
1547               digit(v[i]) || v[i] == '.')
1548             i++;
1549         if(i + name->length > via->length)
1550             break;
1551         if(memcmp(v + i, name->string, name->length) == 0) {
1552             char c = v[i + name->length];
1553             if(c == '\0' || c == ' ' || c == '\t' || c == ',' ||
1554                c == '\r' || c == '\n')
1555                 return 0;
1556         }
1557         i++;
1558         while(letter(v[i]) || digit(v[i]) || v[i] == '.')
1559             i++;
1560     }
1561     return 1;
1562 }