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