?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Rewrite memrchr to avoid an unsigned integer underflow.
[polipo.git] / http_parse.c
blob63dca7e7393de1c78da1aa2b1ebeeb926a7f3063
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 /* Returned *name_start_return is -1 at end of headers, -2 if the line
500 couldn't be parsed. */
501 static int
502 parseHeaderLine(const char *restrict buf, int start,
503 int *name_start_return, int *name_end_return,
504 int *value_start_return, int *value_end_return)
505 {
506 int i;
507 int name_start, name_end, value_start, value_end;
508
509 if(buf[start] == '\n') {
510 *name_start_return = -1;
511 return start + 1;
512 }
513 if(buf[start] == '\r' && buf[start + 1] == '\n') {
514 *name_start_return = -1;
515 return start + 2;
516 }
517
518 i = getNextToken(buf, start, &name_start, &name_end);
519 if(i < 0 || buf[i] != ':')
520 goto syntax;
521 i++;
522 while(buf[i] == ' ' || buf[i] == '\t')
523 i++;
524
525 i = getHeaderValue(buf, i, &value_start, &value_end);
526 if(i < 0)
527 goto syntax;
528
529 *name_start_return = name_start;
530 *name_end_return = name_end;
531 *value_start_return = value_start;
532 *value_end_return = value_end;
533 return i;
534
535 syntax:
536 i = start;
537 while(1) {
538 if(buf[i] == '\n') {
539 i++;
540 break;
541 }
542 if(buf[i] == '\r' && buf[i + 1] == '\n') {
543 i += 2;
544 break;
545 }
546 i++;
547 }
548 *name_start_return = -2;
549 return i;
550 }
551
552 int
553 findEndOfHeaders(const char *restrict buf, int from, int to, int *body_return)
554 {
555 int i = from;
556 int eol = 0;
557 while(i < to) {
558 if(buf[i] == '\n') {
559 if(eol) {
560 *body_return = i + 1;
561 return eol;
562 }
563 eol = i;
564 i++;
565 } else if(buf[i] == '\r') {
566 if(i < to - 1 && buf[i + 1] == '\n') {
567 if(eol) {
568 *body_return = eol;
569 return i + 2;
570 }
571 eol = i;
572 i += 2;
573 } else {
574 eol = 0;
575 i++;
576 }
577 } else {
578 eol = 0;
579 i++;
580 }
581 }
582 return -1;
583 }
584
585 static int
586 parseContentRange(const char *restrict buf, int i,
587 int *from_return, int *to_return, int *full_len_return)
588 {
589 int j;
590 int from, to, full_len;
591
592 i = skipWhitespace(buf, i);
593 if(i < 0) return -1;
594 if(!token_compare(buf, i, i + 5, "bytes")) {
595 do_log(L_WARN, "Incorrect Content-Range header -- chugging along.\n");
596 } else {
597 i += 5;
598 }
599 i = skipWhitespace(buf, i);
600 if(buf[i] == '*') {
601 from = 0;
602 to = -1;
603 i++;
604 } else {
605 i = parseInt(buf, i, 0, INT_MAX, 10, &from);
606 if(i < 0) return -1;
607 if(buf[i] != '-') return -1;
608 i++;
609 i = parseInt(buf, i, 0, INT_MAX, 10, &to);
610 if(i < 0) return -1;
611 to = to + 1;
612 }
613 if(buf[i] != '/')
614 return -1;
615 i++;
616 if(buf[i] == '*')
617 full_len = -1;
618 else {
619 i = parseInt(buf, i, 0, INT_MAX, 10, &full_len);
620 if(i < 0) return -1;
621 }
622 j = skipEol(buf, i);
623 if(j < 0)
624 return -1;
625
626 *from_return = from;
627 *to_return = to;
628 *full_len_return = full_len;
629 return i;
630 }
631
632 static int
633 parseRange(const char *restrict buf, int i,
634 int *from_return, int *to_return)
635 {
636 int j;
637 int from, to;
638
639 i = skipWhitespace(buf, i);
640 if(i < 0)
641 return -1;
642 if(!token_compare(buf, i, i + 6, "bytes="))
643 return -1;
644 i += 6;
645 i = skipWhitespace(buf, i);
646 if(buf[i] == '-') {
647 from = 0;
648 } else {
649 i = parseInt(buf, i, 0, INT_MAX, 10, &from);
650 if(i < 0) return -1;
651 }
652 if(buf[i] != '-')
653 return -1;
654 i++;
655 j = parseInt(buf, i, 0, INT_MAX, 10, &to);
656 if(j < 0)
657 to = -1;
658 else {
659 to = to + 1;
660 i = j;
661 }
662 j = skipEol(buf, i);
663 if(j < 0) return -1;
664 *from_return = from;
665 *to_return = to;
666 return i;
667 }
668
669 static void
670 parseCacheControl(const char *restrict buf,
671 int token_start, int token_end,
672 int v_start, int v_end, int *age_return)
673 {
674 int ret = -1;
675
676 if(v_start > 0)
677 ret = parseInt(buf, v_start, 0, INT_MAX, 10, age_return);
678
679 if(ret < 0) {
680 do_log(L_WARN, "Couldn't parse Cache-Control: ");
681 do_log_n(L_WARN, buf + token_start,
682 (v_end >= 0 ? v_end : token_end) -
683 token_start);
684 do_log(L_WARN, "\n");
685 }
686 }
687
688 static int
689 urlSameHost(const char *url1, int len1, const char *url2, int len2)
690 {
691 int i;
692 if(len1 < 7 || len2 < 7)
693 return 0;
694 if(memcmp(url1 + 4, "://", 3) != 0 || memcmp(url2 + 4, "://", 3) != 0)
695 return 0;
696
697 i = 7;
698 while(i < len1 && i < len2 && url1[i] != '/' && url2[i] != '/') {
699 if((url1[i] | 0x20) != (url2[i] | 0x20))
700 break;
701 i++;
702 }
703
704 if((i == len1 || url1[i] == '/') && ((i == len2 || url2[i] == '/')))
705 return 1;
706 return 0;
707 }
708
709 static char *
710 resize_hbuf(char *hbuf, int *size, char *hbuf_small)
711 {
712 int new_size = 2 * *size;
713 char *new_hbuf;
714
715 if(new_size <= *size)
716 goto fail;
717
718 if(hbuf == hbuf_small) {
719 new_hbuf = malloc(new_size);
720 if(new_hbuf == NULL) goto fail;
721 memcpy(new_hbuf, hbuf, *size);
722 } else {
723 new_hbuf = realloc(hbuf, new_size);
724 if(new_hbuf == NULL) goto fail;
725 }
726 *size = new_size;
727 return new_hbuf;
728
729 fail:
730 if(hbuf != hbuf_small)
731 free(hbuf);
732 *size = 0;
733 return NULL;
734 }
735
736 int
737 httpParseHeaders(int client, AtomPtr url,
738 const char *buf, int start, HTTPRequestPtr request,
739 AtomPtr *headers_return,
740 int *len_return, CacheControlPtr cache_control_return,
741 HTTPConditionPtr *condition_return, int *te_return,
742 time_t *date_return, time_t *last_modified_return,
743 time_t *expires_return, time_t *polipo_age_return,
744 time_t *polipo_access_return, int *polipo_body_offset_return,
745 int *age_return, char **etag_return, AtomPtr *expect_return,
746 HTTPRangePtr range_return, HTTPRangePtr content_range_return,
747 char **location_return, AtomPtr *via_return,
748 AtomPtr *auth_return)
749 {
750 int local = url ? urlIsLocal(url->string, url->length) : 0;
751 char hbuf_small[512];
752 char *hbuf = hbuf_small;
753 int hbuf_size = 512, hbuf_length = 0;
754 int i, j,
755 name_start, name_end, value_start, value_end,
756 token_start, token_end, end;
757 AtomPtr name = NULL;
758 time_t date = -1, last_modified = -1, expires = -1, polipo_age = -1,
759 polipo_access = -1;
760 int len = -1, polipo_body_offset = -1;
761 CacheControlRec cache_control;
762 int te = TE_IDENTITY;
763 int age = -1;
764 char *etag = NULL, *ifrange = NULL;
765 int persistent = (!request || (request->connection->version != HTTP_10));
766 char *location = NULL;
767 AtomPtr via = NULL;
768 AtomPtr auth = NULL;
769 AtomPtr expect = NULL;
770 HTTPConditionPtr condition;
771 time_t ims = -1, inms = -1;
772 char *im = NULL, *inm = NULL;
773 AtomListPtr hopToHop = NULL;
774 HTTPRangeRec range = {-1, -1, -1}, content_range = {-1, -1, -1};
775 int haveCacheControl = 0;
776
777 #define RESIZE_HBUF() \
778 do { \
779 hbuf = resize_hbuf(hbuf, &hbuf_size, hbuf_small); \
780 if(hbuf == NULL) \
781 goto fail; \
782 } while(0)
783
784 cache_control.flags = 0;
785 cache_control.max_age = -1;
786 cache_control.s_maxage = -1;
787 cache_control.min_fresh = -1;
788 cache_control.max_stale = -1;
789
790 i = start;
791
792 while(1) {
793 i = parseHeaderLine(buf, i,
794 &name_start, &name_end, &value_start, &value_end);
795 if(i < 0) {
796 do_log(L_ERROR, "Couldn't find end of header line.\n");
797 goto fail;
798 }
799
800 if(name_start == -1)
801 break;
802
803 if(name_start < 0)
804 continue;
805
806 name = internAtomLowerN(buf + name_start, name_end - name_start);
807
808 if(name == atomConnection) {
809 j = getNextTokenInList(buf, value_start,
810 &token_start, &token_end, NULL, NULL,
811 &end);
812 while(1) {
813 if(j < 0) {
814 do_log(L_ERROR, "Couldn't parse Connection: ");
815 do_log_n(L_ERROR, buf + value_start,
816 value_end - value_start);
817 do_log(L_ERROR, ".\n");
818 goto fail;
819 }
820 if(token_compare(buf, token_start, token_end, "close")) {
821 persistent = 0;
822 } else if(token_compare(buf, token_start, token_end,
823 "keep-alive")) {
824 persistent = 1;
825 } else {
826 if(hopToHop == NULL)
827 hopToHop = makeAtomList(NULL, 0);
828 if(hopToHop == NULL) {
829 do_log(L_ERROR, "Couldn't allocate atom list.\n");
830 goto fail;
831 }
832 atomListCons(internAtomLowerN(buf + token_start,
833 token_end - token_start),
834 hopToHop);
835 }
836 if(end)
837 break;
838 j = getNextTokenInList(buf, j,
839 &token_start, &token_end, NULL, NULL,
840 &end);
841 }
842 } else if(name == atomCacheControl)
843 haveCacheControl = 1;
844
845 releaseAtom(name);
846 name = NULL;
847 }
848
849 i = start;
850
851 while(1) {
852 i = parseHeaderLine(buf, i,
853 &name_start, &name_end, &value_start, &value_end);
854 if(i < 0) {
855 do_log(L_ERROR, "Couldn't find end of header line.\n");
856 goto fail;
857 }
858
859 if(name_start == -1)
860 break;
861
862 if(name_start < 0) {
863 do_log(L_WARN, "Couldn't parse header line.\n");
864 if(laxHttpParser)
865 continue;
866 else
867 goto fail;
868 }
869
870 name = internAtomLowerN(buf + name_start, name_end - name_start);
871
872 if(name == atomProxyConnection) {
873 j = getNextTokenInList(buf, value_start,
874 &token_start, &token_end, NULL, NULL,
875 &end);
876 while(1) {
877 if(j < 0) {
878 do_log(L_WARN, "Couldn't parse Proxy-Connection:");
879 do_log_n(L_WARN, buf + value_start,
880 value_end - value_start);
881 do_log(L_WARN, ".\n");
882 persistent = 0;
883 break;
884 }
885 if(token_compare(buf, token_start, token_end, "close")) {
886 persistent = 0;
887 } else if(token_compare(buf, token_start, token_end,
888 "keep-alive")) {
889 persistent = 1;
890 }
891 if(end)
892 break;
893 j = getNextTokenInList(buf, j,
894 &token_start, &token_end, NULL, NULL,
895 &end);
896 }
897 } else if(name == atomContentLength) {
898 j = skipWhitespace(buf, value_start);
899 if(j < 0) {
900 do_log(L_WARN, "Couldn't parse Content-Length: \n");
901 do_log_n(L_WARN, buf + value_start, value_end - value_start);
902 do_log(L_WARN, ".\n");
903 len = -1;
904 } else {
905 if(parseInt(buf, value_start, 0, INT_MAX, 10, &len) < 0) {
906 do_log(L_WARN, "Couldn't parse Content-Length: \n");
907 do_log_n(L_WARN, buf + value_start,
908 value_end - value_start);
909 do_log(L_WARN, ".\n");
910 len = -1;
911 }
912 }
913 } else if((!local && name == atomProxyAuthorization) ||
914 (local && name == atomAuthorization)) {
915 if(auth_return) {
916 auth = internAtomN(buf + value_start, value_end - value_start);
917 if(auth == NULL) {
918 do_log(L_ERROR, "Couldn't allocate authorization.\n");
919 goto fail;
920 }
921 }
922 } else if(name == atomReferer) {
923 int h;
924 if(censorReferer == 0 ||
925 (censorReferer == 1 && url != NULL &&
926 urlSameHost(url->string, url->length,
927 buf + value_start, value_end - value_start))) {
928 while(hbuf_length > hbuf_size - 2)
929 RESIZE_HBUF();
930 hbuf[hbuf_length++] = '\r';
931 hbuf[hbuf_length++] = '\n';
932 do {
933 h = snnprint_n(hbuf, hbuf_length, hbuf_size,
934 buf + name_start, value_end - name_start);
935 if(h < 0) RESIZE_HBUF();
936 } while(h < 0);
937 hbuf_length = h;
938 }
939 } else if(name == atomTrailer || name == atomUpgrade) {
940 do_log(L_ERROR, "Trailers or upgrade present.\n");
941 goto fail;
942 } else if(name == atomDate || name == atomExpires ||
943 name == atomIfModifiedSince ||
944 name == atomIfUnmodifiedSince ||
945 name == atomLastModified ||
946 name == atomXPolipoDate || name == atomXPolipoAccess) {
947 time_t t;
948 j = parse_time(buf, value_start, value_end, &t);
949 if(j < 0) {
950 if(name != atomExpires) {
951 do_log(L_WARN, "Couldn't parse %s: ", name->string);
952 do_log_n(L_WARN, buf + value_start,
953 value_end - value_start);
954 do_log(L_WARN, "\n");
955 }
956 t = -1;
957 }
958 if(name == atomDate) {
959 if(t >= 0)
960 date = t;
961 } else if(name == atomExpires) {
962 if(t >= 0)
963 expires = t;
964 else
965 expires = 0;
966 } else if(name == atomLastModified)
967 last_modified = t;
968 else if(name == atomIfModifiedSince)
969 ims = t;
970 else if(name == atomIfUnmodifiedSince)
971 inms = t;
972 else if(name == atomXPolipoDate)
973 polipo_age = t;
974 else if(name == atomXPolipoAccess)
975 polipo_access = t;
976 } else if(name == atomAge) {
977 j = skipWhitespace(buf, value_start);
978 if(j < 0) {
979 age = -1;
980 } else {
981 if(parseInt(buf, value_start, 0, INT_MAX, 10, &age) < 0)
982 age = -1;
983 }
984 if(age < 0) {
985 do_log(L_WARN, "Couldn't parse age: \n");
986 do_log_n(L_WARN, buf + value_start, value_end - value_start);
987 do_log(L_WARN, " -- ignored.\n");
988 }
989 } else if(name == atomXPolipoBodyOffset) {
990 j = skipWhitespace(buf, value_start);
991 if(j < 0) {
992 do_log(L_ERROR, "Couldn't parse body offset.\n");
993 goto fail;
994 } else {
995 if(parseInt(buf, value_start, 0, INT_MAX, 10,
996 &polipo_body_offset) < 0) {
997 do_log(L_ERROR, "Couldn't parse body offset.\n");
998 goto fail;
999 }
1000 }
1001 } else if(name == atomTransferEncoding) {
1002 if(token_compare(buf, value_start, value_end, "identity"))
1003 te = TE_IDENTITY;
1004 else if(token_compare(buf, value_start, value_end, "chunked"))
1005 te = TE_CHUNKED;
1006 else
1007 te = TE_UNKNOWN;
1008 } else if(name == atomETag ||
1009 name == atomIfNoneMatch || name == atomIfMatch ||
1010 name == atomIfRange) {
1011 int x, y;
1012 int weak;
1013 char *e;
1014 j = getNextETag(buf, value_start, &x, &y, &weak);
1015 if(j < 0) {
1016 if(buf[value_start] != '\r' && buf[value_start] != '\n')
1017 do_log(L_ERROR, "Couldn't parse ETag.\n");
1018 } else if(weak) {
1019 do_log(L_WARN, "Server returned weak ETag -- ignored.\n");
1020 } else {
1021 e = strdup_n(buf + x, y - x);
1022 if(e == NULL) goto fail;
1023 if(name == atomETag) {
1024 if(!etag)
1025 etag = e;
1026 else
1027 free(e);
1028 } else if(name == atomIfNoneMatch) {
1029 if(!inm)
1030 inm = e;
1031 else
1032 free(e);
1033 } else if(name == atomIfMatch) {
1034 if(!im)
1035 im = e;
1036 else
1037 free(e);
1038 } else if(name == atomIfRange) {
1039 if(!ifrange)
1040 ifrange = e;
1041 else
1042 free(e);
1043 } else {
1044 abort();
1045 }
1046 }
1047 } else if(name == atomCacheControl) {
1048 int v_start, v_end;
1049 j = getNextTokenInList(buf, value_start,
1050 &token_start, &token_end,
1051 &v_start, &v_end,
1052 &end);
1053 while(1) {
1054 if(j < 0) {
1055 do_log(L_WARN, "Couldn't parse Cache-Control.\n");
1056 cache_control.flags |= CACHE_NO;
1057 break;
1058 }
1059 if(token_compare(buf, token_start, token_end, "no-cache")) {
1060 cache_control.flags |= CACHE_NO;
1061 } else if(token_compare(buf, token_start, token_end,
1062 "public")) {
1063 cache_control.flags |= CACHE_PUBLIC;
1064 } else if(token_compare(buf, token_start, token_end,
1065 "private")) {
1066 cache_control.flags |= CACHE_PRIVATE;
1067 } else if(token_compare(buf, token_start, token_end,
1068 "no-store")) {
1069 cache_control.flags |= CACHE_NO_STORE;
1070 } else if(token_compare(buf, token_start, token_end,
1071 "no-transform")) {
1072 cache_control.flags |= CACHE_NO_TRANSFORM;
1073 } else if(token_compare(buf, token_start, token_end,
1074 "must-revalidate") ||
1075 token_compare(buf, token_start, token_end,
1076 "must-validate")) { /* losers */
1077 cache_control.flags |= CACHE_MUST_REVALIDATE;
1078 } else if(token_compare(buf, token_start, token_end,
1079 "proxy-revalidate")) {
1080 cache_control.flags |= CACHE_PROXY_REVALIDATE;
1081 } else if(token_compare(buf, token_start, token_end,
1082 "only-if-cached")) {
1083 cache_control.flags |= CACHE_ONLY_IF_CACHED;
1084 } else if(token_compare(buf, token_start, token_end,
1085 "max-age") ||
1086 token_compare(buf, token_start, token_end,
1087 "maxage") || /* losers */
1088 token_compare(buf, token_start, token_end,
1089 "s-maxage") ||
1090 token_compare(buf, token_start, token_end,
1091 "min-fresh")) {
1092 parseCacheControl(buf, token_start, token_end,
1093 v_start, v_end,
1094 &cache_control.max_age);
1095 } else if(token_compare(buf, token_start, token_end,
1096 "max-stale")) {
1097 parseCacheControl(buf, token_start, token_end,
1098 v_start, v_end,
1099 &cache_control.max_stale);
1100 } else {
1101 do_log(L_WARN, "Unsupported Cache-Control directive ");
1102 do_log_n(L_WARN, buf + token_start,
1103 (v_end >= 0 ? v_end : token_end) - token_start);
1104 do_log(L_WARN, " -- ignored.\n");
1105 }
1106 if(end)
1107 break;
1108 j = getNextTokenInList(buf, j,
1109 &token_start, &token_end,
1110 &v_start, &v_end,
1111 &end);
1112 }
1113 } else if(name == atomContentRange) {
1114 if(!client) {
1115 j = parseContentRange(buf, value_start,
1116 &content_range.from, &content_range.to,
1117 &content_range.full_length);
1118 if(j < 0) {
1119 do_log(L_ERROR, "Couldn't parse Content-Range: ");
1120 do_log_n(L_ERROR, buf + value_start,
1121 value_end - value_start);
1122 do_log(L_ERROR, "\n");
1123 goto fail;
1124 }
1125 } else {
1126 do_log(L_ERROR, "Content-Range from client.\n");
1127 goto fail;
1128 }
1129 } else if(name == atomRange) {
1130 if(client) {
1131 j = parseRange(buf, value_start, &range.from, &range.to);
1132 if(j < 0) {
1133 do_log(L_WARN, "Couldn't parse Range -- ignored.\n");
1134 range.from = -1;
1135 range.to = -1;
1136 }
1137 } else {
1138 do_log(L_WARN, "Range from server -- ignored\n");
1139 }
1140 } else if(name == atomXPolipoLocation) {
1141 if(location_return) {
1142 location =
1143 strdup_n(buf + value_start, value_end - value_start);
1144 if(location == NULL) {
1145 do_log(L_ERROR, "Couldn't allocate location.\n");
1146 goto fail;
1147 }
1148 }
1149 } else if(name == atomVia) {
1150 if(via_return) {
1151 AtomPtr new_via, full_via;
1152 new_via =
1153 internAtomN(buf + value_start, value_end - value_start);
1154 if(new_via == NULL) {
1155 do_log(L_ERROR, "Couldn't allocate via.\n");
1156 goto fail;
1157 }
1158 if(via) {
1159 full_via =
1160 internAtomF("%s, %s", via->string, new_via->string);
1161 releaseAtom(new_via);
1162 if(full_via == NULL) {
1163 do_log(L_ERROR, "Couldn't allocate via");
1164 goto fail;
1165 }
1166 releaseAtom(via);
1167 via = full_via;
1168 } else {
1169 via = new_via;
1170 }
1171 }
1172 } else if(name == atomExpect) {
1173 if(expect_return) {
1174 expect = internAtomLowerN(buf + value_start,
1175 value_end - value_start);
1176 if(expect == NULL) {
1177 do_log(L_ERROR, "Couldn't allocate expect.\n");
1178 goto fail;
1179 }
1180 }
1181 } else {
1182 if(!client && name == atomContentType) {
1183 if(token_compare(buf, value_start, value_end,
1184 "multipart/byteranges")) {
1185 do_log(L_ERROR,
1186 "Server returned multipart/byteranges -- yuck!\n");
1187 goto fail;
1188 }
1189 }
1190 if(name == atomVary) {
1191 if(!token_compare(buf, value_start, value_end, "host") &&
1192 !token_compare(buf, value_start, value_end, "*")) {
1193 /* What other vary headers should be ignored? */
1194 do_log(L_VARY, "Vary header present (");
1195 do_log_n(L_VARY,
1196 buf + value_start, value_end - value_start);
1197 do_log(L_VARY, ").\n");
1198 }
1199 cache_control.flags |= CACHE_VARY;
1200 } else if(name == atomAuthorization) {
1201 cache_control.flags |= CACHE_AUTHORIZATION;
1202 }
1203
1204 if(name == atomPragma) {
1205 /* Pragma is only defined for the client, and the only
1206 standard value is no-cache (RFC 1945, 10.12).
1207 However, we honour a Pragma: no-cache for both the client
1208 and the server when there's no Cache-Control header. In
1209 all cases, we pass the Pragma header to the next hop. */
1210 if(!haveCacheControl) {
1211 j = getNextTokenInList(buf, value_start,
1212 &token_start, &token_end, NULL, NULL,
1213 &end);
1214 while(1) {
1215 if(j < 0) {
1216 do_log(L_WARN, "Couldn't parse Pragma.\n");
1217 cache_control.flags |= CACHE_NO;
1218 break;
1219 }
1220 if(token_compare(buf, token_start, token_end,
1221 "no-cache"))
1222 cache_control.flags = CACHE_NO;
1223 if(end)
1224 break;
1225 j = getNextTokenInList(buf, j, &token_start, &token_end,
1226 NULL, NULL, &end);
1227 }
1228 }
1229 }
1230 if(!client &&
1231 (name == atomSetCookie ||
1232 name == atomCookie || name == atomCookie2))
1233 cache_control.flags |= CACHE_COOKIE;
1234
1235 if(hbuf) {
1236 if(name != atomConnection && name != atomHost &&
1237 name != atomAcceptRange && name != atomTE &&
1238 name != atomProxyAuthenticate &&
1239 name != atomKeepAlive &&
1240 (!hopToHop || !atomListMember(name, hopToHop)) &&
1241 !atomListMember(name, censoredHeaders)) {
1242 int h;
1243 while(hbuf_length > hbuf_size - 2)
1244 RESIZE_HBUF();
1245 hbuf[hbuf_length++] = '\r';
1246 hbuf[hbuf_length++] = '\n';
1247 do {
1248 h = snnprint_n(hbuf, hbuf_length, hbuf_size,
1249 buf + name_start,
1250 value_end - name_start);
1251 if(h < 0) RESIZE_HBUF();
1252 } while(h < 0);
1253 hbuf_length = h;
1254 }
1255 }
1256 }
1257 releaseAtom(name);
1258 name = NULL;
1259 }
1260
1261 if(headers_return) {
1262 AtomPtr pheaders = NULL;
1263 pheaders = internAtomN(hbuf, hbuf_length);
1264 if(!pheaders)
1265 goto fail;
1266 *headers_return = pheaders;
1267 }
1268 if(hbuf != hbuf_small)
1269 free(hbuf);
1270 hbuf = NULL;
1271 hbuf_size = 0;
1272
1273 if(request)
1274 if(!persistent)
1275 request->flags &= ~REQUEST_PERSISTENT;
1276
1277 if(te != TE_IDENTITY) len = -1;
1278 if(len_return) *len_return = len;
1279 if(cache_control_return) *cache_control_return = cache_control;
1280 if(condition_return) {
1281 if(ims >= 0 || inms >= 0 || im || inm || ifrange) {
1282 condition = httpMakeCondition();
1283 if(condition) {
1284 condition->ims = ims;
1285 condition->inms = inms;
1286 condition->im = im;
1287 condition->inm = inm;
1288 condition->ifrange = ifrange;
1289 } else {
1290 do_log(L_ERROR, "Couldn't allocate condition.\n");
1291 if(im) free(im);
1292 if(inm) free(inm);
1293 }
1294 } else {
1295 condition = NULL;
1296 }
1297 *condition_return = condition;
1298 } else {
1299 assert(!im && !inm);
1300 }
1301
1302 if(te_return) *te_return = te;
1303 if(date_return) *date_return = date;
1304 if(last_modified_return) *last_modified_return = last_modified;
1305 if(expires_return) *expires_return = expires;
1306 if(polipo_age_return) *polipo_age_return = polipo_age;
1307 if(polipo_access_return) *polipo_access_return = polipo_access;
1308 if(polipo_body_offset_return)
1309 *polipo_body_offset_return = polipo_body_offset;
1310 if(age_return) *age_return = age;
1311 if(etag_return)
1312 *etag_return = etag;
1313 else {
1314 if(etag) free(etag);
1315 }
1316 if(range_return) *range_return = range;
1317 if(content_range_return) *content_range_return = content_range;
1318 if(location_return) {
1319 *location_return = location;
1320 } else {
1321 if(location)
1322 free(location);
1323 }
1324 if(via_return)
1325 *via_return = via;
1326 else {
1327 if(via)
1328 releaseAtom(via);
1329 }
1330 if(expect_return)
1331 *expect_return = expect;
1332 else {
1333 if(expect)
1334 releaseAtom(expect);
1335 }
1336 if(auth_return)
1337 *auth_return = auth;
1338 else {
1339 if(auth)
1340 releaseAtom(auth);
1341 }
1342 if(hopToHop) destroyAtomList(hopToHop);
1343 return i;
1344
1345 fail:
1346 if(hbuf && hbuf != hbuf_small) free(hbuf);
1347 if(name) releaseAtom(name);
1348 if(etag) free(etag);
1349 if(location) free(location);
1350 if(via) releaseAtom(via);
1351 if(expect) releaseAtom(expect);
1352 if(auth) releaseAtom(auth);
1353 if(hopToHop) destroyAtomList(hopToHop);
1354
1355 return -1;
1356 #undef RESIZE_HBUF
1357 }
1358
1359 int
1360 httpFindHeader(AtomPtr header, const char *headers, int hlen,
1361 int *value_begin_return, int *value_end_return)
1362 {
1363 int len = header->length;
1364 int i = 0;
1365
1366 while(i + len + 1 < hlen) {
1367 if(headers[i + len] == ':' &&
1368 lwrcmp(headers + i, header->string, len) == 0) {
1369 int j = i + len + 1, k;
1370 while(j < hlen && headers[j] == ' ')
1371 j++;
1372 k = j;
1373 while(k < hlen && headers[k] != '\n' && headers[k] != '\r')
1374 k++;
1375 *value_begin_return = j;
1376 *value_end_return = k;
1377 return 1;
1378 } else {
1379 while(i < hlen && headers[i] != '\n' && headers[i] != '\r')
1380 i++;
1381 i++;
1382 if(i < hlen && headers[i] == '\n')
1383 i++;
1384 }
1385 }
1386 return 0;
1387 }
1388
1389 int
1390 parseUrl(const char *url, int len,
1391 int *x_return, int *y_return, int *port_return, int *z_return)
1392 {
1393 int x, y, z, port = -1, i = 0;
1394
1395 if(len >= 7 && lwrcmp(url, "http://", 7) == 0) {
1396 x = 7;
1397 if(x < len && url[x] == '[') {
1398 /* RFC 2732 */
1399 for(i = x + 1; i < len; i++) {
1400 if(url[i] == ']') {
1401 i++;
1402 break;
1403 }
1404 if((url[i] != ':') && !letter(url[i]) && !digit(url[i]))
1405 break;
1406 }
1407 } else {
1408 for(i = x; i < len; i++)
1409 if(url[i] == ':' || url[i] == '/')
1410 break;
1411 }
1412 y = i;
1413
1414 if(i < len && url[i] == ':') {
1415 int j;
1416 j = parseIntN(url, i + 1, len, 0, 65535, 10, &port);
1417 if(j < 0) {
1418 port = 80;
1419 } else {
1420 i = j;
1421 }
1422 } else {
1423 port = 80;
1424 }
1425 } else {
1426 x = -1;
1427 y = -1;
1428 }
1429
1430 z = i;
1431
1432 *x_return = x;
1433 *y_return = y;
1434 *port_return = port;
1435 *z_return = z;
1436 return 0;
1437 }
1438
1439 int
1440 urlIsLocal(const char *url, int len)
1441 {
1442 return (len > 0 && url[0] == '/');
1443 }
1444
1445 int
1446 urlIsSpecial(const char *url, int len)
1447 {
1448 return (len >= 8 && memcmp(url, "/polipo/", 8) == 0);
1449 }
1450
1451 int
1452 parseChunkSize(const char *restrict buf, int i, int end,
1453 int *chunk_size_return)
1454 {
1455 int v;
1456
1457 i = parseIntN(buf, i, end, 0, INT_MAX, 16, &v);
1458 if(i < 0)
1459 return -1;
1460
1461 while(i < end) {
1462 if(buf[i] == ' ' || buf[i] == '\t')
1463 i++;
1464 else
1465 break;
1466 }
1467
1468 if(i >= end - 1)
1469 return 0;
1470
1471 if(buf[i] != '\r' || buf[i + 1] != '\n')
1472 return -1;
1473
1474 i += 2;
1475
1476 if(v == 0) {
1477 if(i >= end - 1)
1478 return 0;
1479 if(buf[i] != '\r') {
1480 do_log(L_ERROR, "Trailers present!\n");
1481 return -1;
1482 }
1483 i++;
1484 if(buf[i] != '\n')
1485 return -1;
1486 i++;
1487 }
1488
1489 *chunk_size_return = v;
1490 return i;
1491 }
1492
1493
1494 int
1495 checkVia(AtomPtr name, AtomPtr via)
1496 {
1497 int i;
1498 char *v;
1499 if(via == NULL || via->length == 0)
1500 return 1;
1501
1502 v = via->string;
1503
1504 i = 0;
1505 while(i < via->length) {
1506 while(v[i] == ' ' || v[i] == '\t' || v[i] == ',' ||
1507 v[i] == '\r' || v[i] == '\n' ||
1508 digit(v[i]) || v[i] == '.')
1509 i++;
1510 if(i + name->length > via->length)
1511 break;
1512 if(memcmp(v + i, name->string, name->length) == 0) {
1513 char c = v[i + name->length];
1514 if(c == '\0' || c == ' ' || c == '\t' || c == ',' ||
1515 c == '\r' || c == '\n')
1516 return 0;
1517 }
1518 i++;
1519 while(letter(v[i]) || digit(v[i]) || v[i] == '.')
1520 i++;
1521 }
1522 return 1;
1523 }
Caching web proxy