projects / m6w6 / ext-http / blob
? search:
summary | shortlog | log | commit | commitdiff | tree | github
history | raw | HEAD
fix missing files in package.xml; [ci skip]
[m6w6/ext-http] / php_http_header_parser.c
1 /*
2 +--------------------------------------------------------------------+
3 | PECL :: http |
4 +--------------------------------------------------------------------+
5 | Redistribution and use in source and binary forms, with or without |
6 | modification, are permitted provided that the conditions mentioned |
7 | in the accompanying LICENSE file are met. |
8 +--------------------------------------------------------------------+
9 | Copyright (c) 2004-2014, Michael Wallner <mike@php.net> |
10 +--------------------------------------------------------------------+
11 */
12
13 #include "php_http_api.h"
14
15 #ifndef DBG_PARSER
16 # define DBG_PARSER 0
17 #endif
18
19 typedef struct php_http_header_parser_state_spec {
20 php_http_header_parser_state_t state;
21 unsigned need_data:1;
22 } php_http_header_parser_state_spec_t;
23
24 static const php_http_header_parser_state_spec_t php_http_header_parser_states[] = {
25 {PHP_HTTP_HEADER_PARSER_STATE_START, 1},
26 {PHP_HTTP_HEADER_PARSER_STATE_KEY, 1},
27 {PHP_HTTP_HEADER_PARSER_STATE_VALUE, 1},
28 {PHP_HTTP_HEADER_PARSER_STATE_VALUE_EX, 0},
29 {PHP_HTTP_HEADER_PARSER_STATE_HEADER_DONE, 0},
30 {PHP_HTTP_HEADER_PARSER_STATE_DONE, 0}
31 };
32
33 php_http_header_parser_t *php_http_header_parser_init(php_http_header_parser_t *parser)
34 {
35 if (!parser) {
36 parser = emalloc(sizeof(*parser));
37 }
38 memset(parser, 0, sizeof(*parser));
39
40 return parser;
41 }
42
43 php_http_header_parser_state_t php_http_header_parser_state_push(php_http_header_parser_t *parser, unsigned argc, ...)
44 {
45 va_list va_args;
46 unsigned i;
47 php_http_header_parser_state_t state = 0;
48
49 /* short circuit */
50 ZEND_PTR_STACK_RESIZE_IF_NEEDED((&parser->stack), argc);
51
52 va_start(va_args, argc);
53 for (i = 0; i < argc; ++i) {
54 state = va_arg(va_args, php_http_header_parser_state_t);
55 zend_ptr_stack_push(&parser->stack, (void *) state);
56 }
57 va_end(va_args);
58
59 return state;
60 }
61
62 php_http_header_parser_state_t php_http_header_parser_state_is(php_http_header_parser_t *parser)
63 {
64 if (parser->stack.top) {
65 return (php_http_header_parser_state_t) parser->stack.elements[parser->stack.top - 1];
66 }
67
68 return PHP_HTTP_HEADER_PARSER_STATE_START;
69 }
70
71 php_http_header_parser_state_t php_http_header_parser_state_pop(php_http_header_parser_t *parser)
72 {
73 if (parser->stack.top) {
74 return (php_http_header_parser_state_t) zend_ptr_stack_pop(&parser->stack);
75 }
76
77 return PHP_HTTP_HEADER_PARSER_STATE_START;
78 }
79
80 void php_http_header_parser_dtor(php_http_header_parser_t *parser)
81 {
82 zend_ptr_stack_destroy(&parser->stack);
83 php_http_info_dtor(&parser->info);
84 PTR_FREE(parser->_key.str);
85 PTR_FREE(parser->_val.str);
86 }
87
88 void php_http_header_parser_free(php_http_header_parser_t **parser)
89 {
90 if (*parser) {
91 php_http_header_parser_dtor(*parser);
92 efree(*parser);
93 *parser = NULL;
94 }
95 }
96
97 /* NOTE: 'str' has to be null terminated */
98 static void php_http_header_parser_error(size_t valid_len, char *str, size_t len, const char *eol_str )
99 {
100 zend_string *escaped_str = zend_string_init(str, len, 0);
101
102 escaped_str = php_addcslashes(escaped_str, 1, ZEND_STRL("\x0..\x1F\x7F..\xFF"));
103
104 if (valid_len != len && (!eol_str || (str+valid_len) != eol_str)) {
105 php_error_docref(NULL, E_WARNING, "Failed to parse headers: unexpected character '\\%03o' at pos %zu of '%s'", str[valid_len], valid_len, escaped_str->val);
106 } else if (eol_str) {
107 php_error_docref(NULL, E_WARNING, "Failed to parse headers: unexpected end of line at pos %zu of '%s'", eol_str - str, escaped_str->val);
108 } else {
109 php_error_docref(NULL, E_WARNING, "Failed to parse headers: unexpected end of input at pos %zu of '%s'", len, escaped_str->val);
110 }
111
112 efree(escaped_str);
113 }
114
115 php_http_header_parser_state_t php_http_header_parser_parse(php_http_header_parser_t *parser, php_http_buffer_t *buffer, unsigned flags, HashTable *headers, php_http_info_callback_t callback_func, void *callback_arg)
116 {
117 while (buffer->used || !php_http_header_parser_states[php_http_header_parser_state_is(parser)].need_data) {
118 #if DBG_PARSER
119 const char *state[] = {"START", "KEY", "VALUE", "VALUE_EX", "HEADER_DONE", "DONE"};
120 fprintf(stderr, "#HP: %s (avail:%zu, num:%d cleanup:%u)\n", php_http_header_parser_state_is(parser) < 0 ? "FAILURE" : state[php_http_header_parser_state_is(parser)], buffer->used, headers?zend_hash_num_elements(headers):0, flags);
121 _dpf(0, buffer->data, buffer->used);
122 #endif
123 switch (php_http_header_parser_state_pop(parser)) {
124 case PHP_HTTP_HEADER_PARSER_STATE_FAILURE:
125 php_error_docref(NULL, E_WARNING, "Failed to parse headers");
126 return php_http_header_parser_state_push(parser, 1, PHP_HTTP_HEADER_PARSER_STATE_FAILURE);
127
128 case PHP_HTTP_HEADER_PARSER_STATE_START: {
129 char *ptr = buffer->data;
130
131 while (ptr - buffer->data < buffer->used && PHP_HTTP_IS_CTYPE(space, *ptr)) {
132 ++ptr;
133 }
134
135 php_http_buffer_cut(buffer, 0, ptr - buffer->data);
136 php_http_header_parser_state_push(parser, 1, PHP_HTTP_HEADER_PARSER_STATE_KEY);
137 break;
138 }
139
140 case PHP_HTTP_HEADER_PARSER_STATE_KEY: {
141 const char *colon, *eol_str = NULL;
142 int eol_len = 0;
143
144 /* fix buffer here, so eol_str pointer doesn't become obsolete afterwards */
145 php_http_buffer_fix(buffer);
146
147 if (buffer->data == (eol_str = php_http_locate_bin_eol(buffer->data, buffer->used, &eol_len))) {
148 /* end of headers */
149 php_http_buffer_cut(buffer, 0, eol_len);
150 php_http_header_parser_state_push(parser, 1, PHP_HTTP_HEADER_PARSER_STATE_DONE);
151 } else if (php_http_info_parse(&parser->info, buffer->data)) {
152 /* new message starting with request/response line */
153 if (callback_func) {
154 callback_func(callback_arg, &headers, &parser->info);
155 }
156 php_http_info_dtor(&parser->info);
157 php_http_buffer_cut(buffer, 0, eol_str + eol_len - buffer->data);
158 php_http_header_parser_state_push(parser, 1, PHP_HTTP_HEADER_PARSER_STATE_HEADER_DONE);
159 } else if ((colon = memchr(buffer->data, ':', buffer->used)) && (!eol_str || eol_str > colon)) {
160 /* header: string */
161 size_t valid_len;
162
163 parser->_key.len = colon - buffer->data;
164 parser->_key.str = estrndup(buffer->data, parser->_key.len);
165
166 valid_len = strspn(parser->_key.str, PHP_HTTP_HEADER_NAME_CHARS);
167 if (valid_len != parser->_key.len) {
168 php_http_header_parser_error(valid_len, parser->_key.str, parser->_key.len, eol_str);
169 PTR_SET(parser->_key.str, NULL);
170 return php_http_header_parser_state_push(parser, 1, PHP_HTTP_HEADER_PARSER_STATE_FAILURE);
171 }
172 while (PHP_HTTP_IS_CTYPE(space, *++colon) && *colon != '\n' && *colon != '\r');
173 php_http_buffer_cut(buffer, 0, colon - buffer->data);
174 php_http_header_parser_state_push(parser, 1, PHP_HTTP_HEADER_PARSER_STATE_VALUE);
175 } else if (eol_str || (flags & PHP_HTTP_HEADER_PARSER_CLEANUP)) {
176 /* neither reqeust/response line nor 'header:' string, or injected new line or NUL etc. */
177 php_http_header_parser_error(strspn(buffer->data, PHP_HTTP_HEADER_NAME_CHARS), buffer->data, buffer->used, eol_str);
178 return php_http_header_parser_state_push(parser, 1, PHP_HTTP_HEADER_PARSER_STATE_FAILURE);
179 } else {
180 /* keep feeding */
181 return php_http_header_parser_state_push(parser, 1, PHP_HTTP_HEADER_PARSER_STATE_KEY);
182 }
183 break;
184 }
185
186 case PHP_HTTP_HEADER_PARSER_STATE_VALUE: {
187 const char *eol_str;
188 int eol_len;
189
190 #define SET_ADD_VAL(slen, eol_len) \
191 do { \
192 const char *ptr = buffer->data; \
193 size_t len = slen; \
194 \
195 while (len > 0 && PHP_HTTP_IS_CTYPE(space, *ptr)) { \
196 ++ptr; \
197 --len; \
198 } \
199 while (len > 0 && PHP_HTTP_IS_CTYPE(space, ptr[len - 1])) { \
200 --len; \
201 } \
202 \
203 if (len > 0) { \
204 if (parser->_val.str) { \
205 parser->_val.str = erealloc(parser->_val.str, parser->_val.len + len + 2); \
206 parser->_val.str[parser->_val.len++] = ' '; \
207 memcpy(&parser->_val.str[parser->_val.len], ptr, len); \
208 parser->_val.len += len; \
209 parser->_val.str[parser->_val.len] = '\0'; \
210 } else { \
211 parser->_val.len = len; \
212 parser->_val.str = estrndup(ptr, len); \
213 } \
214 } \
215 php_http_buffer_cut(buffer, 0, slen + eol_len); \
216 } while (0)
217
218 if ((eol_str = php_http_locate_bin_eol(buffer->data, buffer->used, &eol_len))) {
219 SET_ADD_VAL(eol_str - buffer->data, eol_len);
220 php_http_header_parser_state_push(parser, 1, PHP_HTTP_HEADER_PARSER_STATE_VALUE_EX);
221 } else if (flags & PHP_HTTP_HEADER_PARSER_CLEANUP) {
222 if (buffer->used) {
223 SET_ADD_VAL(buffer->used, 0);
224 }
225 php_http_header_parser_state_push(parser, 1, PHP_HTTP_HEADER_PARSER_STATE_HEADER_DONE);
226 } else {
227 return php_http_header_parser_state_push(parser, 1, PHP_HTTP_HEADER_PARSER_STATE_VALUE);
228 }
229 break;
230 }
231
232 case PHP_HTTP_HEADER_PARSER_STATE_VALUE_EX:
233 if (buffer->used && (*buffer->data == ' ' || *buffer->data == '\t')) {
234 php_http_header_parser_state_push(parser, 1, PHP_HTTP_HEADER_PARSER_STATE_VALUE);
235 } else if (buffer->used || (flags & PHP_HTTP_HEADER_PARSER_CLEANUP)) {
236 php_http_header_parser_state_push(parser, 1, PHP_HTTP_HEADER_PARSER_STATE_HEADER_DONE);
237 } else {
238 /* keep feeding */
239 return php_http_header_parser_state_push(parser, 1, PHP_HTTP_HEADER_PARSER_STATE_VALUE_EX);
240 }
241 break;
242
243 case PHP_HTTP_HEADER_PARSER_STATE_HEADER_DONE:
244 if (parser->_key.str && parser->_val.str) {
245 zval tmp, *exist;
246 size_t valid_len = strlen(parser->_val.str);
247
248 /* check for truncation */
249 if (valid_len != parser->_val.len) {
250 php_http_header_parser_error(valid_len, parser->_val.str, parser->_val.len, NULL);
251
252 PTR_SET(parser->_key.str, NULL);
253 PTR_SET(parser->_val.str, NULL);
254
255 return php_http_header_parser_state_push(parser, 1, PHP_HTTP_HEADER_PARSER_STATE_FAILURE);
256 }
257
258 if (!headers && callback_func) {
259 callback_func(callback_arg, &headers, NULL);
260 }
261
262 php_http_pretty_key(parser->_key.str, parser->_key.len, 1, 1);
263 if ((exist = zend_symtable_str_find(headers, parser->_key.str, parser->_key.len))) {
264 convert_to_array(exist);
265 add_next_index_str(exist, php_http_cs2zs(parser->_val.str, parser->_val.len));
266 } else {
267 ZVAL_STR(&tmp, php_http_cs2zs(parser->_val.str, parser->_val.len));
268 zend_symtable_str_update(headers, parser->_key.str, parser->_key.len, &tmp);
269 }
270 parser->_val.str = NULL;
271 }
272
273 PTR_SET(parser->_key.str, NULL);
274 PTR_SET(parser->_val.str, NULL);
275
276 php_http_header_parser_state_push(parser, 1, PHP_HTTP_HEADER_PARSER_STATE_KEY);
277 break;
278
279 case PHP_HTTP_HEADER_PARSER_STATE_DONE:
280 return PHP_HTTP_HEADER_PARSER_STATE_DONE;
281 }
282 }
283
284 return php_http_header_parser_state_is(parser);
285 }
286
287 php_http_header_parser_state_t php_http_header_parser_parse_stream(php_http_header_parser_t *parser, php_http_buffer_t *buf, php_stream *s, unsigned flags, HashTable *headers, php_http_info_callback_t callback_func, void *callback_arg)
288 {
289 php_http_header_parser_state_t state = PHP_HTTP_HEADER_PARSER_STATE_START;
290
291 if (!buf->data) {
292 php_http_buffer_resize_ex(buf, 0x1000, 1, 0);
293 }
294 while (1) {
295 size_t justread = 0;
296 #if DBG_PARSER
297 const char *states[] = {"START", "KEY", "VALUE", "VALUE_EX", "HEADER_DONE", "DONE"};
298 fprintf(stderr, "#SHP: %s (f:%u)\n", states[state], flags);
299 #endif
300 /* resize if needed */
301 if (buf->free < 0x1000) {
302 php_http_buffer_resize_ex(buf, 0x1000, 1, 0);
303 }
304 switch (state) {
305 case PHP_HTTP_HEADER_PARSER_STATE_FAILURE:
306 case PHP_HTTP_HEADER_PARSER_STATE_DONE:
307 return state;
308
309 default:
310 /* read line */
311 php_stream_get_line(s, buf->data + buf->used, buf->free, &justread);
312 /* if we fail reading a whole line, try a single char */
313 if (!justread) {
314 int c = php_stream_getc(s);
315
316 if (c != EOF) {
317 char s[1] = {c};
318 justread = php_http_buffer_append(buf, s, 1);
319 }
320 }
321 php_http_buffer_account(buf, justread);
322 }
323
324 if (justread) {
325 state = php_http_header_parser_parse(parser, buf, flags, headers, callback_func, callback_arg);
326 } else if (php_stream_eof(s)) {
327 return php_http_header_parser_parse(parser, buf, flags | PHP_HTTP_HEADER_PARSER_CLEANUP, headers, callback_func, callback_arg);
328 } else {
329 return state;
330 }
331 }
332
333 return PHP_HTTP_HEADER_PARSER_STATE_DONE;
334 }
335
336 zend_class_entry *php_http_header_parser_class_entry;
337 static zend_object_handlers php_http_header_parser_object_handlers;
338
339 zend_object *php_http_header_parser_object_new(zend_class_entry *ce)
340 {
341 return &php_http_header_parser_object_new_ex(ce, NULL)->zo;
342 }
343
344 php_http_header_parser_object_t *php_http_header_parser_object_new_ex(zend_class_entry *ce, php_http_header_parser_t *parser)
345 {
346 php_http_header_parser_object_t *o;
347
348 o = ecalloc(1, sizeof(php_http_header_parser_object_t) + zend_object_properties_size(ce));
349 zend_object_std_init(&o->zo, ce);
350 object_properties_init(&o->zo, ce);
351
352 if (parser) {
353 o->parser = parser;
354 } else {
355 o->parser = php_http_header_parser_init(NULL);
356 }
357 o->buffer = php_http_buffer_new();
358
359 o->zo.handlers = &php_http_header_parser_object_handlers;
360
361 return o;
362 }
363
364 void php_http_header_parser_object_free(zend_object *object)
365 {
366 php_http_header_parser_object_t *o = PHP_HTTP_OBJ(object, NULL);
367
368 if (o->parser) {
369 php_http_header_parser_free(&o->parser);
370 }
371 if (o->buffer) {
372 php_http_buffer_free(&o->buffer);
373 }
374 zend_object_std_dtor(object);
375 }
376
377 ZEND_BEGIN_ARG_INFO_EX(ai_HttpHeaderParser_getState, 0, 0, 0)
378 ZEND_END_ARG_INFO();
379 static PHP_METHOD(HttpHeaderParser, getState)
380 {
381 php_http_header_parser_object_t *parser_obj = PHP_HTTP_OBJ(NULL, getThis());
382
383 zend_parse_parameters_none();
384 /* always return the real state */
385 RETVAL_LONG(php_http_header_parser_state_is(parser_obj->parser));
386 }
387
388 ZEND_BEGIN_ARG_INFO_EX(ai_HttpHeaderParser_parse, 0, 0, 3)
389 ZEND_ARG_INFO(0, data)
390 ZEND_ARG_INFO(0, flags)
391 ZEND_ARG_ARRAY_INFO(1, headers, 1)
392 ZEND_END_ARG_INFO();
393 static PHP_METHOD(HttpHeaderParser, parse)
394 {
395 php_http_header_parser_object_t *parser_obj;
396 zval *zmsg;
397 char *data_str;
398 size_t data_len;
399 zend_long flags;
400
401 php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "slz", &data_str, &data_len, &flags, &zmsg), invalid_arg, return);
402
403 ZVAL_DEREF(zmsg);
404 if (Z_TYPE_P(zmsg) != IS_ARRAY) {
405 zval_dtor(zmsg);
406 array_init(zmsg);
407 }
408 parser_obj = PHP_HTTP_OBJ(NULL, getThis());
409 php_http_buffer_append(parser_obj->buffer, data_str, data_len);
410 RETVAL_LONG(php_http_header_parser_parse(parser_obj->parser, parser_obj->buffer, flags, Z_ARRVAL_P(zmsg), NULL, NULL));
411 }
412
413 ZEND_BEGIN_ARG_INFO_EX(ai_HttpHeaderParser_stream, 0, 0, 3)
414 ZEND_ARG_INFO(0, stream)
415 ZEND_ARG_INFO(0, flags)
416 ZEND_ARG_ARRAY_INFO(1, headers, 1)
417 ZEND_END_ARG_INFO();
418 static PHP_METHOD(HttpHeaderParser, stream)
419 {
420 php_http_header_parser_object_t *parser_obj;
421 zend_error_handling zeh;
422 zval *zmsg, *zstream;
423 php_stream *s;
424 zend_long flags;
425
426 php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "rlz", &zstream, &flags, &zmsg), invalid_arg, return);
427
428 zend_replace_error_handling(EH_THROW, php_http_exception_unexpected_val_class_entry, &zeh);
429 php_stream_from_zval(s, zstream);
430 zend_restore_error_handling(&zeh);
431
432 ZVAL_DEREF(zmsg);
433 if (Z_TYPE_P(zmsg) != IS_ARRAY) {
434 zval_dtor(zmsg);
435 array_init(zmsg);
436 }
437 parser_obj = PHP_HTTP_OBJ(NULL, getThis());
438 RETVAL_LONG(php_http_header_parser_parse_stream(parser_obj->parser, parser_obj->buffer, s, flags, Z_ARRVAL_P(zmsg), NULL, NULL));
439 }
440
441 static zend_function_entry php_http_header_parser_methods[] = {
442 PHP_ME(HttpHeaderParser, getState, ai_HttpHeaderParser_getState, ZEND_ACC_PUBLIC)
443 PHP_ME(HttpHeaderParser, parse, ai_HttpHeaderParser_parse, ZEND_ACC_PUBLIC)
444 PHP_ME(HttpHeaderParser, stream, ai_HttpHeaderParser_stream, ZEND_ACC_PUBLIC)
445 {NULL, NULL, NULL}
446 };
447
448 PHP_MINIT_FUNCTION(http_header_parser)
449 {
450 zend_class_entry ce;
451
452 INIT_NS_CLASS_ENTRY(ce, "http\\Header", "Parser", php_http_header_parser_methods);
453 php_http_header_parser_class_entry = zend_register_internal_class(&ce);
454 memcpy(&php_http_header_parser_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
455 php_http_header_parser_class_entry->create_object = php_http_header_parser_object_new;
456 php_http_header_parser_object_handlers.offset = XtOffsetOf(php_http_header_parser_object_t, zo);
457 php_http_header_parser_object_handlers.clone_obj = NULL;
458 php_http_header_parser_object_handlers.free_obj = php_http_header_parser_object_free;
459
460 zend_declare_class_constant_long(php_http_header_parser_class_entry, ZEND_STRL("CLEANUP"), PHP_HTTP_HEADER_PARSER_CLEANUP);
461
462 zend_declare_class_constant_long(php_http_header_parser_class_entry, ZEND_STRL("STATE_FAILURE"), PHP_HTTP_HEADER_PARSER_STATE_FAILURE);
463 zend_declare_class_constant_long(php_http_header_parser_class_entry, ZEND_STRL("STATE_START"), PHP_HTTP_HEADER_PARSER_STATE_START);
464 zend_declare_class_constant_long(php_http_header_parser_class_entry, ZEND_STRL("STATE_KEY"), PHP_HTTP_HEADER_PARSER_STATE_KEY);
465 zend_declare_class_constant_long(php_http_header_parser_class_entry, ZEND_STRL("STATE_VALUE"), PHP_HTTP_HEADER_PARSER_STATE_VALUE);
466 zend_declare_class_constant_long(php_http_header_parser_class_entry, ZEND_STRL("STATE_VALUE_EX"), PHP_HTTP_HEADER_PARSER_STATE_VALUE_EX);
467 zend_declare_class_constant_long(php_http_header_parser_class_entry, ZEND_STRL("STATE_HEADER_DONE"), PHP_HTTP_HEADER_PARSER_STATE_HEADER_DONE);
468 zend_declare_class_constant_long(php_http_header_parser_class_entry, ZEND_STRL("STATE_DONE"), PHP_HTTP_HEADER_PARSER_STATE_DONE);
469
470 return SUCCESS;
471 }
472
473 /*
474 * Local variables:
475 * tab-width: 4
476 * c-basic-offset: 4
477 * End:
478 * vim600: noet sw=4 ts=4 fdm=marker
479 * vim<600: noet sw=4 ts=4
480 */
481
Extended HTTP Support