projects / m6w6 / ext-http / blob
? search:
summary | shortlog | log | commit | commitdiff | tree | github
history | raw | HEAD
this got implemented in zend API
[m6w6/ext-http] / php_http_message_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_message_parser_state_spec {
20 php_http_message_parser_state_t state;
21 unsigned need_data:1;
22 } php_http_message_parser_state_spec_t;
23
24 static const php_http_message_parser_state_spec_t php_http_message_parser_states[] = {
25 {PHP_HTTP_MESSAGE_PARSER_STATE_START, 1},
26 {PHP_HTTP_MESSAGE_PARSER_STATE_HEADER, 0},
27 {PHP_HTTP_MESSAGE_PARSER_STATE_HEADER_DONE, 0},
28 {PHP_HTTP_MESSAGE_PARSER_STATE_BODY, 0},
29 {PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DUMB, 1},
30 {PHP_HTTP_MESSAGE_PARSER_STATE_BODY_LENGTH, 1},
31 {PHP_HTTP_MESSAGE_PARSER_STATE_BODY_CHUNKED, 1},
32 {PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DONE, 0},
33 {PHP_HTTP_MESSAGE_PARSER_STATE_UPDATE_CL, 0},
34 {PHP_HTTP_MESSAGE_PARSER_STATE_DONE, 0}
35 };
36
37 #if DBG_PARSER
38 const char *php_http_message_parser_state_name(php_http_message_parser_state_t state) {
39 const char *states[] = {"START", "HEADER", "HEADER_DONE", "BODY", "BODY_DUMB", "BODY_LENGTH", "BODY_CHUNK", "BODY_DONE", "UPDATE_CL", "DONE"};
40
41 if (state < 0 || state > (sizeof(states)/sizeof(char*))-1) {
42 return "FAILURE";
43 }
44 return states[state];
45 }
46 #endif
47
48 php_http_message_parser_t *php_http_message_parser_init(php_http_message_parser_t *parser)
49 {
50 if (!parser) {
51 parser = emalloc(sizeof(*parser));
52 }
53 memset(parser, 0, sizeof(*parser));
54
55 php_http_header_parser_init(&parser->header);
56
57 return parser;
58 }
59
60 php_http_message_parser_state_t php_http_message_parser_state_push(php_http_message_parser_t *parser, unsigned argc, ...)
61 {
62 php_http_message_parser_state_t state = PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE;
63 va_list va_args;
64 unsigned i;
65
66 if (argc > 0) {
67 /* short circuit */
68 ZEND_PTR_STACK_RESIZE_IF_NEEDED((&parser->stack), argc);
69
70 va_start(va_args, argc);
71 for (i = 0; i < argc; ++i) {
72 state = va_arg(va_args, php_http_message_parser_state_t);
73 zend_ptr_stack_push(&parser->stack, (void *) state);
74 }
75 va_end(va_args);
76 }
77
78 return state;
79 }
80
81 php_http_message_parser_state_t php_http_message_parser_state_is(php_http_message_parser_t *parser)
82 {
83 if (parser->stack.top) {
84 return (php_http_message_parser_state_t) parser->stack.elements[parser->stack.top - 1];
85 }
86 return PHP_HTTP_MESSAGE_PARSER_STATE_START;
87 }
88
89 php_http_message_parser_state_t php_http_message_parser_state_pop(php_http_message_parser_t *parser)
90 {
91 if (parser->stack.top) {
92 return (php_http_message_parser_state_t) zend_ptr_stack_pop(&parser->stack);
93 }
94 return PHP_HTTP_MESSAGE_PARSER_STATE_START;
95 }
96
97 void php_http_message_parser_dtor(php_http_message_parser_t *parser)
98 {
99 php_http_header_parser_dtor(&parser->header);
100 zend_ptr_stack_destroy(&parser->stack);
101 php_http_message_free(&parser->message);
102 if (parser->dechunk) {
103 php_http_encoding_stream_free(&parser->dechunk);
104 }
105 if (parser->inflate) {
106 php_http_encoding_stream_free(&parser->inflate);
107 }
108 }
109
110 void php_http_message_parser_free(php_http_message_parser_t **parser)
111 {
112 if (*parser) {
113 php_http_message_parser_dtor(*parser);
114 efree(*parser);
115 *parser = NULL;
116 }
117 }
118
119 php_http_message_parser_state_t php_http_message_parser_parse_stream(php_http_message_parser_t *parser, php_http_buffer_t *buf, php_stream *s, unsigned flags, php_http_message_t **message)
120 {
121 php_http_message_parser_state_t state = PHP_HTTP_MESSAGE_PARSER_STATE_START;
122
123 if (!buf->data) {
124 php_http_buffer_resize_ex(buf, 0x1000, 1, 0);
125 }
126 while (1) {
127 size_t justread = 0;
128 #if DBG_PARSER
129 fprintf(stderr, "#SP: %s (f:%u)\n", php_http_message_parser_state_name(state), flags);
130 #endif
131 /* resize if needed */
132 if (buf->free < 0x1000) {
133 php_http_buffer_resize_ex(buf, 0x1000, 1, 0);
134 }
135 switch (state) {
136 case PHP_HTTP_MESSAGE_PARSER_STATE_START:
137 case PHP_HTTP_MESSAGE_PARSER_STATE_HEADER:
138 case PHP_HTTP_MESSAGE_PARSER_STATE_HEADER_DONE:
139 /* read line */
140 php_stream_get_line(s, buf->data + buf->used, buf->free, &justread);
141 /* if we fail reading a whole line, try a single char */
142 if (!justread) {
143 int c = php_stream_getc(s);
144
145 if (c != EOF) {
146 char s[1] = {c};
147 justread = php_http_buffer_append(buf, s, 1);
148 }
149 }
150 php_http_buffer_account(buf, justread);
151 break;
152
153 case PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DUMB:
154 /* read all */
155 justread = php_stream_read(s, buf->data + buf->used, buf->free);
156 php_http_buffer_account(buf, justread);
157 break;
158
159 case PHP_HTTP_MESSAGE_PARSER_STATE_BODY_LENGTH:
160 /* read body_length */
161 justread = php_stream_read(s, buf->data + buf->used, MIN(buf->free, parser->body_length));
162 php_http_buffer_account(buf, justread);
163 break;
164
165 case PHP_HTTP_MESSAGE_PARSER_STATE_BODY_CHUNKED:
166 /* duh, this is very naive */
167 if (parser->body_length) {
168 justread = php_stream_read(s, buf->data + buf->used, MIN(parser->body_length, buf->free));
169
170 php_http_buffer_account(buf, justread);
171
172 parser->body_length -= justread;
173 } else {
174 php_http_buffer_resize(buf, 24);
175 php_stream_get_line(s, buf->data, buf->free, &justread);
176 php_http_buffer_account(buf, justread);
177
178 parser->body_length = strtoul(buf->data + buf->used - justread, NULL, 16);
179 }
180 break;
181
182 case PHP_HTTP_MESSAGE_PARSER_STATE_BODY:
183 case PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DONE:
184 case PHP_HTTP_MESSAGE_PARSER_STATE_UPDATE_CL:
185 /* should not occur */
186 abort();
187 break;
188
189 case PHP_HTTP_MESSAGE_PARSER_STATE_DONE:
190 case PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE:
191 return php_http_message_parser_state_is(parser);
192 }
193
194 if (justread) {
195 state = php_http_message_parser_parse(parser, buf, flags, message);
196 } else if (php_stream_eof(s)) {
197 return php_http_message_parser_parse(parser, buf, flags | PHP_HTTP_MESSAGE_PARSER_CLEANUP, message);
198 } else {
199 return state;
200 }
201 }
202
203 return PHP_HTTP_MESSAGE_PARSER_STATE_DONE;
204 }
205
206
207 php_http_message_parser_state_t php_http_message_parser_parse(php_http_message_parser_t *parser, php_http_buffer_t *buffer, unsigned flags, php_http_message_t **message)
208 {
209 char *str = NULL;
210 size_t len = 0;
211 size_t cut = 0;
212
213 while (buffer->used || !php_http_message_parser_states[php_http_message_parser_state_is(parser)].need_data) {
214 #if DBG_PARSER
215 fprintf(stderr, "#MP: %s (f: %u, t:%d, l:%zu)\n",
216 php_http_message_parser_state_name(php_http_message_parser_state_is(parser)),
217 flags,
218 message && *message ? (*message)->type : -1,
219 buffer->used
220 );
221 _dpf(0, buffer->data, buffer->used);
222 #endif
223
224 switch (php_http_message_parser_state_pop(parser))
225 {
226 case PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE:
227 return php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE);
228
229 case PHP_HTTP_MESSAGE_PARSER_STATE_START:
230 {
231 char *ptr = buffer->data;
232
233 while (ptr - buffer->data < buffer->used && PHP_HTTP_IS_CTYPE(space, *ptr)) {
234 ++ptr;
235 }
236
237 php_http_buffer_cut(buffer, 0, ptr - buffer->data);
238
239 if (buffer->used) {
240 php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_HEADER);
241 }
242 break;
243 }
244
245 case PHP_HTTP_MESSAGE_PARSER_STATE_HEADER:
246 {
247 unsigned header_parser_flags = (flags & PHP_HTTP_MESSAGE_PARSER_CLEANUP) ? PHP_HTTP_HEADER_PARSER_CLEANUP : 0;
248
249 switch (php_http_header_parser_parse(&parser->header, buffer, header_parser_flags, *message ? &(*message)->hdrs : NULL, (php_http_info_callback_t) php_http_message_info_callback, message)) {
250 case PHP_HTTP_HEADER_PARSER_STATE_FAILURE:
251 return PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE;
252
253 case PHP_HTTP_HEADER_PARSER_STATE_DONE:
254 php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_HEADER_DONE);
255 break;
256
257 default:
258 if (buffer->used || !(flags & PHP_HTTP_MESSAGE_PARSER_CLEANUP)) {
259 return php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_HEADER);
260 } else {
261 php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_HEADER_DONE);
262 }
263 }
264 break;
265 }
266
267 case PHP_HTTP_MESSAGE_PARSER_STATE_HEADER_DONE:
268 {
269 zval h, *h_ptr, *h_loc = NULL, *h_con = NULL, *h_ce;
270 zend_bool chunked = 0;
271 zend_long content_length = -1;
272 zend_string *content_range = NULL;
273
274 /* Content-Range has higher precedence than Content-Length,
275 * and content-length denotes the original length of the entity,
276 * so let's *NOT* remove CR/CL, because that would fundamentally
277 * change the meaning of the whole message
278 */
279 if ((h_ptr = php_http_message_header(*message, ZEND_STRL("Transfer-Encoding")))) {
280 zend_string *zs = zval_get_string(h_ptr);
281
282 chunked = zend_string_equals_literal(zs, "chunked");
283 zend_string_release(zs);
284
285 Z_TRY_ADDREF_P(h_ptr);
286 zend_hash_str_update(&(*message)->hdrs, "X-Original-Transfer-Encoding", lenof("X-Original-Transfer-Encoding"), h_ptr);
287 zend_hash_str_del(&(*message)->hdrs, "Transfer-Encoding", lenof("Transfer-Encoding"));
288
289 /* reset */
290 ZVAL_LONG(&h, 0);
291 zend_hash_str_update(&(*message)->hdrs, "Content-Length", lenof("Content-Length"), &h);
292 } else if ((h_ptr = php_http_message_header(*message, ZEND_STRL("Content-Length")))) {
293 content_length = zval_get_long(h_ptr);
294 Z_TRY_ADDREF_P(h_ptr);
295 zend_hash_str_update(&(*message)->hdrs, "X-Original-Content-Length", lenof("X-Original-Content-Length"), h_ptr);
296 }
297
298 if ((content_range = php_http_message_header_string(*message, ZEND_STRL("Content-Range")))) {
299 ZVAL_STR_COPY(&h, content_range);
300 zend_hash_str_update(&(*message)->hdrs, "Content-Range", lenof("Content-Range"), &h);
301 }
302
303 /* so, if curl sees a 3xx code, a Location header and a Connection:close header
304 * it decides not to read the response body.
305 */
306 if ((flags & PHP_HTTP_MESSAGE_PARSER_EMPTY_REDIRECTS)
307 && (*message)->type == PHP_HTTP_RESPONSE
308 && (*message)->http.info.response.code/100 == 3
309 && (h_loc = php_http_message_header(*message, ZEND_STRL("Location")))
310 && (h_con = php_http_message_header(*message, ZEND_STRL("Connection")))
311 ) {
312 zend_string *con = zval_get_string(h_con);
313
314 if (php_http_match(con->val, "close", PHP_HTTP_MATCH_WORD)) {
315 zend_string_release(con);
316 php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_DONE);
317 break;
318 }
319 zend_string_release(con);
320 }
321
322 if ((h_ce = php_http_message_header(*message, ZEND_STRL("Content-Encoding")))) {
323 zend_string *ce = zval_get_string(h_ce);
324
325 if (php_http_match(ce->val, "gzip", PHP_HTTP_MATCH_WORD)
326 || php_http_match(ce->val, "x-gzip", PHP_HTTP_MATCH_WORD)
327 || php_http_match(ce->val, "deflate", PHP_HTTP_MATCH_WORD)
328 ) {
329 if (parser->inflate) {
330 php_http_encoding_stream_reset(&parser->inflate);
331 } else {
332 parser->inflate = php_http_encoding_stream_init(NULL, php_http_encoding_stream_get_inflate_ops(), 0);
333 }
334 Z_TRY_ADDREF_P(h_ce);
335 zend_hash_str_update(&(*message)->hdrs, "X-Original-Content-Encoding", lenof("X-Original-Content-Encoding"), h_ce);
336 zend_hash_str_del(&(*message)->hdrs, "Content-Encoding", lenof("Content-Encoding"));
337 }
338 zend_string_release(ce);
339 }
340
341 if ((flags & PHP_HTTP_MESSAGE_PARSER_DUMB_BODIES)) {
342 php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DUMB);
343 } else {
344 if (chunked) {
345 parser->dechunk = php_http_encoding_stream_init(parser->dechunk, php_http_encoding_stream_get_dechunk_ops(), 0);
346 php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_BODY_CHUNKED);
347 break;
348 }
349
350 if (content_range) {
351 ulong total = 0, start = 0, end = 0;
352
353 if (!strncasecmp(content_range->val, "bytes", lenof("bytes"))
354 && ( content_range->val[lenof("bytes")] == ':'
355 || content_range->val[lenof("bytes")] == ' '
356 || content_range->val[lenof("bytes")] == '='
357 )
358 ) {
359 char *total_at = NULL, *end_at = NULL;
360 char *start_at = content_range->val + sizeof("bytes");
361
362 start = strtoul(start_at, &end_at, 10);
363 if (end_at) {
364 end = strtoul(end_at + 1, &total_at, 10);
365 if (total_at && strncmp(total_at + 1, "*", 1)) {
366 total = strtoul(total_at + 1, NULL, 10);
367 }
368
369 if (end >= start && (!total || end <= total)) {
370 parser->body_length = end + 1 - start;
371 php_http_message_parser_state_push(parser, 1, !parser->body_length?PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DONE:PHP_HTTP_MESSAGE_PARSER_STATE_BODY_LENGTH);
372 zend_string_release(content_range);
373 break;
374 }
375 }
376 }
377
378 zend_string_release(content_range);
379 }
380
381 if (content_length >= 0) {
382 parser->body_length = content_length;
383 php_http_message_parser_state_push(parser, 1, !parser->body_length?PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DONE:PHP_HTTP_MESSAGE_PARSER_STATE_BODY_LENGTH);
384 break;
385 }
386
387 if ((*message)->type == PHP_HTTP_REQUEST) {
388 php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_DONE);
389 } else {
390 php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DUMB);
391 }
392 }
393 break;
394 }
395
396 case PHP_HTTP_MESSAGE_PARSER_STATE_BODY:
397 {
398 if (len) {
399 if (parser->inflate) {
400 char *dec_str = NULL;
401 size_t dec_len;
402
403 if (SUCCESS != php_http_encoding_stream_update(parser->inflate, str, len, &dec_str, &dec_len)) {
404 return php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE);
405 }
406
407 if (str != buffer->data) {
408 PTR_FREE(str);
409 }
410 str = dec_str;
411 len = dec_len;
412 }
413
414 php_stream_write(php_http_message_body_stream((*message)->body), str, len);
415 }
416
417 if (cut) {
418 php_http_buffer_cut(buffer, 0, cut);
419 }
420
421 if (str != buffer->data) {
422 PTR_FREE(str);
423 }
424
425 str = NULL;
426 len = 0;
427 cut = 0;
428 break;
429 }
430
431 case PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DUMB:
432 {
433 str = buffer->data;
434 len = buffer->used;
435 cut = len;
436
437 php_http_message_parser_state_push(parser, 2, PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DONE, PHP_HTTP_MESSAGE_PARSER_STATE_BODY);
438 break;
439 }
440
441 case PHP_HTTP_MESSAGE_PARSER_STATE_BODY_LENGTH:
442 {
443 len = MIN(parser->body_length, buffer->used);
444 str = buffer->data;
445 cut = len;
446
447 parser->body_length -= len;
448
449 php_http_message_parser_state_push(parser, 2, !parser->body_length?PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DONE:PHP_HTTP_MESSAGE_PARSER_STATE_BODY_LENGTH, PHP_HTTP_MESSAGE_PARSER_STATE_BODY);
450 break;
451 }
452
453 case PHP_HTTP_MESSAGE_PARSER_STATE_BODY_CHUNKED:
454 {
455 /*
456 * - pass available data through the dechunk stream
457 * - pass decoded data along
458 * - if stream zeroed:
459 * Y: - cut processed string out of buffer, but leave length of unprocessed dechunk stream data untouched
460 * - body done
461 * N: - parse ahaed
462 */
463 char *dec_str = NULL;
464 size_t dec_len;
465
466 if (SUCCESS != php_http_encoding_stream_update(parser->dechunk, buffer->data, buffer->used, &dec_str, &dec_len)) {
467 return PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE;
468 }
469
470 str = dec_str;
471 len = dec_len;
472
473 if (php_http_encoding_stream_done(parser->dechunk)) {
474 cut = buffer->used - PHP_HTTP_BUFFER(parser->dechunk->ctx)->used;
475 php_http_message_parser_state_push(parser, 2, PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DONE, PHP_HTTP_MESSAGE_PARSER_STATE_BODY);
476 } else {
477 cut = buffer->used;
478 php_http_message_parser_state_push(parser, 2, PHP_HTTP_MESSAGE_PARSER_STATE_BODY_CHUNKED, PHP_HTTP_MESSAGE_PARSER_STATE_BODY);
479 }
480 break;
481 }
482
483 case PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DONE:
484 {
485 php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_DONE);
486
487 if (parser->dechunk && parser->dechunk->ctx) {
488 char *dec_str = NULL;
489 size_t dec_len;
490
491 if (SUCCESS != php_http_encoding_stream_finish(parser->dechunk, &dec_str, &dec_len)) {
492 return php_http_message_parser_state_push(parser, 1, PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE);
493 }
494 php_http_encoding_stream_dtor(parser->dechunk);
495
496 if (dec_str && dec_len) {
497 str = dec_str;
498 len = dec_len;
499 cut = 0;
500 php_http_message_parser_state_push(parser, 2, PHP_HTTP_MESSAGE_PARSER_STATE_UPDATE_CL, PHP_HTTP_MESSAGE_PARSER_STATE_BODY);
501 }
502 }
503
504 break;
505 }
506
507 case PHP_HTTP_MESSAGE_PARSER_STATE_UPDATE_CL:
508 {
509 zval zcl;
510
511 ZVAL_LONG(&zcl, php_http_message_body_size((*message)->body));
512 zend_hash_str_update(&(*message)->hdrs, "Content-Length", lenof("Content-Length"), &zcl);
513 break;
514 }
515
516 case PHP_HTTP_MESSAGE_PARSER_STATE_DONE:
517 {
518 char *ptr = buffer->data;
519
520 while (ptr - buffer->data < buffer->used && PHP_HTTP_IS_CTYPE(space, *ptr)) {
521 ++ptr;
522 }
523
524 php_http_buffer_cut(buffer, 0, ptr - buffer->data);
525
526 if (!(flags & PHP_HTTP_MESSAGE_PARSER_GREEDY)) {
527 return PHP_HTTP_MESSAGE_PARSER_STATE_DONE;
528 }
529 break;
530 }
531 }
532 }
533
534 return php_http_message_parser_state_is(parser);
535 }
536
537 zend_class_entry *php_http_message_parser_class_entry;
538 static zend_object_handlers php_http_message_parser_object_handlers;
539
540 zend_object *php_http_message_parser_object_new(zend_class_entry *ce)
541 {
542 return &php_http_message_parser_object_new_ex(ce, NULL)->zo;
543 }
544
545 php_http_message_parser_object_t *php_http_message_parser_object_new_ex(zend_class_entry *ce, php_http_message_parser_t *parser)
546 {
547 php_http_message_parser_object_t *o;
548
549 o = ecalloc(1, sizeof(*o) + zend_object_properties_size(ce));
550 zend_object_std_init(&o->zo, ce);
551 object_properties_init(&o->zo, ce);
552
553 if (parser) {
554 o->parser = parser;
555 } else {
556 o->parser = php_http_message_parser_init(NULL);
557 }
558 php_http_buffer_init(&o->buffer);
559 o->zo.handlers = &php_http_message_parser_object_handlers;
560
561 return o;
562 }
563
564 void php_http_message_parser_object_free(zend_object *object)
565 {
566 php_http_message_parser_object_t *o = PHP_HTTP_OBJ(object, NULL);
567
568 if (o->parser) {
569 php_http_message_parser_free(&o->parser);
570 }
571 php_http_buffer_dtor(&o->buffer);
572 zend_object_std_dtor(object);
573 }
574
575 ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessageParser_getState, 0, 0, 0)
576 ZEND_END_ARG_INFO();
577 static PHP_METHOD(HttpMessageParser, getState)
578 {
579 php_http_message_parser_object_t *parser_obj = PHP_HTTP_OBJ(NULL, getThis());
580
581 zend_parse_parameters_none();
582 /* always return the real state */
583 RETVAL_LONG(php_http_message_parser_state_is(parser_obj->parser));
584 }
585
586 ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessageParser_parse, 0, 0, 3)
587 ZEND_ARG_INFO(0, data)
588 ZEND_ARG_INFO(0, flags)
589 ZEND_ARG_INFO(1, message)
590 ZEND_END_ARG_INFO();
591 static PHP_METHOD(HttpMessageParser, parse)
592 {
593 php_http_message_parser_object_t *parser_obj;
594 zval *zmsg;
595 char *data_str;
596 size_t data_len;
597 zend_long flags;
598
599 php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "slz", &data_str, &data_len, &flags, &zmsg), invalid_arg, return);
600
601 parser_obj = PHP_HTTP_OBJ(NULL, getThis());
602 php_http_buffer_append(&parser_obj->buffer, data_str, data_len);
603 RETVAL_LONG(php_http_message_parser_parse(parser_obj->parser, &parser_obj->buffer, flags, &parser_obj->parser->message));
604
605 ZVAL_DEREF(zmsg);
606 zval_dtor(zmsg);
607 ZVAL_NULL(zmsg);
608 if (parser_obj->parser->message) {
609 php_http_message_t *msg_cpy = php_http_message_copy(parser_obj->parser->message, NULL);
610 php_http_message_object_t *msg_obj = php_http_message_object_new_ex(php_http_message_class_entry, msg_cpy);
611 ZVAL_OBJ(zmsg, &msg_obj->zo);
612 }
613 }
614
615 ZEND_BEGIN_ARG_INFO_EX(ai_HttpMessageParser_stream, 0, 0, 3)
616 ZEND_ARG_INFO(0, stream)
617 ZEND_ARG_INFO(0, flags)
618 ZEND_ARG_INFO(1, message)
619 ZEND_END_ARG_INFO();
620 static PHP_METHOD(HttpMessageParser, stream)
621 {
622 php_http_message_parser_object_t *parser_obj;
623 zend_error_handling zeh;
624 zval *zmsg, *zstream;
625 php_stream *s;
626 zend_long flags;
627
628 php_http_expect(SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlz", &zstream, &flags, &zmsg), invalid_arg, return);
629
630 zend_replace_error_handling(EH_THROW, php_http_exception_unexpected_val_class_entry, &zeh);
631 php_stream_from_zval(s, zstream);
632 zend_restore_error_handling(&zeh);
633
634 parser_obj = PHP_HTTP_OBJ(NULL, getThis());
635 RETVAL_LONG(php_http_message_parser_parse_stream(parser_obj->parser, &parser_obj->buffer, s, flags, &parser_obj->parser->message));
636
637 ZVAL_DEREF(zmsg);
638 zval_dtor(zmsg);
639 ZVAL_NULL(zmsg);
640 if (parser_obj->parser->message) {
641 php_http_message_t *msg_cpy = php_http_message_copy(parser_obj->parser->message, NULL);
642 php_http_message_object_t *msg_obj = php_http_message_object_new_ex(php_http_message_class_entry, msg_cpy);
643 ZVAL_OBJ(zmsg, &msg_obj->zo);
644 }
645 }
646
647 static zend_function_entry php_http_message_parser_methods[] = {
648 PHP_ME(HttpMessageParser, getState, ai_HttpMessageParser_getState, ZEND_ACC_PUBLIC)
649 PHP_ME(HttpMessageParser, parse, ai_HttpMessageParser_parse, ZEND_ACC_PUBLIC)
650 PHP_ME(HttpMessageParser, stream, ai_HttpMessageParser_stream, ZEND_ACC_PUBLIC)
651 {NULL, NULL, NULL}
652 };
653
654 PHP_MINIT_FUNCTION(http_message_parser)
655 {
656 zend_class_entry ce;
657
658 INIT_NS_CLASS_ENTRY(ce, "http\\Message", "Parser", php_http_message_parser_methods);
659 php_http_message_parser_class_entry = zend_register_internal_class(&ce);
660 memcpy(&php_http_message_parser_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
661 php_http_message_parser_class_entry->create_object = php_http_message_parser_object_new;
662 php_http_message_parser_object_handlers.clone_obj = NULL;
663 php_http_message_parser_object_handlers.free_obj = php_http_message_parser_object_free;
664 php_http_message_parser_object_handlers.offset = XtOffsetOf(php_http_message_parser_object_t, zo);
665
666 zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("CLEANUP"), PHP_HTTP_MESSAGE_PARSER_CLEANUP);
667 zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("DUMB_BODIES"), PHP_HTTP_MESSAGE_PARSER_DUMB_BODIES);
668 zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("EMPTY_REDIRECTS"), PHP_HTTP_MESSAGE_PARSER_EMPTY_REDIRECTS);
669 zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("GREEDY"), PHP_HTTP_MESSAGE_PARSER_GREEDY);
670
671 zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_FAILURE"), PHP_HTTP_MESSAGE_PARSER_STATE_FAILURE);
672 zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_START"), PHP_HTTP_MESSAGE_PARSER_STATE_START);
673 zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_HEADER"), PHP_HTTP_MESSAGE_PARSER_STATE_HEADER);
674 zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_HEADER_DONE"), PHP_HTTP_MESSAGE_PARSER_STATE_HEADER_DONE);
675 zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_BODY"), PHP_HTTP_MESSAGE_PARSER_STATE_BODY);
676 zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_BODY_DUMB"), PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DUMB);
677 zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_BODY_LENGTH"), PHP_HTTP_MESSAGE_PARSER_STATE_BODY_LENGTH);
678 zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_BODY_CHUNKED"), PHP_HTTP_MESSAGE_PARSER_STATE_BODY_CHUNKED);
679 zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_BODY_DONE"), PHP_HTTP_MESSAGE_PARSER_STATE_BODY_DONE);
680 zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_UPDATE_CL"), PHP_HTTP_MESSAGE_PARSER_STATE_UPDATE_CL);
681 zend_declare_class_constant_long(php_http_message_parser_class_entry, ZEND_STRL("STATE_DONE"), PHP_HTTP_MESSAGE_PARSER_STATE_DONE);
682
683 return SUCCESS;
684 }
685
686 /*
687 * Local variables:
688 * tab-width: 4
689 * c-basic-offset: 4
690 * End:
691 * vim600: noet sw=4 ts=4 fdm=marker
692 * vim<600: noet sw=4 ts=4
693 */
694
Extended HTTP Support