git.m6w6.name Git - m6w6/ext-http/blob - 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-2005, Michael Wallner <mike@php.net>            |
  10     +--------------------------------------------------------------------+
  11 */
  12
  13 /* $Id$ */
  14
  15
  16 #ifdef HAVE_CONFIG_H
  17 #       include "config.h"
  18 #endif
  19
  20 #include "php_http.h"
  21
  22 #ifdef ZEND_ENGINE_2
  23
  24 #include "php_http_api.h"
  25 #include "php_http_message_api.h"
  26 #include "php_http_message_object.h"
  27 #include "php_http_exception_object.h"
  28
  29 #ifndef WONKY
  30 #       include "zend_interfaces.h"
  31 #       if defined(HAVE_SPL)
  32 /* SPL doesn't install its headers */
  33 extern PHPAPI zend_class_entry *spl_ce_Countable;
  34 #       endif
  35 #endif
  36
  37 #define HTTP_BEGIN_ARGS(method, ret_ref, req_args)      HTTP_BEGIN_ARGS_EX(HttpMessage, method, ret_ref, req_args)
  38 #define HTTP_EMPTY_ARGS(method, ret_ref)                        HTTP_EMPTY_ARGS_EX(HttpMessage, method, ret_ref)
  39 #define HTTP_MESSAGE_ME(method, visibility)                     PHP_ME(HttpMessage, method, HTTP_ARGS(HttpMessage, method), visibility)
  40
  41 HTTP_BEGIN_ARGS(__construct, 0, 0)
  42         HTTP_ARG_VAL(message, 0)
  43 HTTP_END_ARGS;
  44
  45 HTTP_BEGIN_ARGS(fromString, 1, 1)
  46         HTTP_ARG_VAL(message, 0)
  47 HTTP_END_ARGS;
  48
  49 HTTP_EMPTY_ARGS(getBody, 0);
  50 HTTP_BEGIN_ARGS(setBody, 0, 1)
  51         HTTP_ARG_VAL(body, 0)
  52 HTTP_END_ARGS;
  53
  54 HTTP_EMPTY_ARGS(getHeaders, 0);
  55 HTTP_BEGIN_ARGS(setHeaders, 0, 1)
  56         HTTP_ARG_VAL(headers, 0)
  57 HTTP_END_ARGS;
  58
  59 HTTP_BEGIN_ARGS(addHeaders, 0, 1)
  60         HTTP_ARG_VAL(headers, 0)
  61         HTTP_ARG_VAL(append, 0)
  62 HTTP_END_ARGS;
  63
  64 HTTP_EMPTY_ARGS(getType, 0);
  65 HTTP_BEGIN_ARGS(setType, 0, 1)
  66         HTTP_ARG_VAL(type, 0)
  67 HTTP_END_ARGS;
  68
  69 HTTP_EMPTY_ARGS(getResponseCode, 0);
  70 HTTP_BEGIN_ARGS(setResponseCode, 0, 1)
  71         HTTP_ARG_VAL(response_code, 0)
  72 HTTP_END_ARGS;
  73
  74 HTTP_EMPTY_ARGS(getRequestMethod, 0);
  75 HTTP_BEGIN_ARGS(setRequestMethod, 0, 1)
  76         HTTP_ARG_VAL(request_method, 0)
  77 HTTP_END_ARGS;
  78
  79 HTTP_EMPTY_ARGS(getRequestUri, 0);
  80 HTTP_BEGIN_ARGS(setRequestUri, 0, 1)
  81         HTTP_ARG_VAL(uri, 0)
  82 HTTP_END_ARGS;
  83
  84 HTTP_EMPTY_ARGS(getHttpVersion, 0);
  85 HTTP_BEGIN_ARGS(setHttpVersion, 0, 1)
  86         HTTP_ARG_VAL(http_version, 0)
  87 HTTP_END_ARGS;
  88
  89 HTTP_EMPTY_ARGS(getParentMessage, 1);
  90 HTTP_EMPTY_ARGS(send, 0);
  91 HTTP_BEGIN_ARGS(toString, 0, 0)
  92         HTTP_ARG_VAL(include_parent, 0)
  93 HTTP_END_ARGS;
  94
  95 HTTP_EMPTY_ARGS(count, 0);
  96
  97 HTTP_EMPTY_ARGS(serialize, 0);
  98 HTTP_BEGIN_ARGS(unserialize, 0, 1)
  99         HTTP_ARG_VAL(serialized, 0)
 100 HTTP_END_ARGS;
 101
 102 #define http_message_object_declare_default_properties() _http_message_object_declare_default_properties(TSRMLS_C)
 103 static inline void _http_message_object_declare_default_properties(TSRMLS_D);
 104 #define http_message_object_read_prop _http_message_object_read_prop
 105 static zval *_http_message_object_read_prop(zval *object, zval *member, int type TSRMLS_DC);
 106 #define http_message_object_write_prop _http_message_object_write_prop
 107 static void _http_message_object_write_prop(zval *object, zval *member, zval *value TSRMLS_DC);
 108 #define http_message_object_get_props _http_message_object_get_props
 109 static HashTable *_http_message_object_get_props(zval *object TSRMLS_DC);
 110
 111 zend_class_entry *http_message_object_ce;
 112 zend_function_entry http_message_object_fe[] = {
 113         HTTP_MESSAGE_ME(__construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
 114         HTTP_MESSAGE_ME(getBody, ZEND_ACC_PUBLIC)
 115         HTTP_MESSAGE_ME(setBody, ZEND_ACC_PUBLIC)
 116         HTTP_MESSAGE_ME(getHeaders, ZEND_ACC_PUBLIC)
 117         HTTP_MESSAGE_ME(setHeaders, ZEND_ACC_PUBLIC)
 118         HTTP_MESSAGE_ME(addHeaders, ZEND_ACC_PUBLIC)
 119         HTTP_MESSAGE_ME(getType, ZEND_ACC_PUBLIC)
 120         HTTP_MESSAGE_ME(setType, ZEND_ACC_PUBLIC)
 121         HTTP_MESSAGE_ME(getResponseCode, ZEND_ACC_PUBLIC)
 122         HTTP_MESSAGE_ME(setResponseCode, ZEND_ACC_PUBLIC)
 123         HTTP_MESSAGE_ME(getRequestMethod, ZEND_ACC_PUBLIC)
 124         HTTP_MESSAGE_ME(setRequestMethod, ZEND_ACC_PUBLIC)
 125         HTTP_MESSAGE_ME(getRequestUri, ZEND_ACC_PUBLIC)
 126         HTTP_MESSAGE_ME(setRequestUri, ZEND_ACC_PUBLIC)
 127         HTTP_MESSAGE_ME(getHttpVersion, ZEND_ACC_PUBLIC)
 128         HTTP_MESSAGE_ME(setHttpVersion, ZEND_ACC_PUBLIC)
 129         HTTP_MESSAGE_ME(getParentMessage, ZEND_ACC_PUBLIC)
 130         HTTP_MESSAGE_ME(send, ZEND_ACC_PUBLIC)
 131         HTTP_MESSAGE_ME(toString, ZEND_ACC_PUBLIC)
 132
 133         /* implements Countable */
 134         HTTP_MESSAGE_ME(count, ZEND_ACC_PUBLIC)
 135
 136         /* implements Serializable */
 137         HTTP_MESSAGE_ME(serialize, ZEND_ACC_PUBLIC)
 138         HTTP_MESSAGE_ME(unserialize, ZEND_ACC_PUBLIC)
 139
 140         ZEND_MALIAS(HttpMessage, __toString, toString, HTTP_ARGS(HttpMessage, toString), ZEND_ACC_PUBLIC)
 141
 142         HTTP_MESSAGE_ME(fromString, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 143
 144         EMPTY_FUNCTION_ENTRY
 145 };
 146 static zend_object_handlers http_message_object_handlers;
 147
 148 PHP_MINIT_FUNCTION(http_message_object)
 149 {
 150         HTTP_REGISTER_CLASS_EX(HttpMessage, http_message_object, NULL, 0);
 151 #ifndef WONKY
 152 #       ifdef HAVE_SPL
 153         zend_class_implements(http_message_object_ce TSRMLS_CC, 2, spl_ce_Countable, zend_ce_serializable);
 154 #       else
 155         zend_class_implements(http_message_object_ce TSRMLS_CC, 1, zend_ce_serializable);
 156 #       endif
 157 #endif
 158
 159         HTTP_LONG_CONSTANT("HTTP_MSG_NONE", HTTP_MSG_NONE);
 160         HTTP_LONG_CONSTANT("HTTP_MSG_REQUEST", HTTP_MSG_REQUEST);
 161         HTTP_LONG_CONSTANT("HTTP_MSG_RESPONSE", HTTP_MSG_RESPONSE);
 162
 163         http_message_object_handlers.clone_obj = _http_message_object_clone_obj;
 164         http_message_object_handlers.read_property = http_message_object_read_prop;
 165         http_message_object_handlers.write_property = http_message_object_write_prop;
 166         http_message_object_handlers.get_properties = http_message_object_get_props;
 167         http_message_object_handlers.get_property_ptr_ptr = NULL;
 168
 169         return SUCCESS;
 170 }
 171
 172 zend_object_value _http_message_object_new(zend_class_entry *ce TSRMLS_DC)
 173 {
 174         return http_message_object_new_ex(ce, NULL, NULL);
 175 }
 176
 177 zend_object_value _http_message_object_new_ex(zend_class_entry *ce, http_message *msg, http_message_object **ptr TSRMLS_DC)
 178 {
 179         zend_object_value ov;
 180         http_message_object *o;
 181
 182         o = ecalloc(1, sizeof(http_message_object));
 183         o->zo.ce = ce;
 184
 185         if (ptr) {
 186                 *ptr = o;
 187         }
 188
 189         if (msg) {
 190                 o->message = msg;
 191                 if (msg->parent) {
 192                         o->parent = http_message_object_new_ex(ce, msg->parent, NULL);
 193                 }
 194         }
 195
 196         ALLOC_HASHTABLE(OBJ_PROP(o));
 197         zend_hash_init(OBJ_PROP(o), 0, NULL, ZVAL_PTR_DTOR, 0);
 198
 199         ov.handle = putObject(http_message_object, o);
 200         ov.handlers = &http_message_object_handlers;
 201
 202         return ov;
 203 }
 204
 205 zend_object_value _http_message_object_clone_obj(zval *this_ptr TSRMLS_DC)
 206 {
 207         getObject(http_message_object, obj);
 208         return http_message_object_new_ex(Z_OBJCE_P(this_ptr), http_message_dup(obj->message), NULL);
 209 }
 210
 211 static inline void _http_message_object_declare_default_properties(TSRMLS_D)
 212 {
 213         zend_class_entry *ce = http_message_object_ce;
 214
 215 #ifndef WONKY
 216         DCL_CONST(long, "TYPE_NONE", HTTP_MSG_NONE);
 217         DCL_CONST(long, "TYPE_REQUEST", HTTP_MSG_REQUEST);
 218         DCL_CONST(long, "TYPE_RESPONSE", HTTP_MSG_RESPONSE);
 219 #endif
 220
 221         DCL_PROP(PROTECTED, long, type, HTTP_MSG_NONE);
 222         DCL_PROP(PROTECTED, string, body, "");
 223         DCL_PROP(PROTECTED, string, requestMethod, "");
 224         DCL_PROP(PROTECTED, string, requestUri, "");
 225         DCL_PROP(PROTECTED, long, responseCode, 0);
 226         DCL_PROP_N(PROTECTED, httpVersion);
 227         DCL_PROP_N(PROTECTED, headers);
 228         DCL_PROP_N(PROTECTED, parentMessage);
 229 }
 230
 231 void _http_message_object_free(zend_object *object TSRMLS_DC)
 232 {
 233         http_message_object *o = (http_message_object *) object;
 234
 235         if (OBJ_PROP(o)) {
 236                 zend_hash_destroy(OBJ_PROP(o));
 237                 FREE_HASHTABLE(OBJ_PROP(o));
 238         }
 239         if (o->message) {
 240                 http_message_dtor(o->message);
 241                 efree(o->message);
 242         }
 243         efree(o);
 244 }
 245
 246 static zval *_http_message_object_read_prop(zval *object, zval *member, int type TSRMLS_DC)
 247 {
 248         getObjectEx(http_message_object, obj, object);
 249         http_message *msg = obj->message;
 250         zval *return_value;
 251 #ifdef WONKY
 252         ulong h = zend_get_hash_value(Z_STRVAL_P(member), Z_STRLEN_P(member)+1);
 253 #else
 254         zend_property_info *pinfo = zend_get_property_info(obj->zo.ce, member, 1 TSRMLS_CC);
 255
 256         if (!pinfo || ACC_PROP_PUBLIC(pinfo->flags)) {
 257                 return zend_get_std_object_handlers()->read_property(object, member, type TSRMLS_CC);
 258         }
 259 #endif
 260
 261         if (type == BP_VAR_W) {
 262                 zend_error(E_ERROR, "Cannot access HttpMessage properties by reference or array key/index");
 263                 return NULL;
 264         }
 265
 266         ALLOC_ZVAL(return_value);
 267         return_value->refcount = 0;
 268         return_value->is_ref = 0;
 269
 270 #ifdef WONKY
 271         switch (h)
 272 #else
 273         switch (pinfo->h)
 274 #endif
 275         {
 276                 case HTTP_MSG_PROPHASH_TYPE:
 277                 case HTTP_MSG_CHILD_PROPHASH_TYPE:
 278                         RETVAL_LONG(msg->type);
 279                 break;
 280
 281                 case HTTP_MSG_PROPHASH_HTTP_VERSION:
 282                 case HTTP_MSG_CHILD_PROPHASH_HTTP_VERSION:
 283                         RETVAL_DOUBLE(msg->http.version);
 284                 break;
 285
 286                 case HTTP_MSG_PROPHASH_BODY:
 287                 case HTTP_MSG_CHILD_PROPHASH_BODY:
 288                         phpstr_fix(PHPSTR(msg));
 289                         RETVAL_PHPSTR(PHPSTR(msg), 0, 1);
 290                 break;
 291
 292                 case HTTP_MSG_PROPHASH_HEADERS:
 293                 case HTTP_MSG_CHILD_PROPHASH_HEADERS:
 294                         array_init(return_value);
 295                         zend_hash_copy(Z_ARRVAL_P(return_value), &msg->hdrs, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
 296                 break;
 297
 298                 case HTTP_MSG_PROPHASH_PARENT_MESSAGE:
 299                 case HTTP_MSG_CHILD_PROPHASH_PARENT_MESSAGE:
 300                         if (msg->parent) {
 301                                 RETVAL_OBJVAL(obj->parent);
 302                         } else {
 303                                 RETVAL_NULL();
 304                         }
 305                 break;
 306
 307                 case HTTP_MSG_PROPHASH_REQUEST_METHOD:
 308                 case HTTP_MSG_CHILD_PROPHASH_REQUEST_METHOD:
 309                         if (HTTP_MSG_TYPE(REQUEST, msg) && msg->http.info.request.method) {
 310                                 RETVAL_STRING(msg->http.info.request.method, 1);
 311                         } else {
 312                                 RETVAL_NULL();
 313                         }
 314                 break;
 315
 316                 case HTTP_MSG_PROPHASH_REQUEST_URI:
 317                 case HTTP_MSG_CHILD_PROPHASH_REQUEST_URI:
 318                         if (HTTP_MSG_TYPE(REQUEST, msg) && msg->http.info.request.URI) {
 319                                 RETVAL_STRING(msg->http.info.request.URI, 1);
 320                         } else {
 321                                 RETVAL_NULL();
 322                         }
 323                 break;
 324
 325                 case HTTP_MSG_PROPHASH_RESPONSE_CODE:
 326                 case HTTP_MSG_CHILD_PROPHASH_RESPONSE_CODE:
 327                         if (HTTP_MSG_TYPE(RESPONSE, msg)) {
 328                                 RETVAL_LONG(msg->http.info.response.code);
 329                         } else {
 330                                 RETVAL_NULL();
 331                         }
 332                 break;
 333
 334                 case HTTP_MSG_PROPHASH_RESPONSE_STATUS:
 335                 case HTTP_MSG_CHILD_PROPHASH_RESPONSE_STATUS:
 336                         if (HTTP_MSG_TYPE(RESPONSE, msg) && msg->http.info.response.status) {
 337                                 RETVAL_STRING(msg->http.info.response.status, 1);
 338                         } else {
 339                                 RETVAL_NULL();
 340                         }
 341                 break;
 342
 343                 default:
 344 #ifdef WONKY
 345                         return zend_get_std_object_handlers()->read_property(object, member, type TSRMLS_CC);
 346 #else
 347                         RETVAL_NULL();
 348 #endif
 349                 break;
 350         }
 351
 352         return return_value;
 353 }
 354
 355 static void _http_message_object_write_prop(zval *object, zval *member, zval *value TSRMLS_DC)
 356 {
 357         getObjectEx(http_message_object, obj, object);
 358         http_message *msg = obj->message;
 359         zval *cpy = NULL;
 360 #ifdef WONKY
 361         ulong h = zend_get_hash_value(Z_STRVAL_P(member), Z_STRLEN_P(member) + 1);
 362 #else
 363         zend_property_info *pinfo = zend_get_property_info(obj->zo.ce, member, 1 TSRMLS_CC);
 364
 365         if (!pinfo || ACC_PROP_PUBLIC(pinfo->flags)) {
 366                 zend_get_std_object_handlers()->write_property(object, member, value TSRMLS_CC);
 367                 return;
 368         }
 369 #endif
 370
 371         cpy = zval_copy(Z_TYPE_P(value), value);
 372
 373 #ifdef WONKY
 374         switch (h)
 375 #else
 376         switch (pinfo->h)
 377 #endif
 378         {
 379                 case HTTP_MSG_PROPHASH_TYPE:
 380                 case HTTP_MSG_CHILD_PROPHASH_TYPE:
 381                         convert_to_long(cpy);
 382                         http_message_set_type(msg, Z_LVAL_P(cpy));
 383                 break;
 384
 385                 case HTTP_MSG_PROPHASH_HTTP_VERSION:
 386                 case HTTP_MSG_CHILD_PROPHASH_HTTP_VERSION:
 387                         convert_to_double(cpy);
 388                         msg->http.version = Z_DVAL_P(cpy);
 389                 break;
 390
 391                 case HTTP_MSG_PROPHASH_BODY:
 392                 case HTTP_MSG_CHILD_PROPHASH_BODY:
 393                         convert_to_string(cpy);
 394                         phpstr_dtor(PHPSTR(msg));
 395                         phpstr_from_string_ex(PHPSTR(msg), Z_STRVAL_P(cpy), Z_STRLEN_P(cpy));
 396                 break;
 397
 398                 case HTTP_MSG_PROPHASH_HEADERS:
 399                 case HTTP_MSG_CHILD_PROPHASH_HEADERS:
 400                         convert_to_array(cpy);
 401                         zend_hash_clean(&msg->hdrs);
 402                         zend_hash_copy(&msg->hdrs, Z_ARRVAL_P(cpy), (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
 403                 break;
 404
 405                 case HTTP_MSG_PROPHASH_PARENT_MESSAGE:
 406                 case HTTP_MSG_CHILD_PROPHASH_PARENT_MESSAGE:
 407                         if (Z_TYPE_P(value) == IS_OBJECT && instanceof_function(Z_OBJCE_P(value), http_message_object_ce TSRMLS_CC)) {
 408                                 if (msg->parent) {
 409                                         zval tmp;
 410                                         tmp.value.obj = obj->parent;
 411                                         Z_OBJ_DELREF(tmp);
 412                                 }
 413                                 Z_OBJ_ADDREF_P(value);
 414                                 obj->parent = value->value.obj;
 415                         }
 416                 break;
 417
 418                 case HTTP_MSG_PROPHASH_REQUEST_METHOD:
 419                 case HTTP_MSG_CHILD_PROPHASH_REQUEST_METHOD:
 420                         if (HTTP_MSG_TYPE(REQUEST, msg)) {
 421                                 convert_to_string(cpy);
 422                                 STR_SET(msg->http.info.request.method, estrndup(Z_STRVAL_P(cpy), Z_STRLEN_P(cpy)));
 423                         }
 424                 break;
 425
 426                 case HTTP_MSG_PROPHASH_REQUEST_URI:
 427                 case HTTP_MSG_CHILD_PROPHASH_REQUEST_URI:
 428                         if (HTTP_MSG_TYPE(REQUEST, msg)) {
 429                                 convert_to_string(cpy);
 430                                 STR_SET(msg->http.info.request.URI, estrndup(Z_STRVAL_P(cpy), Z_STRLEN_P(cpy)));
 431                         }
 432                 break;
 433
 434                 case HTTP_MSG_PROPHASH_RESPONSE_CODE:
 435                 case HTTP_MSG_CHILD_PROPHASH_RESPONSE_CODE:
 436                         if (HTTP_MSG_TYPE(RESPONSE, msg)) {
 437                                 convert_to_long(cpy);
 438                                 msg->http.info.response.code = Z_LVAL_P(cpy);
 439                         }
 440                 break;
 441
 442                 case HTTP_MSG_PROPHASH_RESPONSE_STATUS:
 443                 case HTTP_MSG_CHILD_PROPHASH_RESPONSE_STATUS:
 444                         if (HTTP_MSG_TYPE(RESPONSE, msg)) {
 445                                 convert_to_string(cpy);
 446                                 STR_SET(msg->http.info.response.status, estrndup(Z_STRVAL_P(cpy), Z_STRLEN_P(cpy)));
 447                         }
 448                 break;
 449
 450                 default:
 451 #ifdef WONKY
 452                         zend_get_std_object_handlers()->write_property(object, member, value TSRMLS_CC);
 453 #endif
 454                 break;
 455         }
 456         zval_free(&cpy);
 457 }
 458
 459 static HashTable *_http_message_object_get_props(zval *object TSRMLS_DC)
 460 {
 461         zval *headers;
 462         getObjectEx(http_message_object, obj, object);
 463         http_message *msg = obj->message;
 464         HashTable *props = OBJ_PROP(obj);
 465         zval array;
 466
 467         INIT_ZARR(array, props);
 468
 469 #define ASSOC_PROP(array, ptype, name, val) \
 470         { \
 471                 char *m_prop_name; \
 472                 int m_prop_len; \
 473                 zend_mangle_property_name(&m_prop_name, &m_prop_len, "*", 1, name, lenof(name), 0); \
 474                 add_assoc_ ##ptype## _ex(&array, m_prop_name, sizeof(name)+3, val); \
 475                 efree(m_prop_name); \
 476         }
 477 #define ASSOC_STRING(array, name, val) ASSOC_STRINGL(array, name, val, strlen(val))
 478 #define ASSOC_STRINGL(array, name, val, len) \
 479         { \
 480                 char *m_prop_name; \
 481                 int m_prop_len; \
 482                 zend_mangle_property_name(&m_prop_name, &m_prop_len, "*", 1, name, lenof(name), 0); \
 483                 add_assoc_stringl_ex(&array, m_prop_name, sizeof(name)+3, val, len, 1); \
 484                 efree(m_prop_name); \
 485         }
 486
 487         ASSOC_PROP(array, long, "type", msg->type);
 488         ASSOC_PROP(array, double, "httpVersion", msg->http.version);
 489
 490         switch (msg->type)
 491         {
 492                 case HTTP_MSG_REQUEST:
 493                         ASSOC_PROP(array, long, "responseCode", 0);
 494                         ASSOC_STRINGL(array, "responseStatus", "", 0);
 495                         ASSOC_STRING(array, "requestMethod", msg->http.info.request.method);
 496                         ASSOC_STRING(array, "requestUri", msg->http.info.request.URI);
 497                 break;
 498
 499                 case HTTP_MSG_RESPONSE:
 500                         ASSOC_PROP(array, long, "responseCode", msg->http.info.response.code);
 501                         ASSOC_STRING(array, "responseStatus", msg->http.info.response.status);
 502                         ASSOC_STRINGL(array, "requestMethod", "", 0);
 503                         ASSOC_STRINGL(array, "requestUri", "", 0);
 504                 break;
 505
 506                 case HTTP_MSG_NONE:
 507                 default:
 508                         ASSOC_PROP(array, long, "responseCode", 0);
 509                         ASSOC_STRINGL(array, "responseStatus", "", 0);
 510                         ASSOC_STRINGL(array, "requestMethod", "", 0);
 511                         ASSOC_STRINGL(array, "requestUri", "", 0);
 512                 break;
 513         }
 514
 515         MAKE_STD_ZVAL(headers);
 516         array_init(headers);
 517         zend_hash_copy(Z_ARRVAL_P(headers), &msg->hdrs, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
 518         ASSOC_PROP(array, zval, "headers", headers);
 519         ASSOC_STRINGL(array, "body", PHPSTR_VAL(msg), PHPSTR_LEN(msg));
 520
 521         return OBJ_PROP(obj);
 522 }
 523
 524 /* ### USERLAND ### */
 525
 526 /* {{{ proto void HttpMessage::__construct([string message])
 527  *
 528  * Instantiate a new HttpMessage object.
 529  *
 530  * Accepts an optional string parameter containing a single or several
 531  * consecutive HTTP messages.  The constructed object will actually
 532  * represent the *last* message of the passed string.  If there were
 533  * prior messages, those can be accessed by HttpMessage::getParentMessage().
 534  *
 535  * Throws HttpMalformedHeaderException.
 536  */
 537 PHP_METHOD(HttpMessage, __construct)
 538 {
 539         int length = 0;
 540         char *message = NULL;
 541
 542         getObject(http_message_object, obj);
 543
 544         SET_EH_THROW_HTTP();
 545         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &message, &length) && message && length) {
 546                 http_message *msg = obj->message;
 547
 548                 http_message_dtor(msg);
 549                 if ((obj->message = http_message_parse_ex(msg, message, length))) {
 550                         if (obj->message->parent) {
 551                                 obj->parent = http_message_object_new_ex(Z_OBJCE_P(getThis()), obj->message->parent, NULL);
 552                         }
 553                 } else {
 554                         obj->message = http_message_init(msg);
 555                 }
 556         }
 557         if (!obj->message) {
 558                 obj->message = http_message_new();
 559         }
 560         SET_EH_NORMAL();
 561 }
 562 /* }}} */
 563
 564 /* {{{ proto static HttpMessage HttpMessage::fromString(string raw_message)
 565  *
 566  * Create an HttpMessage object from a string. Kind of a static constructor.
 567  *
 568  * Expects a string parameter containing a sinlge or several consecutive
 569  * HTTP messages.
 570  *
 571  * Returns an HttpMessage object on success or NULL on failure.
 572  *
 573  * Throws HttpMalformedHeadersException.
 574  */
 575 PHP_METHOD(HttpMessage, fromString)
 576 {
 577         char *string = NULL;
 578         int length = 0;
 579         http_message *msg = NULL;
 580
 581         RETVAL_NULL();
 582
 583         SET_EH_THROW_HTTP();
 584         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &string, &length)) {
 585                 if ((msg = http_message_parse(string, length))) {
 586                         ZVAL_OBJVAL(return_value, http_message_object_new_ex(http_message_object_ce, msg, NULL));
 587                 }
 588         }
 589         SET_EH_NORMAL();
 590 }
 591 /* }}} */
 592
 593 /* {{{ proto string HttpMessage::getBody()
 594  *
 595  * Get the body of the parsed HttpMessage.
 596  *
 597  * Returns the message body as string.
 598  */
 599 PHP_METHOD(HttpMessage, getBody)
 600 {
 601         NO_ARGS;
 602
 603         IF_RETVAL_USED {
 604                 getObject(http_message_object, obj);
 605                 RETURN_PHPSTR(&obj->message->body, PHPSTR_FREE_NOT, 1);
 606         }
 607 }
 608 /* }}} */
 609
 610 /* {{{ proto void HttpMessage::setBody(string body)
 611  *
 612  * Set the body of the HttpMessage.
 613  * NOTE: Don't forget to update any headers accordingly.
 614  *
 615  * Expects a string parameter containing the new body of the message.
 616  */
 617 PHP_METHOD(HttpMessage, setBody)
 618 {
 619         char *body;
 620         int len;
 621         getObject(http_message_object, obj);
 622
 623         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &body, &len)) {
 624                 phpstr_dtor(PHPSTR(obj->message));
 625                 phpstr_from_string_ex(PHPSTR(obj->message), body, len);
 626         }
 627 }
 628 /* }}} */
 629
 630 /* {{{ proto array HttpMessage::getHeaders()
 631  *
 632  * Get Message Headers.
 633  *
 634  * Returns an associative array containing the messages HTTP headers.
 635  */
 636 PHP_METHOD(HttpMessage, getHeaders)
 637 {
 638         NO_ARGS;
 639
 640         IF_RETVAL_USED {
 641                 zval headers;
 642                 getObject(http_message_object, obj);
 643
 644                 INIT_ZARR(headers, &obj->message->hdrs);
 645                 array_init(return_value);
 646                 array_copy(&headers, return_value);
 647         }
 648 }
 649 /* }}} */
 650
 651 /* {{{ proto void HttpMessage::setHeaders(array headers)
 652  *
 653  * Sets new headers.
 654  *
 655  * Expects an associative array as parameter containing the new HTTP headers,
 656  * which will replace *all* previous HTTP headers of the message.
 657  */
 658 PHP_METHOD(HttpMessage, setHeaders)
 659 {
 660         zval *new_headers, old_headers;
 661         getObject(http_message_object, obj);
 662
 663         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/", &new_headers)) {
 664                 return;
 665         }
 666
 667         zend_hash_clean(&obj->message->hdrs);
 668         INIT_ZARR(old_headers, &obj->message->hdrs);
 669         array_copy(new_headers, &old_headers);
 670 }
 671 /* }}} */
 672
 673 /* {{{ proto void HttpMessage::addHeaders(array headers[, bool append = false])
 674  *
 675  * Add headers. If append is true, headers with the same name will be separated, else overwritten.
 676  *
 677  * Expects an associative array as parameter containing the additional HTTP headers
 678  * to add to the messages existing headers.  If the optional bool parameter is true,
 679  * and a header with the same name of one to add exists already, this respective
 680  * header will be converted to an array containing both header values, otherwise
 681  * it will be overwritten with the new header value.
 682  */
 683 PHP_METHOD(HttpMessage, addHeaders)
 684 {
 685         zval old_headers, *new_headers;
 686         zend_bool append = 0;
 687         getObject(http_message_object, obj);
 688
 689         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|b", &new_headers, &append)) {
 690                 return;
 691         }
 692
 693         INIT_ZARR(old_headers, &obj->message->hdrs);
 694         if (append) {
 695                 array_append(new_headers, &old_headers);
 696         } else {
 697                 array_merge(new_headers, &old_headers);
 698         }
 699 }
 700 /* }}} */
 701
 702 /* {{{ proto int HttpMessage::getType()
 703  *
 704  * Get Message Type. (HTTP_MSG_NONE|HTTP_MSG_REQUEST|HTTP_MSG_RESPONSE)
 705  *
 706  * Returns the HttpMessage::TYPE.
 707  */
 708 PHP_METHOD(HttpMessage, getType)
 709 {
 710         NO_ARGS;
 711
 712         IF_RETVAL_USED {
 713                 getObject(http_message_object, obj);
 714                 RETURN_LONG(obj->message->type);
 715         }
 716 }
 717 /* }}} */
 718
 719 /* {{{ proto void HttpMessage::setType(int type)
 720  *
 721  * Set Message Type. (HTTP_MSG_NONE|HTTP_MSG_REQUEST|HTTP_MSG_RESPONSE)
 722  *
 723  * Exptects an int parameter, the HttpMessage::TYPE.
 724  */
 725 PHP_METHOD(HttpMessage, setType)
 726 {
 727         long type;
 728         getObject(http_message_object, obj);
 729
 730         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &type)) {
 731                 return;
 732         }
 733         http_message_set_type(obj->message, type);
 734 }
 735 /* }}} */
 736
 737 /* {{{ proto int HttpMessage::getResponseCode()
 738  *
 739  * Get the Response Code of the Message.
 740  *
 741  * Returns the HTTP response code if the message is of type
 742  * HttpMessage::TYPE_RESPONSE, else FALSE.
 743  */
 744 PHP_METHOD(HttpMessage, getResponseCode)
 745 {
 746         NO_ARGS;
 747
 748         IF_RETVAL_USED {
 749                 getObject(http_message_object, obj);
 750                 HTTP_CHECK_MESSAGE_TYPE_RESPONSE(obj->message, RETURN_FALSE);
 751                 RETURN_LONG(obj->message->http.info.response.code);
 752         }
 753 }
 754 /* }}} */
 755
 756 /* {{{ proto bool HttpMessage::setResponseCode(int code)
 757  *
 758  * Set the response code of an HTTP Response Message.
 759  *
 760  * Expects an int parameter with the HTTP response code.
 761  *
 762  * Returns TRUE on success, or FALSE if the message is not of type
 763  * HttpMessage::TYPE_RESPONSE or the response code is out of range (100-510).
 764  */
 765 PHP_METHOD(HttpMessage, setResponseCode)
 766 {
 767         long code;
 768         getObject(http_message_object, obj);
 769
 770         HTTP_CHECK_MESSAGE_TYPE_RESPONSE(obj->message, RETURN_FALSE);
 771
 772         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &code)) {
 773                 RETURN_FALSE;
 774         }
 775         if (code < 100 || code > 510) {
 776                 http_error_ex(HE_WARNING, HTTP_E_INVALID_PARAM, "Invalid response code (100-510): %ld", code);
 777                 RETURN_FALSE;
 778         }
 779
 780         obj->message->http.info.response.code = code;
 781         RETURN_TRUE;
 782 }
 783 /* }}} */
 784
 785 /* {{{ proto string HttpMessage::getRequestMethod()
 786  *
 787  * Get the Request Method of the Message.
 788  *
 789  * Returns the request method name on success, or FALSE if the message is
 790  * not of type HttpMessage::TYPE_REQUEST.
 791  */
 792 PHP_METHOD(HttpMessage, getRequestMethod)
 793 {
 794         NO_ARGS;
 795
 796         IF_RETVAL_USED {
 797                 getObject(http_message_object, obj);
 798                 HTTP_CHECK_MESSAGE_TYPE_REQUEST(obj->message, RETURN_FALSE);
 799                 RETURN_STRING(obj->message->http.info.request.method, 1);
 800         }
 801 }
 802 /* }}} */
 803
 804 /* {{{ proto bool HttpMessage::setRequestMethod(string method)
 805  *
 806  * Set the Request Method of the HTTP Message.
 807  *
 808  * Expects a string parameter containing the request method name.
 809  *
 810  * Returns TRUE on success, or FALSE if the message is not of type
 811  * HttpMessage::TYPE_REQUEST or an invalid request method was supplied.
 812  */
 813 PHP_METHOD(HttpMessage, setRequestMethod)
 814 {
 815         char *method;
 816         int method_len;
 817         getObject(http_message_object, obj);
 818
 819         HTTP_CHECK_MESSAGE_TYPE_REQUEST(obj->message, RETURN_FALSE);
 820
 821         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &method, &method_len)) {
 822                 RETURN_FALSE;
 823         }
 824         if (method_len < 1) {
 825                 http_error(HE_WARNING, HTTP_E_INVALID_PARAM, "Cannot set HttpMessage::requestMethod to an empty string");
 826                 RETURN_FALSE;
 827         }
 828         if (SUCCESS != http_check_method(method)) {
 829                 http_error_ex(HE_WARNING, HTTP_E_REQUEST_METHOD, "Unkown request method: %s", method);
 830                 RETURN_FALSE;
 831         }
 832
 833         STR_SET(obj->message->http.info.request.method, estrndup(method, method_len));
 834         RETURN_TRUE;
 835 }
 836 /* }}} */
 837
 838 /* {{{ proto string HttpMessage::getRequestUri()
 839  *
 840  * Get the Request URI of the Message.
 841  *
 842  * Returns the request uri as string on success, or FALSE if the message
 843  * is not of type HttpMessage::TYPE_REQUEST.
 844  */
 845 PHP_METHOD(HttpMessage, getRequestUri)
 846 {
 847         NO_ARGS;
 848
 849         IF_RETVAL_USED {
 850                 getObject(http_message_object, obj);
 851                 HTTP_CHECK_MESSAGE_TYPE_REQUEST(obj->message, RETURN_FALSE);
 852                 RETURN_STRING(obj->message->http.info.request.URI, 1);
 853         }
 854 }
 855 /* }}} */
 856
 857 /* {{{ proto bool HttpMessage::setRequestUri(string URI)
 858  *
 859  * Set the Request URI of the HTTP Message.
 860  *
 861  * Expects a string parameters containing the request uri.
 862  *
 863  * Returns TRUE on success, or FALSE if the message is not of type
 864  * HttpMessage::TYPE_REQUEST or supplied URI was empty.
 865  */
 866 PHP_METHOD(HttpMessage, setRequestUri)
 867 {
 868         char *URI;
 869         int URIlen;
 870         getObject(http_message_object, obj);
 871
 872         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &URI, &URIlen)) {
 873                 RETURN_FALSE;
 874         }
 875         HTTP_CHECK_MESSAGE_TYPE_REQUEST(obj->message, RETURN_FALSE);
 876         if (URIlen < 1) {
 877                 http_error(HE_WARNING, HTTP_E_INVALID_PARAM, "Cannot set HttpMessage::requestUri to an empty string");
 878                 RETURN_FALSE;
 879         }
 880
 881         STR_SET(obj->message->http.info.request.URI, estrndup(URI, URIlen));
 882         RETURN_TRUE;
 883 }
 884 /* }}} */
 885
 886 /* {{{ proto string HttpMessage::getHttpVersion()
 887  *
 888  * Get the HTTP Protocol Version of the Message.
 889  *
 890  * Returns the HTTP protocol version as string.
 891  */
 892 PHP_METHOD(HttpMessage, getHttpVersion)
 893 {
 894         NO_ARGS;
 895
 896         IF_RETVAL_USED {
 897                 char ver[4] = {0};
 898                 getObject(http_message_object, obj);
 899
 900                 sprintf(ver, "%1.1lf", obj->message->http.version);
 901                 RETURN_STRINGL(ver, 3, 1);
 902         }
 903 }
 904 /* }}} */
 905
 906 /* {{{ proto bool HttpMessage::setHttpVersion(string version)
 907  *
 908  * Set the HTTP Protocol version of the Message.
 909  *
 910  * Expects a string parameter containing the HTTP protocol version.
 911  *
 912  * Returns TRUE on success, or FALSE if supplied version is out of range (1.0/1.1).
 913  */
 914 PHP_METHOD(HttpMessage, setHttpVersion)
 915 {
 916         char v[4];
 917         zval *zv;
 918         getObject(http_message_object, obj);
 919
 920         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/", &zv)) {
 921                 return;
 922         }
 923
 924         convert_to_double(zv);
 925         sprintf(v, "%1.1lf", Z_DVAL_P(zv));
 926         if (strcmp(v, "1.0") && strcmp(v, "1.1")) {
 927                 http_error_ex(HE_WARNING, HTTP_E_INVALID_PARAM, "Invalid HTTP protocol version (1.0 or 1.1): %s", v);
 928                 RETURN_FALSE;
 929         }
 930
 931         obj->message->http.version = Z_DVAL_P(zv);
 932         RETURN_TRUE;
 933 }
 934 /* }}} */
 935
 936 /* {{{ proto HttpMessage HttpMessage::getParentMessage()
 937  *
 938  * Get parent Message.
 939  *
 940  * Returns the parent HttpMessage on success, or NULL if there's none.
 941  */
 942 PHP_METHOD(HttpMessage, getParentMessage)
 943 {
 944         NO_ARGS;
 945
 946         IF_RETVAL_USED {
 947                 getObject(http_message_object, obj);
 948
 949                 if (obj->message->parent) {
 950                         RETVAL_OBJVAL(obj->parent);
 951                 } else {
 952                         RETVAL_NULL();
 953                 }
 954         }
 955 }
 956 /* }}} */
 957
 958 /* {{{ proto bool HttpMessage::send()
 959  *
 960  * Send the Message according to its type as Response or Request.
 961  * This provides limited functionality compared to HttpRequest and HttpResponse.
 962  *
 963  * Returns TRUE on success, or FALSE on failure.
 964  */
 965 PHP_METHOD(HttpMessage, send)
 966 {
 967         getObject(http_message_object, obj);
 968
 969         NO_ARGS;
 970
 971         RETURN_SUCCESS(http_message_send(obj->message));
 972 }
 973 /* }}} */
 974
 975 /* {{{ proto string HttpMessage::toString([bool include_parent = false])
 976  *
 977  * Get the string representation of the Message.
 978  *
 979  * Accepts a bool parameter which specifies whether the returned string
 980  * should also contain any parent messages.
 981  *
 982  * Returns the full message as string.
 983  */
 984 PHP_METHOD(HttpMessage, toString)
 985 {
 986         IF_RETVAL_USED {
 987                 char *string;
 988                 size_t length;
 989                 zend_bool include_parent = 0;
 990                 getObject(http_message_object, obj);
 991
 992                 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &include_parent)) {
 993                         RETURN_FALSE;
 994                 }
 995
 996                 if (include_parent) {
 997                         http_message_serialize(obj->message, &string, &length);
 998                 } else {
 999                         http_message_tostring(obj->message, &string, &length);
1000                 }
1001                 RETURN_STRINGL(string, length, 0);
1002         }
1003 }
1004 /* }}} */
1005
1006 /* {{{ proto int HttpMessage::count()
1007  *
1008  * Implements Countable.
1009  *
1010  * Returns the number of parent messages + 1.
1011  */
1012 PHP_METHOD(HttpMessage, count)
1013 {
1014         NO_ARGS {
1015                 long i;
1016                 http_message *msg;
1017                 getObject(http_message_object, obj);
1018
1019                 for (i = 0, msg = obj->message; msg; msg = msg->parent, ++i);
1020                 RETURN_LONG(i);
1021         }
1022 }
1023 /* }}} */
1024
1025 /* {{{ proto string HttpMessage::serialize()
1026  *
1027  * Implements Serializable.
1028  *
1029  * Returns the serialized representation of the HttpMessage.
1030  */
1031 PHP_METHOD(HttpMessage, serialize)
1032 {
1033         NO_ARGS {
1034                 char *string;
1035                 size_t length;
1036                 getObject(http_message_object, obj);
1037
1038                 http_message_serialize(obj->message, &string, &length);
1039                 RETURN_STRINGL(string, length, 0);
1040         }
1041 }
1042 /* }}} */
1043
1044 /* {{{ proto void HttpMessage::unserialize(string serialized)
1045  *
1046  * Implements Serializable.
1047  *
1048  * Re-constructs the HttpMessage based upon the serialized string.
1049  */
1050 PHP_METHOD(HttpMessage, unserialize)
1051 {
1052         int length;
1053         char *serialized;
1054         getObject(http_message_object, obj);
1055
1056         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &serialized, &length)) {
1057                 http_message_dtor(obj->message);
1058                 if (!http_message_parse_ex(obj->message, serialized, (size_t) length)) {
1059                         http_error(HE_ERROR, HTTP_E_RUNTIME, "Could not unserialize HttpMessage");
1060                         http_message_init(obj->message);
1061                 }
1062         }
1063 }
1064 /* }}} */
1065
1066 #endif /* ZEND_ENGINE_2 */
1067
1068 /*
1069  * Local variables:
1070  * tab-width: 4
1071  * c-basic-offset: 4
1072  * End:
1073  * vim600: noet sw=4 ts=4 fdm=marker
1074  * vim<600: noet sw=4 ts=4
1075  */
1076