1: /* Copyright 2009,2010 Ryan Dahl <ry@tinyclouds.org>
2: *
3: * Permission is hereby granted, free of charge, to any person obtaining a copy
4: * of this software and associated documentation files (the "Software"), to
5: * deal in the Software without restriction, including without limitation the
6: * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
7: * sell copies of the Software, and to permit persons to whom the Software is
8: * furnished to do so, subject to the following conditions:
9: *
10: * The above copyright notice and this permission notice shall be included in
11: * all copies or substantial portions of the Software.
12: *
13: * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14: * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15: * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16: * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17: * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
18: * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
19: * IN THE SOFTWARE.
20: */
21: #include <assert.h>
22: #include <stddef.h>
23: #include "php_http_parser.h"
24:
25:
26: #ifndef MIN
27: # define MIN(a,b) ((a) < (b) ? (a) : (b))
28: #endif
29:
30:
31: #define CALLBACK2(FOR) \
32: do { \
33: if (settings->on_##FOR) { \
34: if (0 != settings->on_##FOR(parser)) return (p - data); \
35: } \
36: } while (0)
37:
38:
39: #define MARK(FOR) \
40: do { \
41: FOR##_mark = p; \
42: } while (0)
43:
44: #define CALLBACK_NOCLEAR(FOR) \
45: do { \
46: if (FOR##_mark) { \
47: if (settings->on_##FOR) { \
48: if (0 != settings->on_##FOR(parser, \
49: FOR##_mark, \
50: p - FOR##_mark)) \
51: { \
52: return (p - data); \
53: } \
54: } \
55: } \
56: } while (0)
57:
58: #ifdef PHP_WIN32
59: # undef CALLBACK
60: #endif
61: #define CALLBACK(FOR) \
62: do { \
63: CALLBACK_NOCLEAR(FOR); \
64: FOR##_mark = NULL; \
65: } while (0)
66:
67:
68: #define PROXY_CONNECTION "proxy-connection"
69: #define CONNECTION "connection"
70: #define CONTENT_LENGTH "content-length"
71: #define TRANSFER_ENCODING "transfer-encoding"
72: #define UPGRADE "upgrade"
73: #define CHUNKED "chunked"
74: #define KEEP_ALIVE "keep-alive"
75: #define CLOSE "close"
76:
77:
78: static const char *method_strings[] =
79: { "DELETE"
80: , "GET"
81: , "HEAD"
82: , "POST"
83: , "PUT"
84: , "CONNECT"
85: , "OPTIONS"
86: , "TRACE"
87: , "COPY"
88: , "LOCK"
89: , "MKCOL"
90: , "MOVE"
91: , "PROPFIND"
92: , "PROPPATCH"
93: , "UNLOCK"
94: , "REPORT"
95: , "MKACTIVITY"
96: , "CHECKOUT"
97: , "MERGE"
98: , "M-SEARCH"
99: , "NOTIFY"
100: , "SUBSCRIBE"
101: , "UNSUBSCRIBE"
102: };
103:
104:
105: /* Tokens as defined by rfc 2616. Also lowercases them.
106: * token = 1*<any CHAR except CTLs or separators>
107: * separators = "(" | ")" | "<" | ">" | "@"
108: * | "," | ";" | ":" | "\" | <">
109: * | "/" | "[" | "]" | "?" | "="
110: * | "{" | "}" | SP | HT
111: */
112: static const char tokens[256] = {
113: /* 0 nul 1 soh 2 stx 3 etx 4 eot 5 enq 6 ack 7 bel */
114: 0, 0, 0, 0, 0, 0, 0, 0,
115: /* 8 bs 9 ht 10 nl 11 vt 12 np 13 cr 14 so 15 si */
116: 0, 0, 0, 0, 0, 0, 0, 0,
117: /* 16 dle 17 dc1 18 dc2 19 dc3 20 dc4 21 nak 22 syn 23 etb */
118: 0, 0, 0, 0, 0, 0, 0, 0,
119: /* 24 can 25 em 26 sub 27 esc 28 fs 29 gs 30 rs 31 us */
120: 0, 0, 0, 0, 0, 0, 0, 0,
121: /* 32 sp 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' */
122: ' ', '!', '"', '#', '$', '%', '&', '\'',
123: /* 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / */
124: 0, 0, '*', '+', 0, '-', '.', '/',
125: /* 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 */
126: '0', '1', '2', '3', '4', '5', '6', '7',
127: /* 56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ? */
128: '8', '9', 0, 0, 0, 0, 0, 0,
129: /* 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G */
130: 0, 'a', 'b', 'c', 'd', 'e', 'f', 'g',
131: /* 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O */
132: 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
133: /* 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W */
134: 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
135: /* 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ */
136: 'x', 'y', 'z', 0, 0, 0, '^', '_',
137: /* 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g */
138: '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
139: /* 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o */
140: 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
141: /* 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w */
142: 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
143: /* 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 del */
144: 'x', 'y', 'z', 0, '|', '}', '~', 0 };
145:
146:
147: static const int8_t unhex[256] =
148: {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
149: ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
150: ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
151: , 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1
152: ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1
153: ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
154: ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1
155: ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
156: };
157:
158:
159: static const uint8_t normal_url_char[256] = {
160: /* 0 nul 1 soh 2 stx 3 etx 4 eot 5 enq 6 ack 7 bel */
161: 0, 0, 0, 0, 0, 0, 0, 0,
162: /* 8 bs 9 ht 10 nl 11 vt 12 np 13 cr 14 so 15 si */
163: 0, 0, 0, 0, 0, 0, 0, 0,
164: /* 16 dle 17 dc1 18 dc2 19 dc3 20 dc4 21 nak 22 syn 23 etb */
165: 0, 0, 0, 0, 0, 0, 0, 0,
166: /* 24 can 25 em 26 sub 27 esc 28 fs 29 gs 30 rs 31 us */
167: 0, 0, 0, 0, 0, 0, 0, 0,
168: /* 32 sp 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' */
169: 0, 1, 1, 0, 1, 1, 1, 1,
170: /* 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / */
171: 1, 1, 1, 1, 1, 1, 1, 1,
172: /* 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 */
173: 1, 1, 1, 1, 1, 1, 1, 1,
174: /* 56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ? */
175: 1, 1, 1, 1, 1, 1, 1, 0,
176: /* 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G */
177: 1, 1, 1, 1, 1, 1, 1, 1,
178: /* 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O */
179: 1, 1, 1, 1, 1, 1, 1, 1,
180: /* 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W */
181: 1, 1, 1, 1, 1, 1, 1, 1,
182: /* 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ */
183: 1, 1, 1, 1, 1, 1, 1, 1,
184: /* 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g */
185: 1, 1, 1, 1, 1, 1, 1, 1,
186: /* 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o */
187: 1, 1, 1, 1, 1, 1, 1, 1,
188: /* 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w */
189: 1, 1, 1, 1, 1, 1, 1, 1,
190: /* 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 del */
191: 1, 1, 1, 1, 1, 1, 1, 0 };
192:
193:
194: enum state
195: { s_dead = 1 /* important that this is > 0 */
196:
197: , s_start_req_or_res
198: , s_res_or_resp_H
199: , s_start_res
200: , s_res_H
201: , s_res_HT
202: , s_res_HTT
203: , s_res_HTTP
204: , s_res_first_http_major
205: , s_res_http_major
206: , s_res_first_http_minor
207: , s_res_http_minor
208: , s_res_first_status_code
209: , s_res_status_code
210: , s_res_status
211: , s_res_line_almost_done
212:
213: , s_start_req
214:
215: , s_req_method
216: , s_req_spaces_before_url
217: , s_req_schema
218: , s_req_schema_slash
219: , s_req_schema_slash_slash
220: , s_req_host
221: , s_req_port
222: , s_req_path
223: , s_req_query_string_start
224: , s_req_query_string
225: , s_req_fragment_start
226: , s_req_fragment
227: , s_req_http_start
228: , s_req_http_H
229: , s_req_http_HT
230: , s_req_http_HTT
231: , s_req_http_HTTP
232: , s_req_first_http_major
233: , s_req_http_major
234: , s_req_first_http_minor
235: , s_req_http_minor
236: , s_req_line_almost_done
237:
238: , s_header_field_start
239: , s_header_field
240: , s_header_value_start
241: , s_header_value
242:
243: , s_header_almost_done
244:
245: , s_headers_almost_done
246: /* Important: 's_headers_almost_done' must be the last 'header' state. All
247: * states beyond this must be 'body' states. It is used for overflow
248: * checking. See the PARSING_HEADER() macro.
249: */
250: , s_chunk_size_start
251: , s_chunk_size
252: , s_chunk_size_almost_done
253: , s_chunk_parameters
254: , s_chunk_data
255: , s_chunk_data_almost_done
256: , s_chunk_data_done
257:
258: , s_body_identity
259: , s_body_identity_eof
260: };
261:
262:
263: #define PARSING_HEADER(state) (state <= s_headers_almost_done && 0 == (parser->flags & F_TRAILING))
264:
265:
266: enum header_states
267: { h_general = 0
268: , h_C
269: , h_CO
270: , h_CON
271:
272: , h_matching_connection
273: , h_matching_proxy_connection
274: , h_matching_content_length
275: , h_matching_transfer_encoding
276: , h_matching_upgrade
277:
278: , h_connection
279: , h_content_length
280: , h_transfer_encoding
281: , h_upgrade
282:
283: , h_matching_transfer_encoding_chunked
284: , h_matching_connection_keep_alive
285: , h_matching_connection_close
286:
287: , h_transfer_encoding_chunked
288: , h_connection_keep_alive
289: , h_connection_close
290: };
291:
292:
293: enum flags
294: { F_CHUNKED = 1 << 0
295: , F_CONNECTION_KEEP_ALIVE = 1 << 1
296: , F_CONNECTION_CLOSE = 1 << 2
297: , F_TRAILING = 1 << 3
298: , F_UPGRADE = 1 << 4
299: , F_SKIPBODY = 1 << 5
300: };
301:
302:
303: #define CR '\r'
304: #define LF '\n'
305: #define LOWER(c) (unsigned char)(c | 0x20)
306: #define TOKEN(c) tokens[(unsigned char)c]
307:
308:
309: #define start_state (parser->type == PHP_HTTP_REQUEST ? s_start_req : s_start_res)
310:
311:
312: #if HTTP_PARSER_STRICT
313: # define STRICT_CHECK(cond) if (cond) goto error
314: # define NEW_MESSAGE() (http_should_keep_alive(parser) ? start_state : s_dead)
315: #else
316: # define STRICT_CHECK(cond)
317: # define NEW_MESSAGE() start_state
318: #endif
319:
320:
321: size_t php_http_parser_execute (php_http_parser *parser,
322: const php_http_parser_settings *settings,
323: const char *data,
324: size_t len)
325: {
326: char c, ch;
327: const char *p = data, *pe;
328: size_t to_read;
329:
330: enum state state = (enum state) parser->state;
331: enum header_states header_state = (enum header_states) parser->header_state;
332: uint32_t index = parser->index;
333: uint32_t nread = parser->nread;
334:
335: /* technically we could combine all of these (except for url_mark) into one
336: variable, saving stack space, but it seems more clear to have them
337: separated. */
338: const char *header_field_mark = 0;
339: const char *header_value_mark = 0;
340: const char *fragment_mark = 0;
341: const char *query_string_mark = 0;
342: const char *path_mark = 0;
343: const char *url_mark = 0;
344:
345: if (len == 0) {
346: if (state == s_body_identity_eof) {
347: CALLBACK2(message_complete);
348: }
349: return 0;
350: }
351:
352: if (state == s_header_field)
353: header_field_mark = data;
354: if (state == s_header_value)
355: header_value_mark = data;
356: if (state == s_req_fragment)
357: fragment_mark = data;
358: if (state == s_req_query_string)
359: query_string_mark = data;
360: if (state == s_req_path)
361: path_mark = data;
362: if (state == s_req_path || state == s_req_schema || state == s_req_schema_slash
363: || state == s_req_schema_slash_slash || state == s_req_port
364: || state == s_req_query_string_start || state == s_req_query_string
365: || state == s_req_host
366: || state == s_req_fragment_start || state == s_req_fragment)
367: url_mark = data;
368:
369: for (p=data, pe=data+len; p != pe; p++) {
370: ch = *p;
371:
372: if (PARSING_HEADER(state)) {
373: ++nread;
374: /* Buffer overflow attack */
375: if (nread > PHP_HTTP_MAX_HEADER_SIZE) goto error;
376: }
377:
378: switch (state) {
379:
380: case s_dead:
381: /* this state is used after a 'Connection: close' message
382: * the parser will error out if it reads another message
383: */
384: goto error;
385:
386: case s_start_req_or_res:
387: {
388: if (ch == CR || ch == LF)
389: break;
390: parser->flags = 0;
391: parser->content_length = -1;
392:
393: CALLBACK2(message_begin);
394:
395: if (ch == 'H')
396: state = s_res_or_resp_H;
397: else {
398: parser->type = PHP_HTTP_REQUEST;
399: goto start_req_method_assign;
400: }
401: break;
402: }
403:
404: case s_res_or_resp_H:
405: if (ch == 'T') {
406: parser->type = PHP_HTTP_RESPONSE;
407: state = s_res_HT;
408: } else {
409: if (ch != 'E') goto error;
410: parser->type = PHP_HTTP_REQUEST;
411: parser->method = PHP_HTTP_HEAD;
412: index = 2;
413: state = s_req_method;
414: }
415: break;
416:
417: case s_start_res:
418: {
419: parser->flags = 0;
420: parser->content_length = -1;
421:
422: CALLBACK2(message_begin);
423:
424: switch (ch) {
425: case 'H':
426: state = s_res_H;
427: break;
428:
429: case CR:
430: case LF:
431: break;
432:
433: default:
434: goto error;
435: }
436: break;
437: }
438:
439: case s_res_H:
440: STRICT_CHECK(ch != 'T');
441: state = s_res_HT;
442: break;
443:
444: case s_res_HT:
445: STRICT_CHECK(ch != 'T');
446: state = s_res_HTT;
447: break;
448:
449: case s_res_HTT:
450: STRICT_CHECK(ch != 'P');
451: state = s_res_HTTP;
452: break;
453:
454: case s_res_HTTP:
455: STRICT_CHECK(ch != '/');
456: state = s_res_first_http_major;
457: break;
458:
459: case s_res_first_http_major:
460: if (ch < '1' || ch > '9') goto error;
461: parser->http_major = ch - '0';
462: state = s_res_http_major;
463: break;
464:
465: /* major HTTP version or dot */
466: case s_res_http_major:
467: {
468: if (ch == '.') {
469: state = s_res_first_http_minor;
470: break;
471: }
472:
473: if (ch < '0' || ch > '9') goto error;
474:
475: parser->http_major *= 10;
476: parser->http_major += ch - '0';
477:
478: if (parser->http_major > 999) goto error;
479: break;
480: }
481:
482: /* first digit of minor HTTP version */
483: case s_res_first_http_minor:
484: if (ch < '0' || ch > '9') goto error;
485: parser->http_minor = ch - '0';
486: state = s_res_http_minor;
487: break;
488:
489: /* minor HTTP version or end of request line */
490: case s_res_http_minor:
491: {
492: if (ch == ' ') {
493: state = s_res_first_status_code;
494: break;
495: }
496:
497: if (ch < '0' || ch > '9') goto error;
498:
499: parser->http_minor *= 10;
500: parser->http_minor += ch - '0';
501:
502: if (parser->http_minor > 999) goto error;
503: break;
504: }
505:
506: case s_res_first_status_code:
507: {
508: if (ch < '0' || ch > '9') {
509: if (ch == ' ') {
510: break;
511: }
512: goto error;
513: }
514: parser->status_code = ch - '0';
515: state = s_res_status_code;
516: break;
517: }
518:
519: case s_res_status_code:
520: {
521: if (ch < '0' || ch > '9') {
522: switch (ch) {
523: case ' ':
524: state = s_res_status;
525: break;
526: case CR:
527: state = s_res_line_almost_done;
528: break;
529: case LF:
530: state = s_header_field_start;
531: break;
532: default:
533: goto error;
534: }
535: break;
536: }
537:
538: parser->status_code *= 10;
539: parser->status_code += ch - '0';
540:
541: if (parser->status_code > 999) goto error;
542: break;
543: }
544:
545: case s_res_status:
546: /* the human readable status. e.g. "NOT FOUND"
547: * we are not humans so just ignore this */
548: if (ch == CR) {
549: state = s_res_line_almost_done;
550: break;
551: }
552:
553: if (ch == LF) {
554: state = s_header_field_start;
555: break;
556: }
557: break;
558:
559: case s_res_line_almost_done:
560: STRICT_CHECK(ch != LF);
561: state = s_header_field_start;
562: break;
563:
564: case s_start_req:
565: {
566: if (ch == CR || ch == LF)
567: break;
568: parser->flags = 0;
569: parser->content_length = -1;
570:
571: CALLBACK2(message_begin);
572:
573: if (ch < 'A' || 'Z' < ch) goto error;
574:
575: start_req_method_assign:
576: parser->method = (enum php_http_method) 0;
577: index = 1;
578: switch (ch) {
579: case 'C': parser->method = PHP_HTTP_CONNECT; /* or COPY, CHECKOUT */ break;
580: case 'D': parser->method = PHP_HTTP_DELETE; break;
581: case 'G': parser->method = PHP_HTTP_GET; break;
582: case 'H': parser->method = PHP_HTTP_HEAD; break;
583: case 'L': parser->method = PHP_HTTP_LOCK; break;
584: case 'M': parser->method = PHP_HTTP_MKCOL; /* or MOVE, MKACTIVITY, MERGE, M-SEARCH */ break;
585: case 'N': parser->method = PHP_HTTP_NOTIFY; break;
586: case 'O': parser->method = PHP_HTTP_OPTIONS; break;
587: case 'P': parser->method = PHP_HTTP_POST; /* or PROPFIND or PROPPATCH or PUT */ break;
588: case 'R': parser->method = PHP_HTTP_REPORT; break;
589: case 'S': parser->method = PHP_HTTP_SUBSCRIBE; break;
590: case 'T': parser->method = PHP_HTTP_TRACE; break;
591: case 'U': parser->method = PHP_HTTP_UNLOCK; /* or UNSUBSCRIBE */ break;
592: default: goto error;
593: }
594: state = s_req_method;
595: break;
596: }
597:
598: case s_req_method:
599: {
600: const char *matcher;
601: if (ch == '\0')
602: goto error;
603:
604: matcher = method_strings[parser->method];
605: if (ch == ' ' && matcher[index] == '\0') {
606: state = s_req_spaces_before_url;
607: } else if (ch == matcher[index]) {
608: ; /* nada */
609: } else if (parser->method == PHP_HTTP_CONNECT) {
610: if (index == 1 && ch == 'H') {
611: parser->method = PHP_HTTP_CHECKOUT;
612: } else if (index == 2 && ch == 'P') {
613: parser->method = PHP_HTTP_COPY;
614: }
615: } else if (parser->method == PHP_HTTP_MKCOL) {
616: if (index == 1 && ch == 'O') {
617: parser->method = PHP_HTTP_MOVE;
618: } else if (index == 1 && ch == 'E') {
619: parser->method = PHP_HTTP_MERGE;
620: } else if (index == 1 && ch == '-') {
621: parser->method = PHP_HTTP_MSEARCH;
622: } else if (index == 2 && ch == 'A') {
623: parser->method = PHP_HTTP_MKACTIVITY;
624: }
625: } else if (index == 1 && parser->method == PHP_HTTP_POST && ch == 'R') {
626: parser->method = PHP_HTTP_PROPFIND; /* or HTTP_PROPPATCH */
627: } else if (index == 1 && parser->method == PHP_HTTP_POST && ch == 'U') {
628: parser->method = PHP_HTTP_PUT;
629: } else if (index == 2 && parser->method == PHP_HTTP_UNLOCK && ch == 'S') {
630: parser->method = PHP_HTTP_UNSUBSCRIBE;
631: } else if (index == 4 && parser->method == PHP_HTTP_PROPFIND && ch == 'P') {
632: parser->method = PHP_HTTP_PROPPATCH;
633: } else {
634: goto error;
635: }
636:
637: ++index;
638: break;
639: }
640: case s_req_spaces_before_url:
641: {
642: if (ch == ' ') break;
643:
644: if (ch == '/' || ch == '*') {
645: MARK(url);
646: MARK(path);
647: state = s_req_path;
648: break;
649: }
650:
651: c = LOWER(ch);
652:
653: if (c >= 'a' && c <= 'z') {
654: MARK(url);
655: state = s_req_schema;
656: break;
657: }
658:
659: goto error;
660: }
661:
662: case s_req_schema:
663: {
664: c = LOWER(ch);
665:
666: if (c >= 'a' && c <= 'z') break;
667:
668: if (ch == ':') {
669: state = s_req_schema_slash;
670: break;
671: } else if (ch == '.') {
672: state = s_req_host;
673: break;
674: } else if ('0' <= ch && ch <= '9') {
675: state = s_req_host;
676: break;
677: }
678:
679: goto error;
680: }
681:
682: case s_req_schema_slash:
683: STRICT_CHECK(ch != '/');
684: state = s_req_schema_slash_slash;
685: break;
686:
687: case s_req_schema_slash_slash:
688: STRICT_CHECK(ch != '/');
689: state = s_req_host;
690: break;
691:
692: case s_req_host:
693: {
694: c = LOWER(ch);
695: if (c >= 'a' && c <= 'z') break;
696: if ((ch >= '0' && ch <= '9') || ch == '.' || ch == '-') break;
697: switch (ch) {
698: case ':':
699: state = s_req_port;
700: break;
701: case '/':
702: MARK(path);
703: state = s_req_path;
704: break;
705: case ' ':
706: /* The request line looks like:
707: * "GET http://foo.bar.com HTTP/1.1"
708: * That is, there is no path.
709: */
710: CALLBACK(url);
711: state = s_req_http_start;
712: break;
713: default:
714: goto error;
715: }
716: break;
717: }
718:
719: case s_req_port:
720: {
721: if (ch >= '0' && ch <= '9') break;
722: switch (ch) {
723: case '/':
724: MARK(path);
725: state = s_req_path;
726: break;
727: case ' ':
728: /* The request line looks like:
729: * "GET http://foo.bar.com:1234 HTTP/1.1"
730: * That is, there is no path.
731: */
732: CALLBACK(url);
733: state = s_req_http_start;
734: break;
735: default:
736: goto error;
737: }
738: break;
739: }
740:
741: case s_req_path:
742: {
743: if (normal_url_char[(unsigned char)ch]) break;
744:
745: switch (ch) {
746: case ' ':
747: CALLBACK(url);
748: CALLBACK(path);
749: state = s_req_http_start;
750: break;
751: case CR:
752: CALLBACK(url);
753: CALLBACK(path);
754: parser->http_major = 0;
755: parser->http_minor = 9;
756: state = s_req_line_almost_done;
757: break;
758: case LF:
759: CALLBACK(url);
760: CALLBACK(path);
761: parser->http_major = 0;
762: parser->http_minor = 9;
763: state = s_header_field_start;
764: break;
765: case '?':
766: CALLBACK(path);
767: state = s_req_query_string_start;
768: break;
769: case '#':
770: CALLBACK(path);
771: state = s_req_fragment_start;
772: break;
773: default:
774: goto error;
775: }
776: break;
777: }
778:
779: case s_req_query_string_start:
780: {
781: if (normal_url_char[(unsigned char)ch]) {
782: MARK(query_string);
783: state = s_req_query_string;
784: break;
785: }
786:
787: switch (ch) {
788: case '?':
789: break; /* XXX ignore extra '?' ... is this right? */
790: case ' ':
791: CALLBACK(url);
792: state = s_req_http_start;
793: break;
794: case CR:
795: CALLBACK(url);
796: parser->http_major = 0;
797: parser->http_minor = 9;
798: state = s_req_line_almost_done;
799: break;
800: case LF:
801: CALLBACK(url);
802: parser->http_major = 0;
803: parser->http_minor = 9;
804: state = s_header_field_start;
805: break;
806: case '#':
807: state = s_req_fragment_start;
808: break;
809: default:
810: goto error;
811: }
812: break;
813: }
814:
815: case s_req_query_string:
816: {
817: if (normal_url_char[(unsigned char)ch]) break;
818:
819: switch (ch) {
820: case '?':
821: /* allow extra '?' in query string */
822: break;
823: case ' ':
824: CALLBACK(url);
825: CALLBACK(query_string);
826: state = s_req_http_start;
827: break;
828: case CR:
829: CALLBACK(url);
830: CALLBACK(query_string);
831: parser->http_major = 0;
832: parser->http_minor = 9;
833: state = s_req_line_almost_done;
834: break;
835: case LF:
836: CALLBACK(url);
837: CALLBACK(query_string);
838: parser->http_major = 0;
839: parser->http_minor = 9;
840: state = s_header_field_start;
841: break;
842: case '#':
843: CALLBACK(query_string);
844: state = s_req_fragment_start;
845: break;
846: default:
847: goto error;
848: }
849: break;
850: }
851:
852: case s_req_fragment_start:
853: {
854: if (normal_url_char[(unsigned char)ch]) {
855: MARK(fragment);
856: state = s_req_fragment;
857: break;
858: }
859:
860: switch (ch) {
861: case ' ':
862: CALLBACK(url);
863: state = s_req_http_start;
864: break;
865: case CR:
866: CALLBACK(url);
867: parser->http_major = 0;
868: parser->http_minor = 9;
869: state = s_req_line_almost_done;
870: break;
871: case LF:
872: CALLBACK(url);
873: parser->http_major = 0;
874: parser->http_minor = 9;
875: state = s_header_field_start;
876: break;
877: case '?':
878: MARK(fragment);
879: state = s_req_fragment;
880: break;
881: case '#':
882: break;
883: default:
884: goto error;
885: }
886: break;
887: }
888:
889: case s_req_fragment:
890: {
891: if (normal_url_char[(unsigned char)ch]) break;
892:
893: switch (ch) {
894: case ' ':
895: CALLBACK(url);
896: CALLBACK(fragment);
897: state = s_req_http_start;
898: break;
899: case CR:
900: CALLBACK(url);
901: CALLBACK(fragment);
902: parser->http_major = 0;
903: parser->http_minor = 9;
904: state = s_req_line_almost_done;
905: break;
906: case LF:
907: CALLBACK(url);
908: CALLBACK(fragment);
909: parser->http_major = 0;
910: parser->http_minor = 9;
911: state = s_header_field_start;
912: break;
913: case '?':
914: case '#':
915: break;
916: default:
917: goto error;
918: }
919: break;
920: }
921:
922: case s_req_http_start:
923: switch (ch) {
924: case 'H':
925: state = s_req_http_H;
926: break;
927: case ' ':
928: break;
929: default:
930: goto error;
931: }
932: break;
933:
934: case s_req_http_H:
935: STRICT_CHECK(ch != 'T');
936: state = s_req_http_HT;
937: break;
938:
939: case s_req_http_HT:
940: STRICT_CHECK(ch != 'T');
941: state = s_req_http_HTT;
942: break;
943:
944: case s_req_http_HTT:
945: STRICT_CHECK(ch != 'P');
946: state = s_req_http_HTTP;
947: break;
948:
949: case s_req_http_HTTP:
950: STRICT_CHECK(ch != '/');
951: state = s_req_first_http_major;
952: break;
953:
954: /* first digit of major HTTP version */
955: case s_req_first_http_major:
956: if (ch < '1' || ch > '9') goto error;
957: parser->http_major = ch - '0';
958: state = s_req_http_major;
959: break;
960:
961: /* major HTTP version or dot */
962: case s_req_http_major:
963: {
964: if (ch == '.') {
965: state = s_req_first_http_minor;
966: break;
967: }
968:
969: if (ch < '0' || ch > '9') goto error;
970:
971: parser->http_major *= 10;
972: parser->http_major += ch - '0';
973:
974: if (parser->http_major > 999) goto error;
975: break;
976: }
977:
978: /* first digit of minor HTTP version */
979: case s_req_first_http_minor:
980: if (ch < '0' || ch > '9') goto error;
981: parser->http_minor = ch - '0';
982: state = s_req_http_minor;
983: break;
984:
985: /* minor HTTP version or end of request line */
986: case s_req_http_minor:
987: {
988: if (ch == CR) {
989: state = s_req_line_almost_done;
990: break;
991: }
992:
993: if (ch == LF) {
994: state = s_header_field_start;
995: break;
996: }
997:
998: /* XXX allow spaces after digit? */
999:
1000: if (ch < '0' || ch > '9') goto error;
1001:
1002: parser->http_minor *= 10;
1003: parser->http_minor += ch - '0';
1004:
1005: if (parser->http_minor > 999) goto error;
1006: break;
1007: }
1008:
1009: /* end of request line */
1010: case s_req_line_almost_done:
1011: {
1012: if (ch != LF) goto error;
1013: state = s_header_field_start;
1014: break;
1015: }
1016:
1017: case s_header_field_start:
1018: {
1019: if (ch == CR) {
1020: state = s_headers_almost_done;
1021: break;
1022: }
1023:
1024: if (ch == LF) {
1025: /* they might be just sending \n instead of \r\n so this would be
1026: * the second \n to denote the end of headers*/
1027: state = s_headers_almost_done;
1028: goto headers_almost_done;
1029: }
1030:
1031: c = TOKEN(ch);
1032:
1033: if (!c) goto error;
1034:
1035: MARK(header_field);
1036:
1037: index = 0;
1038: state = s_header_field;
1039:
1040: switch (c) {
1041: case 'c':
1042: header_state = h_C;
1043: break;
1044:
1045: case 'p':
1046: header_state = h_matching_proxy_connection;
1047: break;
1048:
1049: case 't':
1050: header_state = h_matching_transfer_encoding;
1051: break;
1052:
1053: case 'u':
1054: header_state = h_matching_upgrade;
1055: break;
1056:
1057: default:
1058: header_state = h_general;
1059: break;
1060: }
1061: break;
1062: }
1063:
1064: case s_header_field:
1065: {
1066: c = TOKEN(ch);
1067:
1068: if (c) {
1069: switch (header_state) {
1070: case h_general:
1071: break;
1072:
1073: case h_C:
1074: index++;
1075: header_state = (c == 'o' ? h_CO : h_general);
1076: break;
1077:
1078: case h_CO:
1079: index++;
1080: header_state = (c == 'n' ? h_CON : h_general);
1081: break;
1082:
1083: case h_CON:
1084: index++;
1085: switch (c) {
1086: case 'n':
1087: header_state = h_matching_connection;
1088: break;
1089: case 't':
1090: header_state = h_matching_content_length;
1091: break;
1092: default:
1093: header_state = h_general;
1094: break;
1095: }
1096: break;
1097:
1098: /* connection */
1099:
1100: case h_matching_connection:
1101: index++;
1102: if (index > sizeof(CONNECTION)-1
1103: || c != CONNECTION[index]) {
1104: header_state = h_general;
1105: } else if (index == sizeof(CONNECTION)-2) {
1106: header_state = h_connection;
1107: }
1108: break;
1109:
1110: /* proxy-connection */
1111:
1112: case h_matching_proxy_connection:
1113: index++;
1114: if (index > sizeof(PROXY_CONNECTION)-1
1115: || c != PROXY_CONNECTION[index]) {
1116: header_state = h_general;
1117: } else if (index == sizeof(PROXY_CONNECTION)-2) {
1118: header_state = h_connection;
1119: }
1120: break;
1121:
1122: /* content-length */
1123:
1124: case h_matching_content_length:
1125: index++;
1126: if (index > sizeof(CONTENT_LENGTH)-1
1127: || c != CONTENT_LENGTH[index]) {
1128: header_state = h_general;
1129: } else if (index == sizeof(CONTENT_LENGTH)-2) {
1130: header_state = h_content_length;
1131: }
1132: break;
1133:
1134: /* transfer-encoding */
1135:
1136: case h_matching_transfer_encoding:
1137: index++;
1138: if (index > sizeof(TRANSFER_ENCODING)-1
1139: || c != TRANSFER_ENCODING[index]) {
1140: header_state = h_general;
1141: } else if (index == sizeof(TRANSFER_ENCODING)-2) {
1142: header_state = h_transfer_encoding;
1143: }
1144: break;
1145:
1146: /* upgrade */
1147:
1148: case h_matching_upgrade:
1149: index++;
1150: if (index > sizeof(UPGRADE)-1
1151: || c != UPGRADE[index]) {
1152: header_state = h_general;
1153: } else if (index == sizeof(UPGRADE)-2) {
1154: header_state = h_upgrade;
1155: }
1156: break;
1157:
1158: case h_connection:
1159: case h_content_length:
1160: case h_transfer_encoding:
1161: case h_upgrade:
1162: if (ch != ' ') header_state = h_general;
1163: break;
1164:
1165: default:
1166: assert(0 && "Unknown header_state");
1167: break;
1168: }
1169: break;
1170: }
1171:
1172: if (ch == ':') {
1173: CALLBACK(header_field);
1174: state = s_header_value_start;
1175: break;
1176: }
1177:
1178: if (ch == CR) {
1179: state = s_header_almost_done;
1180: CALLBACK(header_field);
1181: break;
1182: }
1183:
1184: if (ch == LF) {
1185: CALLBACK(header_field);
1186: state = s_header_field_start;
1187: break;
1188: }
1189:
1190: goto error;
1191: }
1192:
1193: case s_header_value_start:
1194: {
1195: if (ch == ' ') break;
1196:
1197: MARK(header_value);
1198:
1199: state = s_header_value;
1200: index = 0;
1201:
1202: c = LOWER(ch);
1203:
1204: if (ch == CR) {
1205: CALLBACK(header_value);
1206: header_state = h_general;
1207: state = s_header_almost_done;
1208: break;
1209: }
1210:
1211: if (ch == LF) {
1212: CALLBACK(header_value);
1213: state = s_header_field_start;
1214: break;
1215: }
1216:
1217: switch (header_state) {
1218: case h_upgrade:
1219: parser->flags |= F_UPGRADE;
1220: header_state = h_general;
1221: break;
1222:
1223: case h_transfer_encoding:
1224: /* looking for 'Transfer-Encoding: chunked' */
1225: if ('c' == c) {
1226: header_state = h_matching_transfer_encoding_chunked;
1227: } else {
1228: header_state = h_general;
1229: }
1230: break;
1231:
1232: case h_content_length:
1233: if (ch < '0' || ch > '9') goto error;
1234: parser->content_length = ch - '0';
1235: break;
1236:
1237: case h_connection:
1238: /* looking for 'Connection: keep-alive' */
1239: if (c == 'k') {
1240: header_state = h_matching_connection_keep_alive;
1241: /* looking for 'Connection: close' */
1242: } else if (c == 'c') {
1243: header_state = h_matching_connection_close;
1244: } else {
1245: header_state = h_general;
1246: }
1247: break;
1248:
1249: default:
1250: header_state = h_general;
1251: break;
1252: }
1253: break;
1254: }
1255:
1256: case s_header_value:
1257: {
1258: c = LOWER(ch);
1259:
1260: if (ch == CR) {
1261: CALLBACK(header_value);
1262: state = s_header_almost_done;
1263: break;
1264: }
1265:
1266: if (ch == LF) {
1267: CALLBACK(header_value);
1268: goto header_almost_done;
1269: }
1270:
1271: switch (header_state) {
1272: case h_general:
1273: break;
1274:
1275: case h_connection:
1276: case h_transfer_encoding:
1277: assert(0 && "Shouldn't get here.");
1278: break;
1279:
1280: case h_content_length:
1281: if (ch == ' ') break;
1282: if (ch < '0' || ch > '9') goto error;
1283: parser->content_length *= 10;
1284: parser->content_length += ch - '0';
1285: break;
1286:
1287: /* Transfer-Encoding: chunked */
1288: case h_matching_transfer_encoding_chunked:
1289: index++;
1290: if (index > sizeof(CHUNKED)-1
1291: || c != CHUNKED[index]) {
1292: header_state = h_general;
1293: } else if (index == sizeof(CHUNKED)-2) {
1294: header_state = h_transfer_encoding_chunked;
1295: }
1296: break;
1297:
1298: /* looking for 'Connection: keep-alive' */
1299: case h_matching_connection_keep_alive:
1300: index++;
1301: if (index > sizeof(KEEP_ALIVE)-1
1302: || c != KEEP_ALIVE[index]) {
1303: header_state = h_general;
1304: } else if (index == sizeof(KEEP_ALIVE)-2) {
1305: header_state = h_connection_keep_alive;
1306: }
1307: break;
1308:
1309: /* looking for 'Connection: close' */
1310: case h_matching_connection_close:
1311: index++;
1312: if (index > sizeof(CLOSE)-1 || c != CLOSE[index]) {
1313: header_state = h_general;
1314: } else if (index == sizeof(CLOSE)-2) {
1315: header_state = h_connection_close;
1316: }
1317: break;
1318:
1319: case h_transfer_encoding_chunked:
1320: case h_connection_keep_alive:
1321: case h_connection_close:
1322: if (ch != ' ') header_state = h_general;
1323: break;
1324:
1325: default:
1326: state = s_header_value;
1327: header_state = h_general;
1328: break;
1329: }
1330: break;
1331: }
1332:
1333: case s_header_almost_done:
1334: header_almost_done:
1335: {
1336: STRICT_CHECK(ch != LF);
1337:
1338: state = s_header_field_start;
1339:
1340: switch (header_state) {
1341: case h_connection_keep_alive:
1342: parser->flags |= F_CONNECTION_KEEP_ALIVE;
1343: break;
1344: case h_connection_close:
1345: parser->flags |= F_CONNECTION_CLOSE;
1346: break;
1347: case h_transfer_encoding_chunked:
1348: parser->flags |= F_CHUNKED;
1349: break;
1350: default:
1351: break;
1352: }
1353: break;
1354: }
1355:
1356: case s_headers_almost_done:
1357: headers_almost_done:
1358: {
1359: STRICT_CHECK(ch != LF);
1360:
1361: if (parser->flags & F_TRAILING) {
1362: /* End of a chunked request */
1363: CALLBACK2(message_complete);
1364: state = NEW_MESSAGE();
1365: break;
1366: }
1367:
1368: nread = 0;
1369:
1370: if (parser->flags & F_UPGRADE || parser->method == PHP_HTTP_CONNECT) {
1371: parser->upgrade = 1;
1372: }
1373:
1374: /* Here we call the headers_complete callback. This is somewhat
1375: * different than other callbacks because if the user returns 1, we
1376: * will interpret that as saying that this message has no body. This
1377: * is needed for the annoying case of recieving a response to a HEAD
1378: * request.
1379: */
1380: if (settings->on_headers_complete) {
1381: switch (settings->on_headers_complete(parser)) {
1382: case 0:
1383: break;
1384:
1385: case 1:
1386: parser->flags |= F_SKIPBODY;
1387: break;
1388:
1389: default:
1390: return p - data; /* Error */
1391: }
1392: }
1393:
1394: /* Exit, the rest of the connect is in a different protocol. */
1395: if (parser->upgrade) {
1396: CALLBACK2(message_complete);
1397: return (p - data);
1398: }
1399:
1400: if (parser->flags & F_SKIPBODY) {
1401: CALLBACK2(message_complete);
1402: state = NEW_MESSAGE();
1403: } else if (parser->flags & F_CHUNKED) {
1404: /* chunked encoding - ignore Content-Length header */
1405: state = s_chunk_size_start;
1406: } else {
1407: if (parser->content_length == 0) {
1408: /* Content-Length header given but zero: Content-Length: 0\r\n */
1409: CALLBACK2(message_complete);
1410: state = NEW_MESSAGE();
1411: } else if (parser->content_length > 0) {
1412: /* Content-Length header given and non-zero */
1413: state = s_body_identity;
1414: } else {
1415: if (parser->type == PHP_HTTP_REQUEST || php_http_should_keep_alive(parser)) {
1416: /* Assume content-length 0 - read the next */
1417: CALLBACK2(message_complete);
1418: state = NEW_MESSAGE();
1419: } else {
1420: /* Read body until EOF */
1421: state = s_body_identity_eof;
1422: }
1423: }
1424: }
1425:
1426: break;
1427: }
1428:
1429: case s_body_identity:
1430: to_read = MIN(pe - p, (size_t)parser->content_length);
1431: if (to_read > 0) {
1432: if (settings->on_body) settings->on_body(parser, p, to_read);
1433: p += to_read - 1;
1434: parser->content_length -= to_read;
1435: if (parser->content_length == 0) {
1436: CALLBACK2(message_complete);
1437: state = NEW_MESSAGE();
1438: }
1439: }
1440: break;
1441:
1442: /* read until EOF */
1443: case s_body_identity_eof:
1444: to_read = pe - p;
1445: if (to_read > 0) {
1446: if (settings->on_body) settings->on_body(parser, p, to_read);
1447: p += to_read - 1;
1448: }
1449: break;
1450:
1451: case s_chunk_size_start:
1452: {
1453: assert(parser->flags & F_CHUNKED);
1454:
1455: c = unhex[(unsigned char)ch];
1456: if (c == -1) goto error;
1457: parser->content_length = c;
1458: state = s_chunk_size;
1459: break;
1460: }
1461:
1462: case s_chunk_size:
1463: {
1464: assert(parser->flags & F_CHUNKED);
1465:
1466: if (ch == CR) {
1467: state = s_chunk_size_almost_done;
1468: break;
1469: }
1470:
1471: c = unhex[(unsigned char)ch];
1472:
1473: if (c == -1) {
1474: if (ch == ';' || ch == ' ') {
1475: state = s_chunk_parameters;
1476: break;
1477: }
1478: goto error;
1479: }
1480:
1481: parser->content_length *= 16;
1482: parser->content_length += c;
1483: break;
1484: }
1485:
1486: case s_chunk_parameters:
1487: {
1488: assert(parser->flags & F_CHUNKED);
1489: /* just ignore this shit. TODO check for overflow */
1490: if (ch == CR) {
1491: state = s_chunk_size_almost_done;
1492: break;
1493: }
1494: break;
1495: }
1496:
1497: case s_chunk_size_almost_done:
1498: {
1499: assert(parser->flags & F_CHUNKED);
1500: STRICT_CHECK(ch != LF);
1501:
1502: if (parser->content_length == 0) {
1503: parser->flags |= F_TRAILING;
1504: state = s_header_field_start;
1505: } else {
1506: state = s_chunk_data;
1507: }
1508: break;
1509: }
1510:
1511: case s_chunk_data:
1512: {
1513: assert(parser->flags & F_CHUNKED);
1514:
1515: to_read = MIN(pe - p, (size_t)(parser->content_length));
1516:
1517: if (to_read > 0) {
1518: if (settings->on_body) settings->on_body(parser, p, to_read);
1519: p += to_read - 1;
1520: }
1521:
1522: if (to_read == parser->content_length) {
1523: state = s_chunk_data_almost_done;
1524: }
1525:
1526: parser->content_length -= to_read;
1527: break;
1528: }
1529:
1530: case s_chunk_data_almost_done:
1531: assert(parser->flags & F_CHUNKED);
1532: STRICT_CHECK(ch != CR);
1533: state = s_chunk_data_done;
1534: break;
1535:
1536: case s_chunk_data_done:
1537: assert(parser->flags & F_CHUNKED);
1538: STRICT_CHECK(ch != LF);
1539: state = s_chunk_size_start;
1540: break;
1541:
1542: default:
1543: assert(0 && "unhandled state");
1544: goto error;
1545: }
1546: }
1547:
1548: CALLBACK_NOCLEAR(header_field);
1549: CALLBACK_NOCLEAR(header_value);
1550: CALLBACK_NOCLEAR(fragment);
1551: CALLBACK_NOCLEAR(query_string);
1552: CALLBACK_NOCLEAR(path);
1553: CALLBACK_NOCLEAR(url);
1554:
1555: parser->state = state;
1556: parser->header_state = header_state;
1557: parser->index = index;
1558: parser->nread = nread;
1559:
1560: return len;
1561:
1562: error:
1563: parser->state = s_dead;
1564: return (p - data);
1565: }
1566:
1567:
1568: int
1569: php_http_should_keep_alive (php_http_parser *parser)
1570: {
1571: if (parser->http_major > 0 && parser->http_minor > 0) {
1572: /* HTTP/1.1 */
1573: if (parser->flags & F_CONNECTION_CLOSE) {
1574: return 0;
1575: } else {
1576: return 1;
1577: }
1578: } else {
1579: /* HTTP/1.0 or earlier */
1580: if (parser->flags & F_CONNECTION_KEEP_ALIVE) {
1581: return 1;
1582: } else {
1583: return 0;
1584: }
1585: }
1586: }
1587:
1588:
1589: const char * php_http_method_str (enum php_http_method m)
1590: {
1591: return method_strings[m];
1592: }
1593:
1594:
1595: void
1596: php_http_parser_init (php_http_parser *parser, enum php_http_parser_type t)
1597: {
1598: parser->type = t;
1599: parser->state = (t == PHP_HTTP_REQUEST ? s_start_req : (t == PHP_HTTP_RESPONSE ? s_start_res : s_start_req_or_res));
1600: parser->nread = 0;
1601: parser->upgrade = 0;
1602: parser->flags = 0;
1603: parser->method = 0;
1604: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to php_http_parser.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / sapi / cli