projects / m6w6 / ext-http / blob
? search:
summary | shortlog | log | commit | commitdiff | tree | github
history | raw | HEAD
- we're not interested in private properties
[m6w6/ext-http] / http_message_object.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-2007, Michael Wallner <mike@php.net> |
10 +--------------------------------------------------------------------+
11 */
12
13 /* $Id$ */
14
15 #define HTTP_WANT_SAPI
16 #define HTTP_WANT_CURL
17 #define HTTP_WANT_MAGIC
18 #include "php_http.h"
19
20 #ifdef ZEND_ENGINE_2
21
22 #include "zend_interfaces.h"
23 #include "ext/standard/url.h"
24
25 #include "php_http_api.h"
26 #include "php_http_send_api.h"
27 #include "php_http_url_api.h"
28 #include "php_http_message_api.h"
29 #include "php_http_message_object.h"
30 #include "php_http_exception_object.h"
31 #include "php_http_response_object.h"
32 #include "php_http_request_method_api.h"
33 #include "php_http_request_api.h"
34 #include "php_http_request_object.h"
35 #include "php_http_headers_api.h"
36
37 #if defined(HTTP_HAVE_SPL) && !defined(WONKY)
38 /* SPL doesn't install its headers */
39 extern PHPAPI zend_class_entry *spl_ce_Countable;
40 #endif
41
42 #define HTTP_BEGIN_ARGS(method, req_args) HTTP_BEGIN_ARGS_EX(HttpMessage, method, 0, req_args)
43 #define HTTP_EMPTY_ARGS(method) HTTP_EMPTY_ARGS_EX(HttpMessage, method, 0)
44 #define HTTP_MESSAGE_ME(method, visibility) PHP_ME(HttpMessage, method, HTTP_ARGS(HttpMessage, method), visibility)
45
46 HTTP_BEGIN_ARGS(__construct, 0)
47 HTTP_ARG_VAL(message, 0)
48 HTTP_END_ARGS;
49
50 HTTP_BEGIN_ARGS(factory, 0)
51 HTTP_ARG_VAL(message, 0)
52 HTTP_ARG_VAL(class_name, 0)
53 HTTP_END_ARGS;
54
55 HTTP_BEGIN_ARGS(fromEnv, 1)
56 HTTP_ARG_VAL(type, 0)
57 HTTP_ARG_VAL(class_name, 0)
58 HTTP_END_ARGS;
59
60 HTTP_EMPTY_ARGS(getBody);
61 HTTP_BEGIN_ARGS(setBody, 1)
62 HTTP_ARG_VAL(body, 0)
63 HTTP_END_ARGS;
64
65 HTTP_BEGIN_ARGS(getHeader, 1)
66 HTTP_ARG_VAL(header, 0)
67 HTTP_END_ARGS;
68
69 HTTP_EMPTY_ARGS(getHeaders);
70 HTTP_BEGIN_ARGS(setHeaders, 1)
71 HTTP_ARG_VAL(headers, 0)
72 HTTP_END_ARGS;
73
74 HTTP_BEGIN_ARGS(addHeaders, 1)
75 HTTP_ARG_VAL(headers, 0)
76 HTTP_ARG_VAL(append, 0)
77 HTTP_END_ARGS;
78
79 HTTP_EMPTY_ARGS(getType);
80 HTTP_BEGIN_ARGS(setType, 1)
81 HTTP_ARG_VAL(type, 0)
82 HTTP_END_ARGS;
83
84 HTTP_EMPTY_ARGS(getInfo);
85 HTTP_BEGIN_ARGS(setInfo, 1)
86 HTTP_ARG_VAL(http_info, 0)
87 HTTP_END_ARGS;
88
89 HTTP_EMPTY_ARGS(getResponseCode);
90 HTTP_BEGIN_ARGS(setResponseCode, 1)
91 HTTP_ARG_VAL(response_code, 0)
92 HTTP_END_ARGS;
93
94 HTTP_EMPTY_ARGS(getResponseStatus);
95 HTTP_BEGIN_ARGS(setResponseStatus, 1)
96 HTTP_ARG_VAL(response_status, 0)
97 HTTP_END_ARGS;
98
99 HTTP_EMPTY_ARGS(getRequestMethod);
100 HTTP_BEGIN_ARGS(setRequestMethod, 1)
101 HTTP_ARG_VAL(request_method, 0)
102 HTTP_END_ARGS;
103
104 HTTP_EMPTY_ARGS(getRequestUrl);
105 HTTP_BEGIN_ARGS(setRequestUrl, 1)
106 HTTP_ARG_VAL(url, 0)
107 HTTP_END_ARGS;
108
109 HTTP_EMPTY_ARGS(getHttpVersion);
110 HTTP_BEGIN_ARGS(setHttpVersion, 1)
111 HTTP_ARG_VAL(http_version, 0)
112 HTTP_END_ARGS;
113
114 HTTP_BEGIN_ARGS(guessContentType, 1)
115 HTTP_ARG_VAL(magic_file, 0)
116 HTTP_ARG_VAL(magic_mode, 0)
117 HTTP_END_ARGS;
118
119 HTTP_EMPTY_ARGS(getParentMessage);
120 HTTP_EMPTY_ARGS(send);
121 HTTP_BEGIN_ARGS(toString, 0)
122 HTTP_ARG_VAL(include_parent, 0)
123 HTTP_END_ARGS;
124
125 HTTP_EMPTY_ARGS(toMessageTypeObject);
126
127 HTTP_EMPTY_ARGS(count);
128
129 HTTP_EMPTY_ARGS(serialize);
130 HTTP_BEGIN_ARGS(unserialize, 1)
131 HTTP_ARG_VAL(serialized, 0)
132 HTTP_END_ARGS;
133
134 HTTP_EMPTY_ARGS(rewind);
135 HTTP_EMPTY_ARGS(valid);
136 HTTP_EMPTY_ARGS(key);
137 HTTP_EMPTY_ARGS(current);
138 HTTP_EMPTY_ARGS(next);
139
140 HTTP_EMPTY_ARGS(detach);
141 HTTP_BEGIN_ARGS(prepend, 1)
142 HTTP_ARG_OBJ(HttpMessage, message, 0)
143 HTTP_END_ARGS;
144 HTTP_EMPTY_ARGS(reverse);
145
146 #define http_message_object_read_prop _http_message_object_read_prop
147 static zval *_http_message_object_read_prop(zval *object, zval *member, int type TSRMLS_DC);
148 #define http_message_object_write_prop _http_message_object_write_prop
149 static void _http_message_object_write_prop(zval *object, zval *member, zval *value TSRMLS_DC);
150 #define http_message_object_get_props _http_message_object_get_props
151 static HashTable *_http_message_object_get_props(zval *object TSRMLS_DC);
152
153 #define THIS_CE http_message_object_ce
154 zend_class_entry *http_message_object_ce;
155 zend_function_entry http_message_object_fe[] = {
156 HTTP_MESSAGE_ME(__construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
157 HTTP_MESSAGE_ME(getBody, ZEND_ACC_PUBLIC)
158 HTTP_MESSAGE_ME(setBody, ZEND_ACC_PUBLIC)
159 HTTP_MESSAGE_ME(getHeader, ZEND_ACC_PUBLIC)
160 HTTP_MESSAGE_ME(getHeaders, ZEND_ACC_PUBLIC)
161 HTTP_MESSAGE_ME(setHeaders, ZEND_ACC_PUBLIC)
162 HTTP_MESSAGE_ME(addHeaders, ZEND_ACC_PUBLIC)
163 HTTP_MESSAGE_ME(getType, ZEND_ACC_PUBLIC)
164 HTTP_MESSAGE_ME(setType, ZEND_ACC_PUBLIC)
165 HTTP_MESSAGE_ME(getInfo, ZEND_ACC_PUBLIC)
166 HTTP_MESSAGE_ME(setInfo, ZEND_ACC_PUBLIC)
167 HTTP_MESSAGE_ME(getResponseCode, ZEND_ACC_PUBLIC)
168 HTTP_MESSAGE_ME(setResponseCode, ZEND_ACC_PUBLIC)
169 HTTP_MESSAGE_ME(getResponseStatus, ZEND_ACC_PUBLIC)
170 HTTP_MESSAGE_ME(setResponseStatus, ZEND_ACC_PUBLIC)
171 HTTP_MESSAGE_ME(getRequestMethod, ZEND_ACC_PUBLIC)
172 HTTP_MESSAGE_ME(setRequestMethod, ZEND_ACC_PUBLIC)
173 HTTP_MESSAGE_ME(getRequestUrl, ZEND_ACC_PUBLIC)
174 HTTP_MESSAGE_ME(setRequestUrl, ZEND_ACC_PUBLIC)
175 HTTP_MESSAGE_ME(getHttpVersion, ZEND_ACC_PUBLIC)
176 HTTP_MESSAGE_ME(setHttpVersion, ZEND_ACC_PUBLIC)
177 HTTP_MESSAGE_ME(guessContentType, ZEND_ACC_PUBLIC)
178 HTTP_MESSAGE_ME(getParentMessage, ZEND_ACC_PUBLIC)
179 HTTP_MESSAGE_ME(send, ZEND_ACC_PUBLIC)
180 HTTP_MESSAGE_ME(toString, ZEND_ACC_PUBLIC)
181 HTTP_MESSAGE_ME(toMessageTypeObject, ZEND_ACC_PUBLIC)
182
183 /* implements Countable */
184 HTTP_MESSAGE_ME(count, ZEND_ACC_PUBLIC)
185
186 /* implements Serializable */
187 HTTP_MESSAGE_ME(serialize, ZEND_ACC_PUBLIC)
188 HTTP_MESSAGE_ME(unserialize, ZEND_ACC_PUBLIC)
189
190 /* implements Iterator */
191 HTTP_MESSAGE_ME(rewind, ZEND_ACC_PUBLIC)
192 HTTP_MESSAGE_ME(valid, ZEND_ACC_PUBLIC)
193 HTTP_MESSAGE_ME(current, ZEND_ACC_PUBLIC)
194 HTTP_MESSAGE_ME(key, ZEND_ACC_PUBLIC)
195 HTTP_MESSAGE_ME(next, ZEND_ACC_PUBLIC)
196
197 ZEND_MALIAS(HttpMessage, __toString, toString, HTTP_ARGS(HttpMessage, toString), ZEND_ACC_PUBLIC)
198
199 HTTP_MESSAGE_ME(factory, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
200 ZEND_MALIAS(HttpMessage, fromString, factory, HTTP_ARGS(HttpMessage, factory), ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
201 HTTP_MESSAGE_ME(fromEnv, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
202
203 HTTP_MESSAGE_ME(detach, ZEND_ACC_PUBLIC)
204 HTTP_MESSAGE_ME(prepend, ZEND_ACC_PUBLIC)
205 HTTP_MESSAGE_ME(reverse, ZEND_ACC_PUBLIC)
206
207 EMPTY_FUNCTION_ENTRY
208 };
209 static zend_object_handlers http_message_object_handlers;
210
211 PHP_MINIT_FUNCTION(http_message_object)
212 {
213 HTTP_REGISTER_CLASS_EX(HttpMessage, http_message_object, NULL, 0);
214
215 #ifndef WONKY
216 # ifdef HTTP_HAVE_SPL
217 zend_class_implements(http_message_object_ce TSRMLS_CC, 3, spl_ce_Countable, zend_ce_serializable, zend_ce_iterator);
218 # else
219 zend_class_implements(http_message_object_ce TSRMLS_CC, 2, zend_ce_serializable, zend_ce_iterator);
220 # endif
221 #else
222 zend_class_implements(http_message_object_ce TSRMLS_CC, 1, zend_ce_iterator);
223 #endif
224
225 http_message_object_handlers.clone_obj = _http_message_object_clone_obj;
226 http_message_object_handlers.read_property = http_message_object_read_prop;
227 http_message_object_handlers.write_property = http_message_object_write_prop;
228 http_message_object_handlers.get_properties = http_message_object_get_props;
229 http_message_object_handlers.get_property_ptr_ptr = NULL;
230
231 zend_declare_property_long(THIS_CE, ZEND_STRS("type")-1, HTTP_MSG_NONE, ZEND_ACC_PROTECTED TSRMLS_CC);
232 zend_declare_property_string(THIS_CE, ZEND_STRS("body")-1, "", ZEND_ACC_PROTECTED TSRMLS_CC);
233 zend_declare_property_string(THIS_CE, ZEND_STRS("requestMethod")-1, "", ZEND_ACC_PROTECTED TSRMLS_CC);
234 zend_declare_property_string(THIS_CE, ZEND_STRS("requestUrl")-1, "", ZEND_ACC_PROTECTED TSRMLS_CC);
235 zend_declare_property_string(THIS_CE, ZEND_STRS("responseStatus")-1, "", ZEND_ACC_PROTECTED TSRMLS_CC);
236 zend_declare_property_long(THIS_CE, ZEND_STRS("responseCode")-1, 0, ZEND_ACC_PROTECTED TSRMLS_CC);
237 zend_declare_property_null(THIS_CE, ZEND_STRS("httpVersion")-1, ZEND_ACC_PROTECTED TSRMLS_CC);
238 zend_declare_property_null(THIS_CE, ZEND_STRS("headers")-1, ZEND_ACC_PROTECTED TSRMLS_CC);
239 zend_declare_property_null(THIS_CE, ZEND_STRS("parentMessage")-1, ZEND_ACC_PROTECTED TSRMLS_CC);
240
241 #ifndef WONKY
242 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("TYPE_NONE")-1, HTTP_MSG_NONE TSRMLS_CC);
243 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("TYPE_REQUEST")-1, HTTP_MSG_REQUEST TSRMLS_CC);
244 zend_declare_class_constant_long(THIS_CE, ZEND_STRS("TYPE_RESPONSE")-1, HTTP_MSG_RESPONSE TSRMLS_CC);
245 #endif
246
247 HTTP_LONG_CONSTANT("HTTP_MSG_NONE", HTTP_MSG_NONE);
248 HTTP_LONG_CONSTANT("HTTP_MSG_REQUEST", HTTP_MSG_REQUEST);
249 HTTP_LONG_CONSTANT("HTTP_MSG_RESPONSE", HTTP_MSG_RESPONSE);
250
251 return SUCCESS;
252 }
253
254 void _http_message_object_reverse(zval *this_ptr, zval *return_value TSRMLS_DC)
255 {
256 int i;
257 getObject(http_message_object, obj);
258
259 /* count */
260 http_message_count(i, obj->message);
261
262 if (i > 1) {
263 zval o;
264 zend_object_value *ovalues = NULL;
265 http_message_object **objects = NULL;
266 int last = i - 1;
267
268 objects = ecalloc(i, sizeof(http_message_object *));
269 ovalues = ecalloc(i, sizeof(zend_object_value));
270
271 /* we are the first message */
272 objects[0] = obj;
273 ovalues[0] = getThis()->value.obj;
274
275 /* fetch parents */
276 INIT_PZVAL(&o);
277 o.type = IS_OBJECT;
278 for (i = 1; obj->parent.handle; ++i) {
279 o.value.obj = obj->parent;
280 ovalues[i] = o.value.obj;
281 objects[i] = obj = zend_object_store_get_object(&o TSRMLS_CC);
282 }
283
284 /* reorder parents */
285 for (last = --i; i; --i) {
286 objects[i]->message->parent = objects[i-1]->message;
287 objects[i]->parent = ovalues[i-1];
288 }
289 objects[0]->message->parent = NULL;
290 objects[0]->parent.handle = 0;
291 objects[0]->parent.handlers = NULL;
292
293 /* add ref (why?) */
294 Z_OBJ_ADDREF_P(getThis());
295 RETVAL_OBJVAL(ovalues[last], 1);
296
297 efree(objects);
298 efree(ovalues);
299 } else {
300 RETURN_ZVAL(getThis(), 1, 0);
301 }
302 }
303
304 void _http_message_object_prepend_ex(zval *this_ptr, zval *prepend, zend_bool top TSRMLS_DC)
305 {
306 zval m;
307 http_message *save_parent_msg = NULL;
308 zend_object_value save_parent_obj = {0, NULL};
309 getObject(http_message_object, obj);
310 getObjectEx(http_message_object, prepend_obj, prepend);
311
312 INIT_PZVAL(&m);
313 m.type = IS_OBJECT;
314
315 if (!top) {
316 save_parent_obj = obj->parent;
317 save_parent_msg = obj->message->parent;
318 } else {
319 /* iterate to the most parent object */
320 while (obj->parent.handle) {
321 m.value.obj = obj->parent;
322 obj = zend_object_store_get_object(&m TSRMLS_CC);
323 }
324 }
325
326 /* prepend */
327 obj->parent = prepend->value.obj;
328 obj->message->parent = prepend_obj->message;
329
330 /* add ref */
331 zend_objects_store_add_ref(prepend TSRMLS_CC);
332 while (prepend_obj->parent.handle) {
333 m.value.obj = prepend_obj->parent;
334 zend_objects_store_add_ref(&m TSRMLS_CC);
335 prepend_obj = zend_object_store_get_object(&m TSRMLS_CC);
336 }
337
338 if (!top) {
339 prepend_obj->parent = save_parent_obj;
340 prepend_obj->message->parent = save_parent_msg;
341 }
342 }
343
344 zend_object_value _http_message_object_new(zend_class_entry *ce TSRMLS_DC)
345 {
346 return http_message_object_new_ex(ce, NULL, NULL);
347 }
348
349 zend_object_value _http_message_object_new_ex(zend_class_entry *ce, http_message *msg, http_message_object **ptr TSRMLS_DC)
350 {
351 zend_object_value ov;
352 http_message_object *o;
353
354 o = ecalloc(1, sizeof(http_message_object));
355 o->zo.ce = ce;
356
357 if (ptr) {
358 *ptr = o;
359 }
360
361 if (msg) {
362 o->message = msg;
363 if (msg->parent) {
364 o->parent = http_message_object_new_ex(ce, msg->parent, NULL);
365 }
366 }
367
368 ALLOC_HASHTABLE(OBJ_PROP(o));
369 zend_hash_init(OBJ_PROP(o), zend_hash_num_elements(&ce->default_properties), NULL, ZVAL_PTR_DTOR, 0);
370 zend_hash_copy(OBJ_PROP(o), &ce->default_properties, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
371
372 ov.handle = putObject(http_message_object, o);
373 ov.handlers = &http_message_object_handlers;
374
375 return ov;
376 }
377
378 zend_object_value _http_message_object_clone_obj(zval *this_ptr TSRMLS_DC)
379 {
380 zend_object_value new_ov;
381 http_message_object *new_obj = NULL;
382 getObject(http_message_object, old_obj);
383
384 new_ov = http_message_object_new_ex(old_obj->zo.ce, http_message_dup(old_obj->message), &new_obj);
385 zend_objects_clone_members(&new_obj->zo, new_ov, &old_obj->zo, Z_OBJ_HANDLE_P(this_ptr) TSRMLS_CC);
386
387 return new_ov;
388 }
389
390 void _http_message_object_free(zend_object *object TSRMLS_DC)
391 {
392 http_message_object *o = (http_message_object *) object;
393
394 if (o->message) {
395 http_message_dtor(o->message);
396 efree(o->message);
397 }
398 if (o->parent.handle) {
399 zval p;
400
401 INIT_PZVAL(&p);
402 p.type = IS_OBJECT;
403 p.value.obj = o->parent;
404 zend_objects_store_del_ref(&p TSRMLS_CC);
405 }
406 freeObject(o);
407 }
408
409 static zval *_http_message_object_read_prop(zval *object, zval *member, int type TSRMLS_DC)
410 {
411 getObjectEx(http_message_object, obj, object);
412 http_message *msg = obj->message;
413 zval *return_value;
414 #ifdef WONKY
415 ulong h = zend_hash_func(Z_STRVAL_P(member), Z_STRLEN_P(member)+1);
416 #else
417 zend_property_info *pinfo = zend_get_property_info(obj->zo.ce, member, 1 TSRMLS_CC);
418
419 if (!pinfo || ACC_PROP_PUBLIC(pinfo->flags)) {
420 return zend_get_std_object_handlers()->read_property(object, member, type TSRMLS_CC);
421 }
422 #endif
423
424 if (type == BP_VAR_W) {
425 zend_error(E_ERROR, "Cannot access HttpMessage properties by reference or array key/index");
426 return NULL;
427 }
428
429 ALLOC_ZVAL(return_value);
430 return_value->refcount = 0;
431 return_value->is_ref = 0;
432
433 #ifdef WONKY
434 switch (h)
435 #else
436 switch (pinfo->h)
437 #endif
438 {
439 case HTTP_MSG_PROPHASH_TYPE:
440 case HTTP_MSG_CHILD_PROPHASH_TYPE:
441 RETVAL_LONG(msg->type);
442 break;
443
444 case HTTP_MSG_PROPHASH_HTTP_VERSION:
445 case HTTP_MSG_CHILD_PROPHASH_HTTP_VERSION:
446 RETVAL_DOUBLE(msg->http.version);
447 break;
448
449 case HTTP_MSG_PROPHASH_BODY:
450 case HTTP_MSG_CHILD_PROPHASH_BODY:
451 phpstr_fix(PHPSTR(msg));
452 RETVAL_PHPSTR(PHPSTR(msg), 0, 1);
453 break;
454
455 case HTTP_MSG_PROPHASH_HEADERS:
456 case HTTP_MSG_CHILD_PROPHASH_HEADERS:
457 array_init(return_value);
458 zend_hash_copy(Z_ARRVAL_P(return_value), &msg->hdrs, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
459 break;
460
461 case HTTP_MSG_PROPHASH_PARENT_MESSAGE:
462 case HTTP_MSG_CHILD_PROPHASH_PARENT_MESSAGE:
463 if (msg->parent) {
464 RETVAL_OBJVAL(obj->parent, 1);
465 } else {
466 RETVAL_NULL();
467 }
468 break;
469
470 case HTTP_MSG_PROPHASH_REQUEST_METHOD:
471 case HTTP_MSG_CHILD_PROPHASH_REQUEST_METHOD:
472 if (HTTP_MSG_TYPE(REQUEST, msg) && msg->http.info.request.method) {
473 RETVAL_STRING(msg->http.info.request.method, 1);
474 } else {
475 RETVAL_NULL();
476 }
477 break;
478
479 case HTTP_MSG_PROPHASH_REQUEST_URL:
480 case HTTP_MSG_CHILD_PROPHASH_REQUEST_URL:
481 if (HTTP_MSG_TYPE(REQUEST, msg) && msg->http.info.request.url) {
482 RETVAL_STRING(msg->http.info.request.url, 1);
483 } else {
484 RETVAL_NULL();
485 }
486 break;
487
488 case HTTP_MSG_PROPHASH_RESPONSE_CODE:
489 case HTTP_MSG_CHILD_PROPHASH_RESPONSE_CODE:
490 if (HTTP_MSG_TYPE(RESPONSE, msg)) {
491 RETVAL_LONG(msg->http.info.response.code);
492 } else {
493 RETVAL_NULL();
494 }
495 break;
496
497 case HTTP_MSG_PROPHASH_RESPONSE_STATUS:
498 case HTTP_MSG_CHILD_PROPHASH_RESPONSE_STATUS:
499 if (HTTP_MSG_TYPE(RESPONSE, msg) && msg->http.info.response.status) {
500 RETVAL_STRING(msg->http.info.response.status, 1);
501 } else {
502 RETVAL_NULL();
503 }
504 break;
505
506 default:
507 #ifdef WONKY
508 return zend_get_std_object_handlers()->read_property(object, member, type TSRMLS_CC);
509 #else
510 RETVAL_NULL();
511 #endif
512 }
513
514 return return_value;
515 }
516
517 static void _http_message_object_write_prop(zval *object, zval *member, zval *value TSRMLS_DC)
518 {
519 getObjectEx(http_message_object, obj, object);
520 http_message *msg = obj->message;
521 zval *cpy = NULL;
522 #ifdef WONKY
523 ulong h = zend_hash_func(Z_STRVAL_P(member), Z_STRLEN_P(member) + 1);
524 #else
525 zend_property_info *pinfo = zend_get_property_info(obj->zo.ce, member, 1 TSRMLS_CC);
526
527 if (!pinfo || ACC_PROP_PUBLIC(pinfo->flags)) {
528 zend_get_std_object_handlers()->write_property(object, member, value TSRMLS_CC);
529 return;
530 }
531 #endif
532
533 cpy = zval_copy(Z_TYPE_P(value), value);
534
535 #ifdef WONKY
536 switch (h)
537 #else
538 switch (pinfo->h)
539 #endif
540 {
541 case HTTP_MSG_PROPHASH_TYPE:
542 case HTTP_MSG_CHILD_PROPHASH_TYPE:
543 convert_to_long(cpy);
544 http_message_set_type(msg, Z_LVAL_P(cpy));
545 break;
546
547 case HTTP_MSG_PROPHASH_HTTP_VERSION:
548 case HTTP_MSG_CHILD_PROPHASH_HTTP_VERSION:
549 convert_to_double(cpy);
550 msg->http.version = Z_DVAL_P(cpy);
551 break;
552
553 case HTTP_MSG_PROPHASH_BODY:
554 case HTTP_MSG_CHILD_PROPHASH_BODY:
555 convert_to_string(cpy);
556 phpstr_dtor(PHPSTR(msg));
557 phpstr_from_string_ex(PHPSTR(msg), Z_STRVAL_P(cpy), Z_STRLEN_P(cpy));
558 break;
559
560 case HTTP_MSG_PROPHASH_HEADERS:
561 case HTTP_MSG_CHILD_PROPHASH_HEADERS:
562 convert_to_array(cpy);
563 zend_hash_clean(&msg->hdrs);
564 zend_hash_copy(&msg->hdrs, Z_ARRVAL_P(cpy), (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
565 break;
566
567 case HTTP_MSG_PROPHASH_PARENT_MESSAGE:
568 case HTTP_MSG_CHILD_PROPHASH_PARENT_MESSAGE:
569 if (Z_TYPE_P(value) == IS_OBJECT && instanceof_function(Z_OBJCE_P(value), http_message_object_ce TSRMLS_CC)) {
570 if (msg->parent) {
571 zval tmp;
572 tmp.value.obj = obj->parent;
573 Z_OBJ_DELREF(tmp);
574 }
575 Z_OBJ_ADDREF_P(value);
576 obj->parent = value->value.obj;
577 }
578 break;
579
580 case HTTP_MSG_PROPHASH_REQUEST_METHOD:
581 case HTTP_MSG_CHILD_PROPHASH_REQUEST_METHOD:
582 if (HTTP_MSG_TYPE(REQUEST, msg)) {
583 convert_to_string(cpy);
584 STR_SET(msg->http.info.request.method, estrndup(Z_STRVAL_P(cpy), Z_STRLEN_P(cpy)));
585 }
586 break;
587
588 case HTTP_MSG_PROPHASH_REQUEST_URL:
589 case HTTP_MSG_CHILD_PROPHASH_REQUEST_URL:
590 if (HTTP_MSG_TYPE(REQUEST, msg)) {
591 convert_to_string(cpy);
592 STR_SET(msg->http.info.request.url, estrndup(Z_STRVAL_P(cpy), Z_STRLEN_P(cpy)));
593 }
594 break;
595
596 case HTTP_MSG_PROPHASH_RESPONSE_CODE:
597 case HTTP_MSG_CHILD_PROPHASH_RESPONSE_CODE:
598 if (HTTP_MSG_TYPE(RESPONSE, msg)) {
599 convert_to_long(cpy);
600 msg->http.info.response.code = Z_LVAL_P(cpy);
601 }
602 break;
603
604 case HTTP_MSG_PROPHASH_RESPONSE_STATUS:
605 case HTTP_MSG_CHILD_PROPHASH_RESPONSE_STATUS:
606 if (HTTP_MSG_TYPE(RESPONSE, msg)) {
607 convert_to_string(cpy);
608 STR_SET(msg->http.info.response.status, estrndup(Z_STRVAL_P(cpy), Z_STRLEN_P(cpy)));
609 }
610 break;
611
612 default:
613 #ifdef WONKY
614 zend_get_std_object_handlers()->write_property(object, member, value TSRMLS_CC);
615 #endif
616 break;
617 }
618 zval_free(&cpy);
619 }
620
621 static HashTable *_http_message_object_get_props(zval *object TSRMLS_DC)
622 {
623 zval *headers;
624 getObjectEx(http_message_object, obj, object);
625 http_message *msg = obj->message;
626 HashTable *props = OBJ_PROP(obj);
627 zval array, *parent;
628
629 INIT_ZARR(array, props);
630
631 #define ASSOC_PROP(array, ptype, name, val) \
632 { \
633 char *m_prop_name; \
634 int m_prop_len; \
635 zend_mangle_property_name(&m_prop_name, &m_prop_len, "*", 1, name, lenof(name), 0); \
636 add_assoc_ ##ptype## _ex(&array, m_prop_name, sizeof(name)+3, val); \
637 efree(m_prop_name); \
638 }
639 #define ASSOC_STRING(array, name, val) ASSOC_STRINGL(array, name, val, strlen(val))
640 #define ASSOC_STRINGL(array, name, val, len) \
641 { \
642 char *m_prop_name; \
643 int m_prop_len; \
644 zend_mangle_property_name(&m_prop_name, &m_prop_len, "*", 1, name, lenof(name), 0); \
645 add_assoc_stringl_ex(&array, m_prop_name, sizeof(name)+3, val, len, 1); \
646 efree(m_prop_name); \
647 }
648
649 ASSOC_PROP(array, long, "type", msg->type);
650 ASSOC_PROP(array, double, "httpVersion", msg->http.version);
651
652 switch (msg->type) {
653 case HTTP_MSG_REQUEST:
654 ASSOC_PROP(array, long, "responseCode", 0);
655 ASSOC_STRINGL(array, "responseStatus", "", 0);
656 ASSOC_STRING(array, "requestMethod", STR_PTR(msg->http.info.request.method));
657 ASSOC_STRING(array, "requestUrl", STR_PTR(msg->http.info.request.url));
658 break;
659
660 case HTTP_MSG_RESPONSE:
661 ASSOC_PROP(array, long, "responseCode", msg->http.info.response.code);
662 ASSOC_STRING(array, "responseStatus", STR_PTR(msg->http.info.response.status));
663 ASSOC_STRINGL(array, "requestMethod", "", 0);
664 ASSOC_STRINGL(array, "requestUrl", "", 0);
665 break;
666
667 case HTTP_MSG_NONE:
668 default:
669 ASSOC_PROP(array, long, "responseCode", 0);
670 ASSOC_STRINGL(array, "responseStatus", "", 0);
671 ASSOC_STRINGL(array, "requestMethod", "", 0);
672 ASSOC_STRINGL(array, "requestUrl", "", 0);
673 break;
674 }
675
676 MAKE_STD_ZVAL(headers);
677 array_init(headers);
678 zend_hash_copy(Z_ARRVAL_P(headers), &msg->hdrs, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
679 ASSOC_PROP(array, zval, "headers", headers);
680 ASSOC_STRINGL(array, "body", PHPSTR_VAL(msg), PHPSTR_LEN(msg));
681
682 MAKE_STD_ZVAL(parent);
683 if (msg->parent) {
684 ZVAL_OBJVAL(parent, obj->parent, 1);
685 } else {
686 ZVAL_NULL(parent);
687 }
688 ASSOC_PROP(array, zval, "parentMessage", parent);
689
690 return OBJ_PROP(obj);
691 }
692
693 /* ### USERLAND ### */
694
695 /* {{{ proto void HttpMessage::__construct([string message])
696 Create a new HttpMessage object instance. */
697 PHP_METHOD(HttpMessage, __construct)
698 {
699 int length = 0;
700 char *message = NULL;
701
702 getObject(http_message_object, obj);
703
704 SET_EH_THROW_HTTP();
705 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &message, &length) && message && length) {
706 http_message *msg = obj->message;
707
708 http_message_dtor(msg);
709 if ((obj->message = http_message_parse_ex(msg, message, length))) {
710 if (obj->message->parent) {
711 obj->parent = http_message_object_new_ex(Z_OBJCE_P(getThis()), obj->message->parent, NULL);
712 }
713 } else {
714 obj->message = http_message_init(msg);
715 }
716 }
717 if (!obj->message) {
718 obj->message = http_message_new();
719 }
720 SET_EH_NORMAL();
721 }
722 /* }}} */
723
724 /* {{{ proto static HttpMessage HttpMessage::factory([string raw_message[, string class_name = "HttpMessage"]])
725 Create a new HttpMessage object instance. */
726 PHP_METHOD(HttpMessage, factory)
727 {
728 char *string = NULL, *cn = NULL;
729 int length = 0, cl = 0;
730 http_message *msg = NULL;
731 zend_object_value ov;
732 http_message_object *obj = NULL;
733
734 RETVAL_NULL();
735
736 SET_EH_THROW_HTTP();
737 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ss", &string, &length, &cn, &cl)) {
738 if (length) {
739 msg = http_message_parse(string, length);
740 }
741 if ((msg || !length) && SUCCESS == http_object_new(&ov, cn, cl, _http_message_object_new_ex, http_message_object_ce, msg, &obj)) {
742 RETVAL_OBJVAL(ov, 0);
743 }
744 if (obj && !obj->message) {
745 obj->message = http_message_new();
746 }
747 }
748 SET_EH_NORMAL();
749 }
750 /* }}} */
751
752 /* {{{ proto static HttpMessage HttpMessage::fromEnv(int type[, string class_name = "HttpMessage"])
753 Create a new HttpMessage object from environment representing either current request or response */
754 PHP_METHOD(HttpMessage, fromEnv)
755 {
756 char *cn = NULL;
757 int cl = 0;
758 long type;
759 http_message_object *obj = NULL;
760 zend_object_value ov;
761
762 RETVAL_NULL();
763 SET_EH_THROW_HTTP();
764 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|s", &type, &cn, &cl)) {
765 if (SUCCESS == http_object_new(&ov, cn, cl, _http_message_object_new_ex, http_message_object_ce, http_message_init_env(NULL, type), &obj)) {
766 RETVAL_OBJVAL(ov, 0);
767 }
768 if (obj && !obj->message) {
769 obj->message = http_message_new();
770 }
771 }
772 SET_EH_NORMAL();
773 }
774 /* }}} */
775
776 /* {{{ proto string HttpMessage::getBody()
777 Get the body of the parsed HttpMessage. */
778 PHP_METHOD(HttpMessage, getBody)
779 {
780 NO_ARGS;
781
782 if (return_value_used) {
783 getObject(http_message_object, obj);
784 RETURN_PHPSTR(&obj->message->body, PHPSTR_FREE_NOT, 1);
785 }
786 }
787 /* }}} */
788
789 /* {{{ proto void HttpMessage::setBody(string body)
790 Set the body of the HttpMessage. NOTE: Don't forget to update any headers accordingly. */
791 PHP_METHOD(HttpMessage, setBody)
792 {
793 char *body;
794 int len;
795 getObject(http_message_object, obj);
796
797 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &body, &len)) {
798 phpstr_dtor(PHPSTR(obj->message));
799 phpstr_from_string_ex(PHPSTR(obj->message), body, len);
800 }
801 }
802 /* }}} */
803
804 /* {{{ proto string HttpMessage::getHeader(string header)
805 Get message header. */
806 PHP_METHOD(HttpMessage, getHeader)
807 {
808 zval *header;
809 char *orig_header, *nice_header;
810 int header_len;
811 getObject(http_message_object, obj);
812
813 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &orig_header, &header_len)) {
814 RETURN_FALSE;
815 }
816
817 nice_header = pretty_key(estrndup(orig_header, header_len), header_len, 1, 1);
818 if ((header = http_message_header_ex(obj->message, nice_header, header_len + 1, 0))) {
819 RETVAL_ZVAL(header, 1, 1);
820 }
821 efree(nice_header);
822 }
823 /* }}} */
824
825 /* {{{ proto array HttpMessage::getHeaders()
826 Get Message Headers. */
827 PHP_METHOD(HttpMessage, getHeaders)
828 {
829 NO_ARGS;
830
831 if (return_value_used) {
832 getObject(http_message_object, obj);
833
834 array_init(return_value);
835 array_copy(&obj->message->hdrs, Z_ARRVAL_P(return_value));
836 }
837 }
838 /* }}} */
839
840 /* {{{ proto void HttpMessage::setHeaders(array headers)
841 Sets new headers. */
842 PHP_METHOD(HttpMessage, setHeaders)
843 {
844 zval *new_headers = NULL;
845 getObject(http_message_object, obj);
846
847 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/!", &new_headers)) {
848 return;
849 }
850
851 zend_hash_clean(&obj->message->hdrs);
852 if (new_headers) {
853 array_copy(Z_ARRVAL_P(new_headers), &obj->message->hdrs);
854 }
855 }
856 /* }}} */
857
858 /* {{{ proto void HttpMessage::addHeaders(array headers[, bool append = false])
859 Add headers. If append is true, headers with the same name will be separated, else overwritten. */
860 PHP_METHOD(HttpMessage, addHeaders)
861 {
862 zval *new_headers;
863 zend_bool append = 0;
864 getObject(http_message_object, obj);
865
866 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|b", &new_headers, &append)) {
867 return;
868 }
869
870 array_join(Z_ARRVAL_P(new_headers), &obj->message->hdrs, append, ARRAY_JOIN_STRONLY|ARRAY_JOIN_PRETTIFY);
871 }
872 /* }}} */
873
874 /* {{{ proto int HttpMessage::getType()
875 Get Message Type. (HTTP_MSG_NONE|HTTP_MSG_REQUEST|HTTP_MSG_RESPONSE) */
876 PHP_METHOD(HttpMessage, getType)
877 {
878 NO_ARGS;
879
880 if (return_value_used) {
881 getObject(http_message_object, obj);
882 RETURN_LONG(obj->message->type);
883 }
884 }
885 /* }}} */
886
887 /* {{{ proto void HttpMessage::setType(int type)
888 Set Message Type. (HTTP_MSG_NONE|HTTP_MSG_REQUEST|HTTP_MSG_RESPONSE) */
889 PHP_METHOD(HttpMessage, setType)
890 {
891 long type;
892 getObject(http_message_object, obj);
893
894 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &type)) {
895 return;
896 }
897 http_message_set_type(obj->message, type);
898 }
899 /* }}} */
900
901 /* {{{ proto string HttpMessage::getInfo(void)
902 Get the HTTP request/response line */
903 PHP_METHOD(HttpMessage, getInfo)
904 {
905 NO_ARGS;
906
907 if (return_value_used) {
908 getObject(http_message_object, obj);
909
910 switch (obj->message->type) {
911 case HTTP_MSG_REQUEST:
912 Z_STRLEN_P(return_value) = spprintf(&Z_STRVAL_P(return_value), 0, HTTP_INFO_REQUEST_FMT_ARGS(&obj->message->http, ""));
913 break;
914 case HTTP_MSG_RESPONSE:
915 Z_STRLEN_P(return_value) = spprintf(&Z_STRVAL_P(return_value), 0, HTTP_INFO_RESPONSE_FMT_ARGS(&obj->message->http, ""));
916 break;
917 default:
918 RETURN_NULL();
919 break;
920 }
921 Z_TYPE_P(return_value) = IS_STRING;
922 }
923 }
924 /* }}} */
925
926 /* {{{ proto bool HttpMessage::setInfo(string http_info)
927 Set type and request or response info with a standard HTTP request or response line */
928 PHP_METHOD(HttpMessage, setInfo)
929 {
930 char *str;
931 int len;
932 http_info inf;
933
934 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &len) && SUCCESS == http_info_parse_ex(str, &inf, 0)) {
935 getObject(http_message_object, obj);
936
937 http_message_set_info(obj->message, &inf);
938 http_info_dtor(&inf);
939 RETURN_TRUE;
940 }
941 RETURN_FALSE;
942 }
943 /* }}} */
944
945 /* {{{ proto int HttpMessage::getResponseCode()
946 Get the Response Code of the Message. */
947 PHP_METHOD(HttpMessage, getResponseCode)
948 {
949 NO_ARGS;
950
951 if (return_value_used) {
952 getObject(http_message_object, obj);
953 HTTP_CHECK_MESSAGE_TYPE_RESPONSE(obj->message, RETURN_FALSE);
954 RETURN_LONG(obj->message->http.info.response.code);
955 }
956 }
957 /* }}} */
958
959 /* {{{ proto bool HttpMessage::setResponseCode(int code)
960 Set the response code of an HTTP Response Message. */
961 PHP_METHOD(HttpMessage, setResponseCode)
962 {
963 long code;
964 getObject(http_message_object, obj);
965
966 HTTP_CHECK_MESSAGE_TYPE_RESPONSE(obj->message, RETURN_FALSE);
967
968 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &code)) {
969 RETURN_FALSE;
970 }
971 if (code < 100 || code > 599) {
972 http_error_ex(HE_WARNING, HTTP_E_INVALID_PARAM, "Invalid response code (100-599): %ld", code);
973 RETURN_FALSE;
974 }
975
976 obj->message->http.info.response.code = code;
977 RETURN_TRUE;
978 }
979 /* }}} */
980
981 /* {{{ proto string HttpMessage::getResponseStatus()
982 Get the Response Status of the message (i.e. the string following the response code). */
983 PHP_METHOD(HttpMessage, getResponseStatus)
984 {
985 NO_ARGS;
986
987 if (return_value_used) {
988 getObject(http_message_object, obj);
989 HTTP_CHECK_MESSAGE_TYPE_RESPONSE(obj->message, RETURN_FALSE);
990 if (obj->message->http.info.response.status) {
991 RETURN_STRING(obj->message->http.info.response.status, 1);
992 } else {
993 RETURN_EMPTY_STRING();
994 }
995 }
996 }
997 /* }}} */
998
999 /* {{{ proto bool HttpMessage::setResponseStatus(string status)
1000 Set the Response Status of the HTTP message (i.e. the string following the response code). */
1001 PHP_METHOD(HttpMessage, setResponseStatus)
1002 {
1003 char *status;
1004 int status_len;
1005 getObject(http_message_object, obj);
1006
1007 HTTP_CHECK_MESSAGE_TYPE_RESPONSE(obj->message, RETURN_FALSE);
1008
1009 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &status, &status_len)) {
1010 RETURN_FALSE;
1011 }
1012 STR_SET(obj->message->http.info.response.status, estrndup(status, status_len));
1013 RETURN_TRUE;
1014 }
1015 /* }}} */
1016
1017 /* {{{ proto string HttpMessage::getRequestMethod()
1018 Get the Request Method of the Message. */
1019 PHP_METHOD(HttpMessage, getRequestMethod)
1020 {
1021 NO_ARGS;
1022
1023 if (return_value_used) {
1024 getObject(http_message_object, obj);
1025 HTTP_CHECK_MESSAGE_TYPE_REQUEST(obj->message, RETURN_FALSE);
1026 if (obj->message->http.info.request.method) {
1027 RETURN_STRING(obj->message->http.info.request.method, 1);
1028 } else {
1029 RETURN_EMPTY_STRING();
1030 }
1031 }
1032 }
1033 /* }}} */
1034
1035 /* {{{ proto bool HttpMessage::setRequestMethod(string method)
1036 Set the Request Method of the HTTP Message. */
1037 PHP_METHOD(HttpMessage, setRequestMethod)
1038 {
1039 char *method;
1040 int method_len;
1041 getObject(http_message_object, obj);
1042
1043 HTTP_CHECK_MESSAGE_TYPE_REQUEST(obj->message, RETURN_FALSE);
1044
1045 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &method, &method_len)) {
1046 RETURN_FALSE;
1047 }
1048 if (method_len < 1) {
1049 http_error(HE_WARNING, HTTP_E_INVALID_PARAM, "Cannot set HttpMessage::requestMethod to an empty string");
1050 RETURN_FALSE;
1051 }
1052 if (!http_request_method_exists(1, 0, method)) {
1053 http_error_ex(HE_WARNING, HTTP_E_REQUEST_METHOD, "Unknown request method: %s", method);
1054 RETURN_FALSE;
1055 }
1056
1057 STR_SET(obj->message->http.info.request.method, estrndup(method, method_len));
1058 RETURN_TRUE;
1059 }
1060 /* }}} */
1061
1062 /* {{{ proto string HttpMessage::getRequestUrl()
1063 Get the Request URL of the Message. */
1064 PHP_METHOD(HttpMessage, getRequestUrl)
1065 {
1066 NO_ARGS;
1067
1068 if (return_value_used) {
1069 getObject(http_message_object, obj);
1070 HTTP_CHECK_MESSAGE_TYPE_REQUEST(obj->message, RETURN_FALSE);
1071 if (obj->message->http.info.request.url) {
1072 RETURN_STRING(obj->message->http.info.request.url, 1);
1073 } else {
1074 RETURN_EMPTY_STRING();
1075 }
1076 }
1077 }
1078 /* }}} */
1079
1080 /* {{{ proto bool HttpMessage::setRequestUrl(string url)
1081 Set the Request URL of the HTTP Message. */
1082 PHP_METHOD(HttpMessage, setRequestUrl)
1083 {
1084 char *URI;
1085 int URIlen;
1086 getObject(http_message_object, obj);
1087
1088 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &URI, &URIlen)) {
1089 RETURN_FALSE;
1090 }
1091 HTTP_CHECK_MESSAGE_TYPE_REQUEST(obj->message, RETURN_FALSE);
1092 if (URIlen < 1) {
1093 http_error(HE_WARNING, HTTP_E_INVALID_PARAM, "Cannot set HttpMessage::requestUrl to an empty string");
1094 RETURN_FALSE;
1095 }
1096
1097 STR_SET(obj->message->http.info.request.url, estrndup(URI, URIlen));
1098 RETURN_TRUE;
1099 }
1100 /* }}} */
1101
1102 /* {{{ proto string HttpMessage::getHttpVersion()
1103 Get the HTTP Protocol Version of the Message. */
1104 PHP_METHOD(HttpMessage, getHttpVersion)
1105 {
1106 NO_ARGS;
1107
1108 if (return_value_used) {
1109 char ver[4] = {0};
1110 getObject(http_message_object, obj);
1111
1112 sprintf(ver, "%1.1lf", obj->message->http.version);
1113 RETURN_STRINGL(ver, 3, 1);
1114 }
1115 }
1116 /* }}} */
1117
1118 /* {{{ proto bool HttpMessage::setHttpVersion(string version)
1119 Set the HTTP Protocol version of the Message. */
1120 PHP_METHOD(HttpMessage, setHttpVersion)
1121 {
1122 char v[4];
1123 zval *zv;
1124 getObject(http_message_object, obj);
1125
1126 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/", &zv)) {
1127 return;
1128 }
1129
1130 convert_to_double(zv);
1131 sprintf(v, "%1.1lf", Z_DVAL_P(zv));
1132 if (strcmp(v, "1.0") && strcmp(v, "1.1")) {
1133 http_error_ex(HE_WARNING, HTTP_E_INVALID_PARAM, "Invalid HTTP protocol version (1.0 or 1.1): %s", v);
1134 RETURN_FALSE;
1135 }
1136
1137 obj->message->http.version = Z_DVAL_P(zv);
1138 RETURN_TRUE;
1139 }
1140 /* }}} */
1141
1142 /* {{{ proto string HttpMessage::guessContentType(string magic_file[, int magic_mode = MAGIC_MIME])
1143 Attempts to guess the content type of supplied payload through libmagic. */
1144 PHP_METHOD(HttpMessage, guessContentType)
1145 {
1146 #ifdef HTTP_HAVE_MAGIC
1147 char *magic_file, *ct = NULL;
1148 int magic_file_len;
1149 long magic_mode = MAGIC_MIME;
1150
1151 RETVAL_FALSE;
1152 SET_EH_THROW_HTTP();
1153 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &magic_file, &magic_file_len, &magic_mode)) {
1154 getObject(http_message_object, obj);
1155 if ((ct = http_guess_content_type(magic_file, magic_mode, PHPSTR_VAL(&obj->message->body), PHPSTR_LEN(&obj->message->body), SEND_DATA))) {
1156 RETVAL_STRING(ct, 0);
1157 }
1158 }
1159 SET_EH_NORMAL();
1160 #else
1161 http_error(HE_THROW, HTTP_E_RUNTIME, "Cannot guess Content-Type; libmagic not available");
1162 RETURN_FALSE;
1163 #endif
1164 }
1165 /* }}} */
1166
1167 /* {{{ proto HttpMessage HttpMessage::getParentMessage()
1168 Get parent Message. */
1169 PHP_METHOD(HttpMessage, getParentMessage)
1170 {
1171 SET_EH_THROW_HTTP();
1172 NO_ARGS {
1173 getObject(http_message_object, obj);
1174
1175 if (obj->message->parent) {
1176 RETVAL_OBJVAL(obj->parent, 1);
1177 } else {
1178 http_error(HE_WARNING, HTTP_E_RUNTIME, "HttpMessage does not have a parent message");
1179 }
1180 }
1181 SET_EH_NORMAL();
1182 }
1183 /* }}} */
1184
1185 /* {{{ proto bool HttpMessage::send()
1186 Send the Message according to its type as Response or Request. */
1187 PHP_METHOD(HttpMessage, send)
1188 {
1189 getObject(http_message_object, obj);
1190
1191 NO_ARGS;
1192
1193 RETURN_SUCCESS(http_message_send(obj->message));
1194 }
1195 /* }}} */
1196
1197 /* {{{ proto string HttpMessage::toString([bool include_parent = false])
1198 Get the string representation of the Message. */
1199 PHP_METHOD(HttpMessage, toString)
1200 {
1201 if (return_value_used) {
1202 char *string;
1203 size_t length;
1204 zend_bool include_parent = 0;
1205 getObject(http_message_object, obj);
1206
1207 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &include_parent)) {
1208 RETURN_FALSE;
1209 }
1210
1211 if (include_parent) {
1212 http_message_serialize(obj->message, &string, &length);
1213 } else {
1214 http_message_tostring(obj->message, &string, &length);
1215 }
1216 RETURN_STRINGL(string, length, 0);
1217 }
1218 }
1219 /* }}} */
1220
1221 /* {{{ proto HttpRequest|HttpResponse HttpMessage::toMessageTypeObject(void)
1222 Creates an object regarding to the type of the message. Returns either an HttpRequest or HttpResponse object on success, or NULL on failure. */
1223 PHP_METHOD(HttpMessage, toMessageTypeObject)
1224 {
1225 SET_EH_THROW_HTTP();
1226
1227 NO_ARGS;
1228
1229 if (return_value_used) {
1230 getObject(http_message_object, obj);
1231
1232 switch (obj->message->type) {
1233 case HTTP_MSG_REQUEST:
1234 {
1235 #ifdef HTTP_HAVE_CURL
1236 int method;
1237 char *url;
1238 zval body, *array, *headers, *host = http_message_header(obj->message, "Host");
1239 php_url hurl, *purl = php_url_parse(obj->message->http.info.request.url);
1240
1241 MAKE_STD_ZVAL(array);
1242 array_init(array);
1243
1244 memset(&hurl, 0, sizeof(php_url));
1245 hurl.host = host ? Z_STRVAL_P(host) : NULL;
1246 zval_ptr_dtor(&host);
1247 http_build_url(HTTP_URL_REPLACE, purl, &hurl, NULL, &url, NULL);
1248 php_url_free(purl);
1249 add_assoc_string(array, "url", url, 0);
1250
1251 if ( (method = http_request_method_exists(1, 0, obj->message->http.info.request.method)) ||
1252 (method = http_request_method_register(obj->message->http.info.request.method, strlen(obj->message->http.info.request.method)))) {
1253 add_assoc_long(array, "method", method);
1254 }
1255
1256 if (10 == (int) (obj->message->http.version * 10)) {
1257 add_assoc_long(array, "protocol", CURL_HTTP_VERSION_1_0);
1258 }
1259
1260 MAKE_STD_ZVAL(headers);
1261 array_init(headers);
1262 array_copy(&obj->message->hdrs, Z_ARRVAL_P(headers));
1263 add_assoc_zval(array, "headers", headers);
1264
1265 object_init_ex(return_value, http_request_object_ce);
1266 zend_call_method_with_1_params(&return_value, http_request_object_ce, NULL, "setoptions", NULL, array);
1267 zval_ptr_dtor(&array);
1268
1269 INIT_PZVAL(&body);
1270 ZVAL_STRINGL(&body, PHPSTR_VAL(obj->message), PHPSTR_LEN(obj->message), 0);
1271 zend_call_method_with_1_params(&return_value, http_request_object_ce, NULL, "setrawpostdata", NULL, &body);
1272 #else
1273 http_error(HE_WARNING, HTTP_E_RUNTIME, "Cannot transform HttpMessage to HttpRequest (missing curl support)");
1274 #endif
1275 break;
1276 }
1277
1278 case HTTP_MSG_RESPONSE:
1279 {
1280 #ifndef WONKY
1281 HashPosition pos1, pos2;
1282 HashKey key = initHashKey(0);
1283 zval **header, **h, *body;
1284
1285 if (obj->message->http.info.response.code) {
1286 http_send_status(obj->message->http.info.response.code);
1287 }
1288
1289 object_init_ex(return_value, http_response_object_ce);
1290
1291 FOREACH_HASH_KEYVAL(pos1, &obj->message->hdrs, key, header) {
1292 if (key.type == HASH_KEY_IS_STRING) {
1293 zval *zkey;
1294
1295 MAKE_STD_ZVAL(zkey);
1296 ZVAL_STRINGL(zkey, key.str, key.len - 1, 1);
1297
1298 switch (Z_TYPE_PP(header)) {
1299 case IS_ARRAY:
1300 case IS_OBJECT:
1301 FOREACH_HASH_VAL(pos2, HASH_OF(*header), h) {
1302 ZVAL_ADDREF(*h);
1303 zend_call_method_with_2_params(&return_value, http_response_object_ce, NULL, "setheader", NULL, zkey, *h);
1304 zval_ptr_dtor(h);
1305 }
1306 break;
1307
1308 default:
1309 ZVAL_ADDREF(*header);
1310 zend_call_method_with_2_params(&return_value, http_response_object_ce, NULL, "setheader", NULL, zkey, *header);
1311 zval_ptr_dtor(header);
1312 break;
1313 }
1314 zval_ptr_dtor(&zkey);
1315 }
1316 }
1317
1318 MAKE_STD_ZVAL(body);
1319 ZVAL_STRINGL(body, PHPSTR_VAL(obj->message), PHPSTR_LEN(obj->message), 1);
1320 zend_call_method_with_1_params(&return_value, http_response_object_ce, NULL, "setdata", NULL, body);
1321 zval_ptr_dtor(&body);
1322 #else
1323 http_error(HE_WARNING, HTTP_E_RUNTIME, "Cannot transform HttpMessage to HttpResponse (need PHP 5.1+)");
1324 #endif
1325 break;
1326 }
1327
1328 default:
1329 http_error(HE_WARNING, HTTP_E_MESSAGE_TYPE, "HttpMessage is neither of type HttpMessage::TYPE_REQUEST nor HttpMessage::TYPE_RESPONSE");
1330 break;
1331 }
1332 }
1333 SET_EH_NORMAL();
1334 }
1335 /* }}} */
1336
1337 /* {{{ proto int HttpMessage::count()
1338 Implements Countable::count(). Returns the number of parent messages + 1. */
1339 PHP_METHOD(HttpMessage, count)
1340 {
1341 NO_ARGS {
1342 long i;
1343 getObject(http_message_object, obj);
1344
1345 http_message_count(i, obj->message);
1346 RETURN_LONG(i);
1347 }
1348 }
1349 /* }}} */
1350
1351 /* {{{ proto string HttpMessage::serialize()
1352 Implements Serializable::serialize(). Returns the serialized representation of the HttpMessage. */
1353 PHP_METHOD(HttpMessage, serialize)
1354 {
1355 NO_ARGS {
1356 char *string;
1357 size_t length;
1358 getObject(http_message_object, obj);
1359
1360 http_message_serialize(obj->message, &string, &length);
1361 RETURN_STRINGL(string, length, 0);
1362 }
1363 }
1364 /* }}} */
1365
1366 /* {{{ proto void HttpMessage::unserialize(string serialized)
1367 Implements Serializable::unserialize(). Re-constructs the HttpMessage based upon the serialized string. */
1368 PHP_METHOD(HttpMessage, unserialize)
1369 {
1370 int length;
1371 char *serialized;
1372 getObject(http_message_object, obj);
1373
1374 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &serialized, &length)) {
1375 http_message *msg;
1376
1377 http_message_dtor(obj->message);
1378 if ((msg = http_message_parse_ex(obj->message, serialized, (size_t) length))) {
1379 obj->message = msg;
1380 } else {
1381 http_error(HE_ERROR, HTTP_E_RUNTIME, "Could not unserialize HttpMessage");
1382 http_message_init(obj->message);
1383 }
1384 }
1385 }
1386 /* }}} */
1387
1388 /* {{{ proto HttpMessage HttpMessage::detach(void)
1389 Returns a clone of an HttpMessage object detached from any parent messages. */
1390 PHP_METHOD(HttpMessage, detach)
1391 {
1392 http_info info;
1393 http_message *msg;
1394 getObject(http_message_object, obj);
1395
1396 NO_ARGS;
1397
1398 info.type = obj->message->type;
1399 memcpy(&HTTP_INFO(&info), &HTTP_INFO(obj->message), sizeof(struct http_info));
1400
1401 msg = http_message_new();
1402 http_message_set_info(msg, &info);
1403
1404 zend_hash_copy(&msg->hdrs, &obj->message->hdrs, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
1405 phpstr_append(&msg->body, PHPSTR_VAL(obj->message), PHPSTR_LEN(obj->message));
1406
1407 RETVAL_OBJVAL(http_message_object_new_ex(Z_OBJCE_P(getThis()), msg, NULL), 0);
1408 }
1409 /* }}} */
1410
1411 /* {{{ proto void HttpMessage::prepend(HttpMessage message[, bool top = true])
1412 Prepends message(s) to the HTTP message. Throws HttpInvalidParamException if the message is located within the same message chain. */
1413 PHP_METHOD(HttpMessage, prepend)
1414 {
1415 zval *prepend;
1416 zend_bool top = 1;
1417
1418 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|b", &prepend, http_message_object_ce, &top)) {
1419 http_message *msg[2];
1420 getObject(http_message_object, obj);
1421 getObjectEx(http_message_object, prepend_obj, prepend);
1422
1423 /* safety check */
1424 for (msg[0] = obj->message; msg[0]; msg[0] = msg[0]->parent) {
1425 for (msg[1] = prepend_obj->message; msg[1]; msg[1] = msg[1]->parent) {
1426 if (msg[0] == msg[1]) {
1427 http_error(HE_THROW, HTTP_E_INVALID_PARAM, "Cannot prepend a message located within the same message chain");
1428 return;
1429 }
1430 }
1431 }
1432
1433 http_message_object_prepend_ex(getThis(), prepend, top);
1434 }
1435 }
1436 /* }}} */
1437
1438 /* {{{ proto HttpMessage HttpMessage::reverse()
1439 Reorders the message chain in reverse order. Returns the most parent HttpMessage object. */
1440 PHP_METHOD(HttpMessage, reverse)
1441 {
1442 NO_ARGS {
1443 http_message_object_reverse(getThis(), return_value);
1444 }
1445 }
1446 /* }}} */
1447
1448 /* {{{ proto void HttpMessage::rewind(void)
1449 Implements Iterator::rewind(). */
1450 PHP_METHOD(HttpMessage, rewind)
1451 {
1452 NO_ARGS {
1453 getObject(http_message_object, obj);
1454
1455 if (obj->iterator) {
1456 zval_ptr_dtor(&obj->iterator);
1457 }
1458 ZVAL_ADDREF(getThis());
1459 obj->iterator = getThis();
1460 }
1461 }
1462 /* }}} */
1463
1464 /* {{{ proto bool HttpMessage::valid(void)
1465 Implements Iterator::valid(). */
1466 PHP_METHOD(HttpMessage, valid)
1467 {
1468 NO_ARGS {
1469 getObject(http_message_object, obj);
1470
1471 RETURN_BOOL(obj->iterator != NULL);
1472 }
1473 }
1474 /* }}} */
1475
1476 /* {{{ proto void HttpMessage::next(void)
1477 Implements Iterator::next(). */
1478 PHP_METHOD(HttpMessage, next)
1479 {
1480 NO_ARGS {
1481 getObject(http_message_object, obj);
1482 getObjectEx(http_message_object, itr, obj->iterator);
1483
1484 if (itr && itr->parent.handle) {
1485 zval *old = obj->iterator;
1486 MAKE_STD_ZVAL(obj->iterator);
1487 ZVAL_OBJVAL(obj->iterator, itr->parent, 1);
1488 zval_ptr_dtor(&old);
1489 } else {
1490 zval_ptr_dtor(&obj->iterator);
1491 obj->iterator = NULL;
1492 }
1493 }
1494 }
1495 /* }}} */
1496
1497 /* {{{ proto int HttpMessage::key(void)
1498 Implements Iterator::key(). */
1499 PHP_METHOD(HttpMessage, key)
1500 {
1501 NO_ARGS {
1502 getObject(http_message_object, obj);
1503
1504 RETURN_LONG(obj->iterator ? obj->iterator->value.obj.handle:0);
1505 }
1506 }
1507 /* }}} */
1508
1509 /* {{{ proto HttpMessage HttpMessage::current(void)
1510 Implements Iterator::current(). */
1511 PHP_METHOD(HttpMessage, current)
1512 {
1513 NO_ARGS {
1514 getObject(http_message_object, obj);
1515
1516 if (obj->iterator) {
1517 RETURN_ZVAL(obj->iterator, 1, 0);
1518 }
1519 }
1520 }
1521 /* }}} */
1522
1523 #endif /* ZEND_ENGINE_2 */
1524
1525 /*
1526 * Local variables:
1527 * tab-width: 4
1528 * c-basic-offset: 4
1529 * End:
1530 * vim600: noet sw=4 ts=4 fdm=marker
1531 * vim<600: noet sw=4 ts=4
1532 */
1533
Extended HTTP Support