git.m6w6.name Git - m6w6/ext-http/blob - php_http_message.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-2011, Michael Wallner <mike@php.net>            |
  10     +--------------------------------------------------------------------+
  11 */
  12
  13 #include "php_http_api.h"
  14
  15 static zval *message_header_strval(zval **header TSRMLS_DC);
  16 static void message_headers(php_http_message_t *msg, php_http_buffer_t *str);
  17
  18 PHP_HTTP_API zend_bool php_http_message_info_callback(php_http_message_t **message, HashTable **headers, php_http_info_t *info TSRMLS_DC)
  19 {
  20         php_http_message_t *old = *message;
  21
  22         /* advance message */
  23         if (!old || old->type || zend_hash_num_elements(&old->hdrs) || PHP_HTTP_BUFFER_LEN(old)) {
  24                 (*message) = php_http_message_init(NULL, 0 TSRMLS_CC);
  25                 (*message)->parent = old;
  26                 if (headers) {
  27                         (*headers) = &((*message)->hdrs);
  28                 }
  29         }
  30
  31         if (info) {
  32                 php_http_message_set_info(*message, info);
  33         }
  34
  35         return old != *message;
  36 }
  37
  38 PHP_HTTP_API php_http_message_t *php_http_message_init(php_http_message_t *message, php_http_message_type_t type TSRMLS_DC)
  39 {
  40         if (!message) {
  41                 message = emalloc(sizeof(*message));
  42         }
  43         memset(message, 0, sizeof(*message));
  44         TSRMLS_SET_CTX(message->ts);
  45
  46         php_http_message_set_type(message, type);
  47         message->http.version.major = 1;
  48         message->http.version.minor = 1;
  49         zend_hash_init(&message->hdrs, 0, NULL, ZVAL_PTR_DTOR, 0);
  50         php_http_message_body_init(&message->body, NULL TSRMLS_CC);
  51
  52         return message;
  53 }
  54
  55 PHP_HTTP_API php_http_message_t *php_http_message_init_env(php_http_message_t *message, php_http_message_type_t type TSRMLS_DC)
  56 {
  57         int free_msg = !message;
  58         zval *sval, tval;
  59         php_http_message_body_t *mbody;
  60
  61         message = php_http_message_init(message, type TSRMLS_CC);
  62
  63         switch (type) {
  64                 case PHP_HTTP_REQUEST:
  65                         if ((sval = php_http_env_get_server_var(ZEND_STRL("SERVER_PROTOCOL"), 1 TSRMLS_CC)) && !strncmp(Z_STRVAL_P(sval), "HTTP/", lenof("HTTP/"))) {
  66                                 php_http_version_parse(&message->http.version, Z_STRVAL_P(sval) TSRMLS_CC);
  67                         }
  68                         if ((sval = php_http_env_get_server_var(ZEND_STRL("REQUEST_METHOD"), 1 TSRMLS_CC))) {
  69                                 message->http.info.request.method = estrdup(Z_STRVAL_P(sval));
  70                         }
  71                         if ((sval = php_http_env_get_server_var(ZEND_STRL("REQUEST_URI"), 1 TSRMLS_CC))) {
  72                                 message->http.info.request.url = estrdup(Z_STRVAL_P(sval));
  73                         }
  74
  75                         php_http_env_get_request_headers(&message->hdrs TSRMLS_CC);
  76
  77                         if ((mbody = php_http_env_get_request_body(TSRMLS_C))) {
  78                                 php_http_message_body_dtor(&message->body);
  79                                 php_http_message_body_copy(mbody, &message->body, 0);
  80                         }
  81                         break;
  82
  83                 case PHP_HTTP_RESPONSE:
  84                         if (!SG(sapi_headers).http_status_line || !php_http_info_parse((php_http_info_t *) &message->http, SG(sapi_headers).http_status_line TSRMLS_CC)) {
  85                                 if (!(message->http.info.response.code = SG(sapi_headers).http_response_code)) {
  86                                         message->http.info.response.code = 200;
  87                                 }
  88                                 message->http.info.response.status = estrdup(php_http_env_get_response_status_for_code(message->http.info.response.code));
  89                         }
  90
  91                         php_http_env_get_response_headers(&message->hdrs TSRMLS_CC);
  92 #if PHP_VERSION_ID >= 50400
  93                         if (php_output_get_level(TSRMLS_C)) {
  94                                 if (php_output_get_status(TSRMLS_C) & PHP_OUTPUT_SENT) {
  95                                         php_http_error(HE_WARNING, PHP_HTTP_E_RUNTIME, "Could not fetch response body, output has already been sent at %s:%d", php_output_get_start_filename(TSRMLS_C), php_output_get_start_lineno(TSRMLS_C));
  96                                         goto error;
  97                                 } else if (SUCCESS != php_output_get_contents(&tval TSRMLS_CC)) {
  98                                         php_http_error(HE_WARNING, PHP_HTTP_E_RUNTIME, "Could not fetch response body");
  99                                         goto error;
 100                                 } else {
 101                                         php_http_message_body_append(&message->body, Z_STRVAL(tval), Z_STRLEN(tval));
 102                                         zval_dtor(&tval);
 103                                 }
 104                         }
 105 #endif
 106                         break;
 107
 108                 default:
 109                 error:
 110                         if (free_msg) {
 111                                 php_http_message_free(&message);
 112                         } else {
 113                                 message = NULL;
 114                         }
 115                         break;
 116         }
 117
 118         return message;
 119 }
 120
 121 PHP_HTTP_API php_http_message_t *php_http_message_parse(php_http_message_t *msg, const char *str, size_t len TSRMLS_DC)
 122 {
 123         php_http_message_parser_t p;
 124         php_http_buffer_t buf;
 125         int free_msg;
 126
 127         php_http_buffer_from_string_ex(&buf, str, len);
 128         php_http_message_parser_init(&p TSRMLS_CC);
 129
 130         if ((free_msg = !msg)) {
 131                 msg = php_http_message_init(NULL, 0 TSRMLS_CC);
 132         }
 133
 134         if (FAILURE == php_http_message_parser_parse(&p, &buf, PHP_HTTP_MESSAGE_PARSER_CLEANUP, &msg)) {
 135                 if (free_msg) {
 136                         php_http_message_free(&msg);
 137                 }
 138                 msg = NULL;
 139         }
 140
 141         php_http_message_parser_dtor(&p);
 142         php_http_buffer_dtor(&buf);
 143
 144         return msg;
 145 }
 146
 147 PHP_HTTP_API zval *php_http_message_header(php_http_message_t *msg, char *key_str, size_t key_len, int join)
 148 {
 149         zval *ret = NULL, **header;
 150         char *key = php_http_pretty_key(estrndup(key_str, key_len), key_len, 1, 1);
 151
 152         if (SUCCESS == zend_symtable_find(&msg->hdrs, key, key_len + 1, (void *) &header)) {
 153                 if (join && Z_TYPE_PP(header) == IS_ARRAY) {
 154                         TSRMLS_FETCH_FROM_CTX(msg->ts);
 155
 156                         ret = message_header_strval(header TSRMLS_CC);
 157                 } else {
 158                         Z_ADDREF_PP(header);
 159                         ret = *header;
 160                 }
 161         }
 162
 163         efree(key);
 164
 165         return ret;
 166 }
 167
 168 PHP_HTTP_API zend_bool php_http_message_is_multipart(php_http_message_t *msg, char **boundary)
 169 {
 170         zval *ct = php_http_message_header(msg, ZEND_STRL("Content-Type"), 1);
 171         zend_bool is_multipart = 0;
 172         TSRMLS_FETCH_FROM_CTX(msg->ts);
 173
 174         if (ct) {
 175                 php_http_params_opts_t popts;
 176                 HashTable params;
 177
 178                 ZEND_INIT_SYMTABLE(&params);
 179                 php_http_params_opts_default_get(&popts);
 180                 popts.input.str = Z_STRVAL_P(ct);
 181                 popts.input.len = Z_STRLEN_P(ct);
 182
 183                 if (php_http_params_parse(&params, &popts TSRMLS_CC)) {
 184                         zval **cur, **arg;
 185                         char *ct_str;
 186
 187                         zend_hash_internal_pointer_reset(&params);
 188
 189                         if (SUCCESS == zend_hash_get_current_data(&params, (void *) &cur)
 190                         &&      Z_TYPE_PP(cur) == IS_ARRAY
 191                         &&      HASH_KEY_IS_STRING == zend_hash_get_current_key(&params, &ct_str, NULL, 0)
 192                         ) {
 193                                 if (php_http_match(ct_str, "multipart", PHP_HTTP_MATCH_WORD)) {
 194                                         is_multipart = 1;
 195
 196                                         /* get boundary */
 197                                         if (boundary
 198                                         &&      SUCCESS == zend_hash_find(Z_ARRVAL_PP(cur), ZEND_STRS("arguments"), (void *) &arg)
 199                                         &&      Z_TYPE_PP(arg) == IS_ARRAY
 200                                         ) {
 201                                                 zval **val;
 202                                                 HashPosition pos;
 203                                                 php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
 204
 205                                                 FOREACH_KEYVAL(pos, *arg, key, val) {
 206                                                         if (key.type == HASH_KEY_IS_STRING && !strcasecmp(key.str, "boundary")) {
 207                                                                 zval *bnd = php_http_ztyp(IS_STRING, *val);
 208
 209                                                                 if (Z_STRLEN_P(bnd)) {
 210                                                                         *boundary = estrndup(Z_STRVAL_P(bnd), Z_STRLEN_P(bnd));
 211                                                                 }
 212                                                                 zval_ptr_dtor(&bnd);
 213                                                         }
 214                                                 }
 215                                         }
 216                                 }
 217                         }
 218                 }
 219                 zend_hash_destroy(&params);
 220                 zval_ptr_dtor(&ct);
 221         }
 222
 223         return is_multipart;
 224 }
 225
 226 /* */
 227 PHP_HTTP_API void php_http_message_set_type(php_http_message_t *message, php_http_message_type_t type)
 228 {
 229         /* just act if different */
 230         if (type != message->type) {
 231
 232                 /* free request info */
 233                 switch (message->type) {
 234                         case PHP_HTTP_REQUEST:
 235                                 STR_FREE(message->http.info.request.method);
 236                                 STR_FREE(message->http.info.request.url);
 237                                 break;
 238
 239                         case PHP_HTTP_RESPONSE:
 240                                 STR_FREE(message->http.info.response.status);
 241                                 break;
 242
 243                         default:
 244                                 break;
 245                 }
 246
 247                 message->type = type;
 248                 memset(&message->http, 0, sizeof(message->http));
 249         }
 250 }
 251
 252 PHP_HTTP_API void php_http_message_set_info(php_http_message_t *message, php_http_info_t *info)
 253 {
 254         php_http_message_set_type(message, info->type);
 255         message->http.version = info->http.version;
 256         switch (message->type) {
 257                 case PHP_HTTP_REQUEST:
 258                         STR_SET(PHP_HTTP_INFO(message).request.url, PHP_HTTP_INFO(info).request.url ? estrdup(PHP_HTTP_INFO(info).request.url) : NULL);
 259                         STR_SET(PHP_HTTP_INFO(message).request.method, PHP_HTTP_INFO(info).request.method ? estrdup(PHP_HTTP_INFO(info).request.method) : NULL);
 260                         break;
 261
 262                 case PHP_HTTP_RESPONSE:
 263                         PHP_HTTP_INFO(message).response.code = PHP_HTTP_INFO(info).response.code;
 264                         STR_SET(PHP_HTTP_INFO(message).response.status, PHP_HTTP_INFO(info).response.status ? estrdup(PHP_HTTP_INFO(info).response.status) : NULL);
 265                         break;
 266
 267                 default:
 268                         break;
 269         }
 270 }
 271
 272 PHP_HTTP_API void php_http_message_update_headers(php_http_message_t *msg)
 273 {
 274         zval *h;
 275         size_t size;
 276         TSRMLS_FETCH_FROM_CTX(msg->ts);
 277
 278         if ((size = php_http_message_body_size(&msg->body))) {
 279                 MAKE_STD_ZVAL(h);
 280                 ZVAL_LONG(h, size);
 281                 zend_hash_update(&msg->hdrs, "Content-Length", sizeof("Content-Length"), &h, sizeof(zval *), NULL);
 282
 283                 if (msg->body.boundary) {
 284                         char *str;
 285                         size_t len;
 286
 287                         if (!(h = php_http_message_header(msg, ZEND_STRL("Content-Type"), 1))) {
 288                                 len = spprintf(&str, 0, "multipart/form-data; boundary=\"%s\"", msg->body.boundary);
 289                                 MAKE_STD_ZVAL(h);
 290                                 ZVAL_STRINGL(h, str, len, 0);
 291                                 zend_hash_update(&msg->hdrs, "Content-Type", sizeof("Content-Type"), &h, sizeof(zval *), NULL);
 292                         } else if (!php_http_match(Z_STRVAL_P(h), "boundary=", PHP_HTTP_MATCH_WORD)) {
 293                                 zval_dtor(h);
 294                                 Z_STRLEN_P(h) = spprintf(&Z_STRVAL_P(h), 0, "%s; boundary=\"%s\"", Z_STRVAL_P(h), msg->body.boundary);
 295                                 zend_hash_update(&msg->hdrs, "Content-Type", sizeof("Content-Type"), &h, sizeof(zval *), NULL);
 296                         } else {
 297                                 zval_ptr_dtor(&h);
 298                         }
 299                 }
 300         }
 301 }
 302
 303 static zval *message_header_strval(zval **header TSRMLS_DC)
 304 {
 305         zval *ret;
 306
 307         if (Z_TYPE_PP(header) == IS_BOOL) {
 308                 MAKE_STD_ZVAL(ret);
 309                 ZVAL_STRING(ret, Z_BVAL_PP(header) ? "true" : "false", 1);
 310         } else if (Z_TYPE_PP(header) == IS_ARRAY) {
 311                 zval **val;
 312                 HashPosition pos;
 313                 php_http_buffer_t str;
 314
 315                 php_http_buffer_init(&str);
 316                 MAKE_STD_ZVAL(ret);
 317                 FOREACH_VAL(pos, *header, val) {
 318                         zval *strval = message_header_strval(val TSRMLS_CC);
 319
 320                         php_http_buffer_appendf(&str, PHP_HTTP_BUFFER_LEN(&str) ? ", %s":"%s", Z_STRVAL_P(strval));
 321                         zval_ptr_dtor(&strval);
 322                 }
 323                 php_http_buffer_fix(&str);
 324                 ZVAL_STRINGL(ret, PHP_HTTP_BUFFER_VAL(&str), PHP_HTTP_BUFFER_LEN(&str), 0);
 325         } else  {
 326                 ret = php_http_zsep(1, IS_STRING, *header);
 327         }
 328
 329         return ret;
 330 }
 331
 332 static void message_headers(php_http_message_t *msg, php_http_buffer_t *str)
 333 {
 334         php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
 335         HashPosition pos1;
 336         zval **header;
 337         TSRMLS_FETCH_FROM_CTX(msg->ts);
 338
 339         switch (msg->type) {
 340                 case PHP_HTTP_REQUEST:
 341                         php_http_buffer_appendf(str, PHP_HTTP_INFO_REQUEST_FMT_ARGS(&msg->http, PHP_HTTP_CRLF));
 342                         break;
 343
 344                 case PHP_HTTP_RESPONSE:
 345                         php_http_buffer_appendf(str, PHP_HTTP_INFO_RESPONSE_FMT_ARGS(&msg->http, PHP_HTTP_CRLF));
 346                         break;
 347
 348                 default:
 349                         break;
 350         }
 351
 352         php_http_message_update_headers(msg);
 353
 354         FOREACH_HASH_KEYVAL(pos1, &msg->hdrs, key, header) {
 355                 if (key.type == HASH_KEY_IS_STRING) {
 356                         if (key.len == sizeof("Set-Cookie") && !strcasecmp(key.str, "Set-Cookie") && Z_TYPE_PP(header) == IS_ARRAY) {
 357                                 HashPosition pos2;
 358                                 zval **single_header;
 359
 360                                 FOREACH_VAL(pos2, *header, single_header) {
 361                                         if (Z_TYPE_PP(single_header) == IS_ARRAY) {
 362                                                 php_http_cookie_list_t *cookie = php_http_cookie_list_from_struct(NULL, *single_header TSRMLS_CC);
 363
 364                                                 if (cookie) {
 365                                                         char *buf;
 366                                                         size_t len;
 367
 368                                                         php_http_cookie_list_to_string(cookie, &buf, &len);
 369                                                         php_http_buffer_appendf(str, "Set-Cookie: %s" PHP_HTTP_CRLF, buf);
 370                                                         php_http_cookie_list_free(&cookie);
 371                                                         efree(buf);
 372                                                 }
 373                                         } else {
 374                                                 zval *strval = message_header_strval(single_header TSRMLS_CC);
 375
 376                                                 php_http_buffer_appendf(str, "Set-Cookie: %s" PHP_HTTP_CRLF, Z_STRVAL_P(strval));
 377                                                 zval_ptr_dtor(&strval);
 378                                         }
 379                                 }
 380                         } else {
 381                                 zval *strval = message_header_strval(header TSRMLS_CC);
 382
 383                                 php_http_buffer_appendf(str, "%s: %s" PHP_HTTP_CRLF, key.str, Z_STRVAL_P(strval));
 384                                 zval_ptr_dtor(&strval);
 385                         }
 386                 }
 387         }
 388 }
 389
 390 PHP_HTTP_API void php_http_message_to_callback(php_http_message_t *msg, php_http_pass_callback_t cb, void *cb_arg)
 391 {
 392         php_http_buffer_t str;
 393
 394         php_http_buffer_init_ex(&str, 0x1000, 0);
 395         message_headers(msg, &str);
 396         cb(cb_arg, PHP_HTTP_BUFFER_VAL(&str), PHP_HTTP_BUFFER_LEN(&str));
 397         php_http_buffer_dtor(&str);
 398
 399         if (php_http_message_body_size(&msg->body)) {
 400                 cb(cb_arg, ZEND_STRL(PHP_HTTP_CRLF));
 401                 php_http_message_body_to_callback(&msg->body, cb, cb_arg, 0, 0);
 402         }
 403 }
 404
 405 PHP_HTTP_API void php_http_message_to_string(php_http_message_t *msg, char **string, size_t *length)
 406 {
 407         php_http_buffer_t str;
 408         char *data;
 409
 410         php_http_buffer_init_ex(&str, 0x1000, 0);
 411         message_headers(msg, &str);
 412         if (php_http_message_body_size(&msg->body)) {
 413                 php_http_buffer_appends(&str, PHP_HTTP_CRLF);
 414                 php_http_message_body_to_callback(&msg->body, (php_http_pass_callback_t) php_http_buffer_append, &str, 0, 0);
 415         }
 416
 417         data = php_http_buffer_data(&str, string, length);
 418         if (!string) {
 419                 efree(data);
 420         }
 421
 422         php_http_buffer_dtor(&str);
 423 }
 424
 425 PHP_HTTP_API void php_http_message_serialize(php_http_message_t *message, char **string, size_t *length)
 426 {
 427         char *buf;
 428         php_http_buffer_t str;
 429         php_http_message_t *msg;
 430
 431         php_http_buffer_init(&str);
 432
 433         msg = message = php_http_message_reverse(message);
 434         do {
 435                 php_http_message_to_callback(message, (php_http_pass_callback_t) php_http_buffer_append, &str);
 436                 php_http_buffer_appends(&str, PHP_HTTP_CRLF);
 437         } while ((message = message->parent));
 438         php_http_message_reverse(msg);
 439
 440         buf = php_http_buffer_data(&str, string, length);
 441         if (!string) {
 442                 efree(buf);
 443         }
 444
 445         php_http_buffer_dtor(&str);
 446 }
 447
 448 PHP_HTTP_API php_http_message_t *php_http_message_reverse(php_http_message_t *msg)
 449 {
 450         int i, c = 0;
 451
 452         php_http_message_count(c, msg);
 453
 454         if (c > 1) {
 455                 php_http_message_t *tmp = msg, **arr;
 456
 457                 arr = ecalloc(c, sizeof(**arr));
 458                 for (i = 0; i < c; ++i) {
 459                         arr[i] = tmp;
 460                         tmp = tmp->parent;
 461                 }
 462                 arr[0]->parent = NULL;
 463                 for (i = 0; i < c-1; ++i) {
 464                         arr[i+1]->parent = arr[i];
 465                 }
 466
 467                 msg = arr[c-1];
 468                 efree(arr);
 469         }
 470
 471         return msg;
 472 }
 473
 474 PHP_HTTP_API php_http_message_t *php_http_message_zip(php_http_message_t *one, php_http_message_t *two)
 475 {
 476         php_http_message_t *dst = php_http_message_copy(one, NULL), *src = php_http_message_copy(two, NULL), *tmp_dst, *tmp_src, *ret = dst;
 477
 478         while(dst && src) {
 479                 tmp_dst = dst->parent;
 480                 tmp_src = src->parent;
 481                 dst->parent = src;
 482                 if (tmp_dst) {
 483                         src->parent = tmp_dst;
 484                 }
 485                 src = tmp_src;
 486                 dst = tmp_dst;
 487         }
 488
 489         return ret;
 490 }
 491
 492 PHP_HTTP_API php_http_message_t *php_http_message_copy_ex(php_http_message_t *from, php_http_message_t *to, zend_bool parents)
 493 {
 494         php_http_message_t *temp, *copy = NULL;
 495         php_http_info_t info;
 496         TSRMLS_FETCH_FROM_CTX(from->ts);
 497
 498         if (from) {
 499                 info.type = from->type;
 500                 info.http = from->http;
 501
 502                 copy = temp = php_http_message_init(to, 0 TSRMLS_CC);
 503                 php_http_message_set_info(temp, &info);
 504                 zend_hash_copy(&temp->hdrs, &from->hdrs, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
 505                 php_http_message_body_copy(&from->body, &temp->body, 1);
 506
 507                 if (parents) while (from->parent) {
 508                         info.type = from->parent->type;
 509                         info.http = from->parent->http;
 510
 511                         temp->parent = php_http_message_init(NULL, 0 TSRMLS_CC);
 512                         php_http_message_set_info(temp->parent, &info);
 513                         zend_hash_copy(&temp->parent->hdrs, &from->parent->hdrs, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
 514                         php_http_message_body_copy(&from->parent->body, &temp->parent->body, 1);
 515
 516                         temp = temp->parent;
 517                         from = from->parent;
 518                 }
 519         }
 520
 521         return copy;
 522 }
 523
 524 PHP_HTTP_API php_http_message_t *php_http_message_copy(php_http_message_t *from, php_http_message_t *to)
 525 {
 526         return php_http_message_copy_ex(from, to, 1);
 527 }
 528
 529 PHP_HTTP_API void php_http_message_dtor(php_http_message_t *message)
 530 {
 531         if (message) {
 532                 zend_hash_destroy(&message->hdrs);
 533                 php_http_message_body_dtor(&message->body);
 534
 535                 switch (message->type) {
 536                         case PHP_HTTP_REQUEST:
 537                                 STR_SET(message->http.info.request.method, NULL);
 538                                 STR_SET(message->http.info.request.url, NULL);
 539                                 break;
 540
 541                         case PHP_HTTP_RESPONSE:
 542                                 STR_SET(message->http.info.response.status, NULL);
 543                                 break;
 544
 545                         default:
 546                                 break;
 547                 }
 548         }
 549 }
 550
 551 PHP_HTTP_API void php_http_message_free(php_http_message_t **message)
 552 {
 553         if (*message) {
 554                 if ((*message)->parent) {
 555                         php_http_message_free(&(*message)->parent);
 556                 }
 557                 php_http_message_dtor(*message);
 558                 efree(*message);
 559                 *message = NULL;
 560         }
 561 }
 562
 563 #define PHP_HTTP_BEGIN_ARGS(method, req_args)   PHP_HTTP_BEGIN_ARGS_EX(HttpMessage, method, 0, req_args)
 564 #define PHP_HTTP_EMPTY_ARGS(method)                             PHP_HTTP_EMPTY_ARGS_EX(HttpMessage, method, 0)
 565 #define PHP_HTTP_MESSAGE_ME(method, visibility) PHP_ME(HttpMessage, method, PHP_HTTP_ARGS(HttpMessage, method), visibility)
 566
 567 PHP_HTTP_BEGIN_ARGS(__construct, 0)
 568         PHP_HTTP_ARG_VAL(message, 0)
 569 PHP_HTTP_END_ARGS;
 570
 571 PHP_HTTP_EMPTY_ARGS(getBody);
 572 PHP_HTTP_BEGIN_ARGS(setBody, 1)
 573         PHP_HTTP_ARG_VAL(body, 0)
 574 PHP_HTTP_END_ARGS;
 575
 576 PHP_HTTP_BEGIN_ARGS(addBody, 1)
 577         PHP_HTTP_ARG_VAL(body, 0)
 578 PHP_HTTP_END_ARGS;
 579
 580 PHP_HTTP_BEGIN_ARGS(getHeader, 1)
 581         PHP_HTTP_ARG_VAL(header, 0)
 582 PHP_HTTP_END_ARGS;
 583
 584 PHP_HTTP_BEGIN_ARGS(setHeader, 1)
 585         PHP_HTTP_ARG_VAL(header, 0)
 586         PHP_HTTP_ARG_VAL(value, 0)
 587 PHP_HTTP_END_ARGS;
 588
 589 PHP_HTTP_BEGIN_ARGS(addHeader, 2)
 590         PHP_HTTP_ARG_VAL(header, 0)
 591         PHP_HTTP_ARG_VAL(value, 0)
 592 PHP_HTTP_END_ARGS;
 593
 594 PHP_HTTP_EMPTY_ARGS(getHeaders);
 595 PHP_HTTP_BEGIN_ARGS(setHeaders, 1)
 596         PHP_HTTP_ARG_VAL(headers, 0)
 597 PHP_HTTP_END_ARGS;
 598
 599 PHP_HTTP_BEGIN_ARGS(addHeaders, 1)
 600         PHP_HTTP_ARG_VAL(headers, 0)
 601         PHP_HTTP_ARG_VAL(append, 0)
 602 PHP_HTTP_END_ARGS;
 603
 604 PHP_HTTP_EMPTY_ARGS(getType);
 605 PHP_HTTP_BEGIN_ARGS(setType, 1)
 606         PHP_HTTP_ARG_VAL(type, 0)
 607 PHP_HTTP_END_ARGS;
 608
 609 PHP_HTTP_EMPTY_ARGS(getInfo);
 610 PHP_HTTP_BEGIN_ARGS(setInfo, 1)
 611         PHP_HTTP_ARG_VAL(http_info, 0)
 612 PHP_HTTP_END_ARGS;
 613
 614 PHP_HTTP_EMPTY_ARGS(getResponseCode);
 615 PHP_HTTP_BEGIN_ARGS(setResponseCode, 1)
 616         PHP_HTTP_ARG_VAL(response_code, 0)
 617 PHP_HTTP_END_ARGS;
 618
 619 PHP_HTTP_EMPTY_ARGS(getResponseStatus);
 620 PHP_HTTP_BEGIN_ARGS(setResponseStatus, 1)
 621         PHP_HTTP_ARG_VAL(response_status, 0)
 622 PHP_HTTP_END_ARGS;
 623
 624 PHP_HTTP_EMPTY_ARGS(getRequestMethod);
 625 PHP_HTTP_BEGIN_ARGS(setRequestMethod, 1)
 626         PHP_HTTP_ARG_VAL(request_method, 0)
 627 PHP_HTTP_END_ARGS;
 628
 629 PHP_HTTP_EMPTY_ARGS(getRequestUrl);
 630 PHP_HTTP_BEGIN_ARGS(setRequestUrl, 1)
 631         PHP_HTTP_ARG_VAL(url, 0)
 632 PHP_HTTP_END_ARGS;
 633
 634 PHP_HTTP_EMPTY_ARGS(getHttpVersion);
 635 PHP_HTTP_BEGIN_ARGS(setHttpVersion, 1)
 636         PHP_HTTP_ARG_VAL(http_version, 0)
 637 PHP_HTTP_END_ARGS;
 638
 639 PHP_HTTP_EMPTY_ARGS(getParentMessage);
 640 PHP_HTTP_EMPTY_ARGS(__toString);
 641 PHP_HTTP_BEGIN_ARGS(toString, 0)
 642         PHP_HTTP_ARG_VAL(include_parent, 0)
 643 PHP_HTTP_END_ARGS;
 644 PHP_HTTP_BEGIN_ARGS(toCallback, 1)
 645         PHP_HTTP_ARG_VAL(callback, 0)
 646 PHP_HTTP_END_ARGS;
 647 PHP_HTTP_BEGIN_ARGS(toStream, 1)
 648         PHP_HTTP_ARG_VAL(stream, 0)
 649 PHP_HTTP_END_ARGS;
 650
 651 PHP_HTTP_EMPTY_ARGS(count);
 652
 653 PHP_HTTP_EMPTY_ARGS(serialize);
 654 PHP_HTTP_BEGIN_ARGS(unserialize, 1)
 655         PHP_HTTP_ARG_VAL(serialized, 0)
 656 PHP_HTTP_END_ARGS;
 657
 658 PHP_HTTP_EMPTY_ARGS(rewind);
 659 PHP_HTTP_EMPTY_ARGS(valid);
 660 PHP_HTTP_EMPTY_ARGS(key);
 661 PHP_HTTP_EMPTY_ARGS(current);
 662 PHP_HTTP_EMPTY_ARGS(next);
 663
 664 PHP_HTTP_EMPTY_ARGS(detach);
 665 PHP_HTTP_BEGIN_ARGS(prepend, 1)
 666         PHP_HTTP_ARG_OBJ(http\\Message, message, 0)
 667 PHP_HTTP_END_ARGS;
 668 PHP_HTTP_EMPTY_ARGS(reverse);
 669
 670 PHP_HTTP_BEGIN_ARGS(isMultipart, 0)
 671         PHP_HTTP_ARG_VAL(boundary, 1)
 672 PHP_HTTP_END_ARGS;
 673 PHP_HTTP_EMPTY_ARGS(splitMultipartBody);
 674
 675 static zval *php_http_message_object_read_prop(zval *object, zval *member, int type PHP_HTTP_ZEND_LITERAL_DC TSRMLS_DC);
 676 static void php_http_message_object_write_prop(zval *object, zval *member, zval *value PHP_HTTP_ZEND_LITERAL_DC TSRMLS_DC);
 677 static zval **php_http_message_object_get_prop_ptr(zval *object, zval *member PHP_HTTP_ZEND_LITERAL_DC TSRMLS_DC);
 678 static HashTable *php_http_message_object_get_props(zval *object TSRMLS_DC);
 679
 680 static zend_class_entry *php_http_message_class_entry;
 681
 682 zend_class_entry *php_http_message_get_class_entry(void)
 683 {
 684         return php_http_message_class_entry;
 685 }
 686
 687 static zend_function_entry php_http_message_method_entry[] = {
 688         PHP_HTTP_MESSAGE_ME(__construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
 689         PHP_HTTP_MESSAGE_ME(getBody, ZEND_ACC_PUBLIC)
 690         PHP_HTTP_MESSAGE_ME(setBody, ZEND_ACC_PUBLIC)
 691         PHP_HTTP_MESSAGE_ME(addBody, ZEND_ACC_PUBLIC)
 692         PHP_HTTP_MESSAGE_ME(getHeader, ZEND_ACC_PUBLIC)
 693         PHP_HTTP_MESSAGE_ME(setHeader, ZEND_ACC_PUBLIC)
 694         PHP_HTTP_MESSAGE_ME(addHeader, ZEND_ACC_PUBLIC)
 695         PHP_HTTP_MESSAGE_ME(getHeaders, ZEND_ACC_PUBLIC)
 696         PHP_HTTP_MESSAGE_ME(setHeaders, ZEND_ACC_PUBLIC)
 697         PHP_HTTP_MESSAGE_ME(addHeaders, ZEND_ACC_PUBLIC)
 698         PHP_HTTP_MESSAGE_ME(getType, ZEND_ACC_PUBLIC)
 699         PHP_HTTP_MESSAGE_ME(setType, ZEND_ACC_PUBLIC)
 700         PHP_HTTP_MESSAGE_ME(getInfo, ZEND_ACC_PUBLIC)
 701         PHP_HTTP_MESSAGE_ME(setInfo, ZEND_ACC_PUBLIC)
 702         PHP_HTTP_MESSAGE_ME(getResponseCode, ZEND_ACC_PUBLIC)
 703         PHP_HTTP_MESSAGE_ME(setResponseCode, ZEND_ACC_PUBLIC)
 704         PHP_HTTP_MESSAGE_ME(getResponseStatus, ZEND_ACC_PUBLIC)
 705         PHP_HTTP_MESSAGE_ME(setResponseStatus, ZEND_ACC_PUBLIC)
 706         PHP_HTTP_MESSAGE_ME(getRequestMethod, ZEND_ACC_PUBLIC)
 707         PHP_HTTP_MESSAGE_ME(setRequestMethod, ZEND_ACC_PUBLIC)
 708         PHP_HTTP_MESSAGE_ME(getRequestUrl, ZEND_ACC_PUBLIC)
 709         PHP_HTTP_MESSAGE_ME(setRequestUrl, ZEND_ACC_PUBLIC)
 710         PHP_HTTP_MESSAGE_ME(getHttpVersion, ZEND_ACC_PUBLIC)
 711         PHP_HTTP_MESSAGE_ME(setHttpVersion, ZEND_ACC_PUBLIC)
 712         PHP_HTTP_MESSAGE_ME(getParentMessage, ZEND_ACC_PUBLIC)
 713         PHP_HTTP_MESSAGE_ME(toString, ZEND_ACC_PUBLIC)
 714         PHP_HTTP_MESSAGE_ME(toCallback, ZEND_ACC_PUBLIC)
 715         PHP_HTTP_MESSAGE_ME(toStream, ZEND_ACC_PUBLIC)
 716
 717         /* implements Countable */
 718         PHP_HTTP_MESSAGE_ME(count, ZEND_ACC_PUBLIC)
 719
 720         /* implements Serializable */
 721         PHP_HTTP_MESSAGE_ME(serialize, ZEND_ACC_PUBLIC)
 722         PHP_HTTP_MESSAGE_ME(unserialize, ZEND_ACC_PUBLIC)
 723
 724         /* implements Iterator */
 725         PHP_HTTP_MESSAGE_ME(rewind, ZEND_ACC_PUBLIC)
 726         PHP_HTTP_MESSAGE_ME(valid, ZEND_ACC_PUBLIC)
 727         PHP_HTTP_MESSAGE_ME(current, ZEND_ACC_PUBLIC)
 728         PHP_HTTP_MESSAGE_ME(key, ZEND_ACC_PUBLIC)
 729         PHP_HTTP_MESSAGE_ME(next, ZEND_ACC_PUBLIC)
 730
 731         ZEND_MALIAS(HttpMessage, __toString, toString, PHP_HTTP_ARGS(HttpMessage, __toString), ZEND_ACC_PUBLIC)
 732
 733         PHP_HTTP_MESSAGE_ME(detach, ZEND_ACC_PUBLIC)
 734         PHP_HTTP_MESSAGE_ME(prepend, ZEND_ACC_PUBLIC)
 735         PHP_HTTP_MESSAGE_ME(reverse, ZEND_ACC_PUBLIC)
 736
 737         PHP_HTTP_MESSAGE_ME(isMultipart, ZEND_ACC_PUBLIC)
 738         PHP_HTTP_MESSAGE_ME(splitMultipartBody, ZEND_ACC_PUBLIC)
 739
 740         EMPTY_FUNCTION_ENTRY
 741 };
 742 static zend_object_handlers php_http_message_object_handlers;
 743 static HashTable php_http_message_object_prophandlers;
 744
 745 typedef void (*php_http_message_object_prophandler_func_t)(php_http_message_object_t *o, zval *v TSRMLS_DC);
 746
 747 typedef struct php_http_message_object_prophandler {
 748         php_http_message_object_prophandler_func_t read;
 749         php_http_message_object_prophandler_func_t write;
 750 } php_http_message_object_prophandler_t;
 751
 752 static STATUS php_http_message_object_add_prophandler(const char *prop_str, size_t prop_len, php_http_message_object_prophandler_func_t read, php_http_message_object_prophandler_func_t write) {
 753         php_http_message_object_prophandler_t h = { read, write };
 754         return zend_hash_add(&php_http_message_object_prophandlers, prop_str, prop_len + 1, (void *) &h, sizeof(h), NULL);
 755 }
 756 /*
 757 static int php_http_message_object_has_prophandler(const char *prop_str, size_t prop_len) {
 758         return zend_hash_exists(&php_http_message_object_prophandlers, prop_str, prop_len + 1);
 759 }
 760 */
 761 static STATUS php_http_message_object_get_prophandler(const char *prop_str, size_t prop_len, php_http_message_object_prophandler_t **handler) {
 762         return zend_hash_find(&php_http_message_object_prophandlers, prop_str, prop_len + 1, (void *) handler);
 763 }
 764 static void php_http_message_object_prophandler_get_type(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
 765         RETVAL_LONG(obj->message->type);
 766 }
 767 static void php_http_message_object_prophandler_set_type(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
 768         zval *cpy = php_http_ztyp(IS_LONG, value);
 769         php_http_message_set_type(obj->message, Z_LVAL_P(cpy));
 770         zval_ptr_dtor(&cpy);
 771 }
 772 static void php_http_message_object_prophandler_get_request_method(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
 773         if (PHP_HTTP_MESSAGE_TYPE(REQUEST, obj->message) && obj->message->http.info.request.method) {
 774                 RETVAL_STRING(obj->message->http.info.request.method, 1);
 775         } else {
 776                 RETVAL_NULL();
 777         }
 778 }
 779 static void php_http_message_object_prophandler_set_request_method(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
 780         if (PHP_HTTP_MESSAGE_TYPE(REQUEST, obj->message)) {
 781                 zval *cpy = php_http_ztyp(IS_STRING, value);
 782                 STR_SET(obj->message->http.info.request.method, estrndup(Z_STRVAL_P(cpy), Z_STRLEN_P(cpy)));
 783                 zval_ptr_dtor(&cpy);
 784         }
 785 }
 786 static void php_http_message_object_prophandler_get_request_url(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
 787         if (PHP_HTTP_MESSAGE_TYPE(REQUEST, obj->message) && obj->message->http.info.request.url) {
 788                 RETVAL_STRING(obj->message->http.info.request.url, 1);
 789         } else {
 790                 RETVAL_NULL();
 791         }
 792 }
 793 static void php_http_message_object_prophandler_set_request_url(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
 794         if (PHP_HTTP_MESSAGE_TYPE(REQUEST, obj->message)) {
 795                 zval *cpy = php_http_ztyp(IS_STRING, value);
 796                 STR_SET(obj->message->http.info.request.url, estrndup(Z_STRVAL_P(cpy), Z_STRLEN_P(cpy)));
 797                 zval_ptr_dtor(&cpy);
 798         }
 799 }
 800 static void php_http_message_object_prophandler_get_response_status(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
 801         if (PHP_HTTP_MESSAGE_TYPE(RESPONSE, obj->message) && obj->message->http.info.response.status) {
 802                 RETVAL_STRING(obj->message->http.info.response.status, 1);
 803         } else {
 804                 RETVAL_NULL();
 805         }
 806 }
 807 static void php_http_message_object_prophandler_set_response_status(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
 808         if (PHP_HTTP_MESSAGE_TYPE(RESPONSE, obj->message)) {
 809                 zval *cpy = php_http_ztyp(IS_STRING, value);
 810                 STR_SET(obj->message->http.info.response.status, estrndup(Z_STRVAL_P(cpy), Z_STRLEN_P(cpy)));
 811                 zval_ptr_dtor(&cpy);
 812         }
 813 }
 814 static void php_http_message_object_prophandler_get_response_code(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
 815         if (PHP_HTTP_MESSAGE_TYPE(RESPONSE, obj->message)) {
 816                 RETVAL_LONG(obj->message->http.info.response.code);
 817         } else {
 818                 RETVAL_NULL();
 819         }
 820 }
 821 static void php_http_message_object_prophandler_set_response_code(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
 822         if (PHP_HTTP_MESSAGE_TYPE(RESPONSE, obj->message)) {
 823                 zval *cpy = php_http_ztyp(IS_LONG, value);
 824                 obj->message->http.info.response.code = Z_LVAL_P(cpy);
 825                 STR_SET(obj->message->http.info.response.status, estrdup(php_http_env_get_response_status_for_code(obj->message->http.info.response.code)));
 826                 zval_ptr_dtor(&cpy);
 827         }
 828 }
 829 static void php_http_message_object_prophandler_get_http_version(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
 830         char *version_str;
 831         size_t version_len;
 832
 833         php_http_version_to_string(&obj->message->http.version, &version_str, &version_len, NULL, NULL TSRMLS_CC);
 834         RETVAL_STRINGL(version_str, version_len, 0);
 835 }
 836 static void php_http_message_object_prophandler_set_http_version(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
 837         zval *cpy = php_http_ztyp(IS_STRING, value);
 838         php_http_version_parse(&obj->message->http.version, Z_STRVAL_P(cpy) TSRMLS_CC);
 839         zval_ptr_dtor(&cpy);
 840 }
 841 static void php_http_message_object_prophandler_get_headers(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
 842         array_init(return_value);
 843         zend_hash_copy(Z_ARRVAL_P(return_value), &obj->message->hdrs, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
 844 }
 845 static void php_http_message_object_prophandler_set_headers(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
 846         zval *cpy = php_http_ztyp(IS_ARRAY, value);
 847
 848         zend_hash_clean(&obj->message->hdrs);
 849         zend_hash_copy(&obj->message->hdrs, Z_ARRVAL_P(cpy), (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
 850         zval_ptr_dtor(&cpy);
 851 }
 852 static void php_http_message_object_prophandler_get_body(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
 853         if (obj->body.handle) {
 854                 RETVAL_OBJVAL(obj->body, 1);
 855         } else {
 856                 RETVAL_NULL();
 857         }
 858 }
 859 static void php_http_message_object_prophandler_set_body(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
 860         php_http_message_object_set_body(obj, value TSRMLS_CC);
 861 }
 862 static void php_http_message_object_prophandler_get_parent_message(php_http_message_object_t *obj, zval *return_value TSRMLS_DC) {
 863         if (obj->message->parent) {
 864                 RETVAL_OBJVAL(obj->parent, 1);
 865         } else {
 866                 RETVAL_NULL();
 867         }
 868 }
 869 static void php_http_message_object_prophandler_set_parent_message(php_http_message_object_t *obj, zval *value TSRMLS_DC) {
 870         if (Z_TYPE_P(value) == IS_OBJECT && instanceof_function(Z_OBJCE_P(value), php_http_message_class_entry TSRMLS_CC)) {
 871                 if (obj->message->parent) {
 872                         zend_objects_store_del_ref_by_handle(obj->parent.handle TSRMLS_CC);
 873                 }
 874                 Z_OBJ_ADDREF_P(value);
 875                 obj->parent = Z_OBJVAL_P(value);
 876         }
 877 }
 878
 879 PHP_MINIT_FUNCTION(http_message)
 880 {
 881         PHP_HTTP_REGISTER_CLASS(http, Message, http_message, php_http_object_get_class_entry(), 0);
 882         php_http_message_class_entry->create_object = php_http_message_object_new;
 883         memcpy(&php_http_message_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 884         php_http_message_object_handlers.clone_obj = php_http_message_object_clone;
 885         php_http_message_object_handlers.read_property = php_http_message_object_read_prop;
 886         php_http_message_object_handlers.write_property = php_http_message_object_write_prop;
 887         php_http_message_object_handlers.get_properties = php_http_message_object_get_props;
 888         php_http_message_object_handlers.get_property_ptr_ptr = php_http_message_object_get_prop_ptr;
 889
 890         zend_class_implements(php_http_message_class_entry TSRMLS_CC, 3, spl_ce_Countable, zend_ce_serializable, zend_ce_iterator);
 891
 892         zend_hash_init(&php_http_message_object_prophandlers, 9, NULL, NULL, 1);
 893         zend_declare_property_long(php_http_message_class_entry, ZEND_STRL("type"), PHP_HTTP_NONE, ZEND_ACC_PROTECTED TSRMLS_CC);
 894         php_http_message_object_add_prophandler(ZEND_STRL("type"), php_http_message_object_prophandler_get_type, php_http_message_object_prophandler_set_type);
 895         zend_declare_property_string(php_http_message_class_entry, ZEND_STRL("body"), "", ZEND_ACC_PROTECTED TSRMLS_CC);
 896         php_http_message_object_add_prophandler(ZEND_STRL("body"), php_http_message_object_prophandler_get_body, php_http_message_object_prophandler_set_body);
 897         zend_declare_property_string(php_http_message_class_entry, ZEND_STRL("requestMethod"), "", ZEND_ACC_PROTECTED TSRMLS_CC);
 898         php_http_message_object_add_prophandler(ZEND_STRL("requestMethod"), php_http_message_object_prophandler_get_request_method, php_http_message_object_prophandler_set_request_method);
 899         zend_declare_property_string(php_http_message_class_entry, ZEND_STRL("requestUrl"), "", ZEND_ACC_PROTECTED TSRMLS_CC);
 900         php_http_message_object_add_prophandler(ZEND_STRL("requestUrl"), php_http_message_object_prophandler_get_request_url, php_http_message_object_prophandler_set_request_url);
 901         zend_declare_property_string(php_http_message_class_entry, ZEND_STRL("responseStatus"), "", ZEND_ACC_PROTECTED TSRMLS_CC);
 902         php_http_message_object_add_prophandler(ZEND_STRL("responseStatus"), php_http_message_object_prophandler_get_response_status, php_http_message_object_prophandler_set_response_status);
 903         zend_declare_property_long(php_http_message_class_entry, ZEND_STRL("responseCode"), 0, ZEND_ACC_PROTECTED TSRMLS_CC);
 904         php_http_message_object_add_prophandler(ZEND_STRL("responseCode"), php_http_message_object_prophandler_get_response_code, php_http_message_object_prophandler_set_response_code);
 905         zend_declare_property_null(php_http_message_class_entry, ZEND_STRL("httpVersion"), ZEND_ACC_PROTECTED TSRMLS_CC);
 906         php_http_message_object_add_prophandler(ZEND_STRL("httpVersion"), php_http_message_object_prophandler_get_http_version, php_http_message_object_prophandler_set_http_version);
 907         zend_declare_property_null(php_http_message_class_entry, ZEND_STRL("headers"), ZEND_ACC_PROTECTED TSRMLS_CC);
 908         php_http_message_object_add_prophandler(ZEND_STRL("headers"), php_http_message_object_prophandler_get_headers, php_http_message_object_prophandler_set_headers);
 909         zend_declare_property_null(php_http_message_class_entry, ZEND_STRL("parentMessage"), ZEND_ACC_PROTECTED TSRMLS_CC);
 910         php_http_message_object_add_prophandler(ZEND_STRL("parentMessage"), php_http_message_object_prophandler_get_parent_message, php_http_message_object_prophandler_set_parent_message);
 911
 912         zend_declare_class_constant_long(php_http_message_class_entry, ZEND_STRL("TYPE_NONE"), PHP_HTTP_NONE TSRMLS_CC);
 913         zend_declare_class_constant_long(php_http_message_class_entry, ZEND_STRL("TYPE_REQUEST"), PHP_HTTP_REQUEST TSRMLS_CC);
 914         zend_declare_class_constant_long(php_http_message_class_entry, ZEND_STRL("TYPE_RESPONSE"), PHP_HTTP_RESPONSE TSRMLS_CC);
 915
 916         return SUCCESS;
 917 }
 918
 919 PHP_MSHUTDOWN_FUNCTION(http_message)
 920 {
 921         zend_hash_destroy(&php_http_message_object_prophandlers);
 922
 923         return SUCCESS;
 924 }
 925
 926 void php_http_message_object_reverse(zval *this_ptr, zval *return_value TSRMLS_DC)
 927 {
 928         int i = 0;
 929         php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 930
 931         /* count */
 932         php_http_message_count(i, obj->message);
 933
 934         if (i > 1) {
 935                 zend_object_value *ovalues = NULL;
 936                 php_http_message_object_t **objects = NULL;
 937                 int last = i - 1;
 938
 939                 objects = ecalloc(i, sizeof(**objects));
 940                 ovalues = ecalloc(i, sizeof(*ovalues));
 941
 942                 /* we are the first message */
 943                 objects[0] = obj;
 944                 ovalues[0] = getThis()->value.obj;
 945
 946                 /* fetch parents */
 947                 for (i = 1; obj->parent.handle; ++i) {
 948                         ovalues[i] = obj->parent;
 949                         objects[i] = obj = zend_object_store_get_object_by_handle(obj->parent.handle TSRMLS_CC);
 950                 }
 951
 952                 /* reorder parents */
 953                 for (last = --i; i; --i) {
 954                         objects[i]->message->parent = objects[i-1]->message;
 955                         objects[i]->parent = ovalues[i-1];
 956                 }
 957
 958                 objects[0]->message->parent = NULL;
 959                 objects[0]->parent.handle = 0;
 960                 objects[0]->parent.handlers = NULL;
 961
 962                 /* add ref, because we previously have not been a parent message */
 963                 Z_OBJ_ADDREF_P(getThis());
 964                 RETVAL_OBJVAL(ovalues[last], 1);
 965
 966                 efree(objects);
 967                 efree(ovalues);
 968         } else {
 969                 RETURN_ZVAL(getThis(), 1, 0);
 970         }
 971 }
 972
 973 void php_http_message_object_prepend(zval *this_ptr, zval *prepend, zend_bool top TSRMLS_DC)
 974 {
 975         zval m;
 976         php_http_message_t *save_parent_msg = NULL;
 977         zend_object_value save_parent_obj = {0, NULL};
 978         php_http_message_object_t *obj = zend_object_store_get_object(this_ptr TSRMLS_CC);
 979         php_http_message_object_t *prepend_obj = zend_object_store_get_object(prepend TSRMLS_CC);
 980
 981         INIT_PZVAL(&m);
 982         m.type = IS_OBJECT;
 983
 984         if (!top) {
 985                 save_parent_obj = obj->parent;
 986                 save_parent_msg = obj->message->parent;
 987         } else {
 988                 /* iterate to the most parent object */
 989                 while (obj->parent.handle) {
 990                         m.value.obj = obj->parent;
 991                         obj = zend_object_store_get_object(&m TSRMLS_CC);
 992                 }
 993         }
 994
 995         /* prepend */
 996         obj->parent = prepend->value.obj;
 997         obj->message->parent = prepend_obj->message;
 998
 999         /* add ref */
1000         zend_objects_store_add_ref(prepend TSRMLS_CC);
1001         while (prepend_obj->parent.handle) {
1002                 m.value.obj = prepend_obj->parent;
1003                 zend_objects_store_add_ref(&m TSRMLS_CC);
1004                 prepend_obj = zend_object_store_get_object(&m TSRMLS_CC);
1005         }
1006
1007         if (!top) {
1008                 prepend_obj->parent = save_parent_obj;
1009                 prepend_obj->message->parent = save_parent_msg;
1010         }
1011 }
1012
1013 STATUS php_http_message_object_set_body(php_http_message_object_t *msg_obj, zval *zbody TSRMLS_DC)
1014 {
1015         zval *tmp = NULL;
1016         php_stream *s;
1017         zend_object_value ov;
1018         php_http_message_body_t *body;
1019         php_http_message_body_object_t *body_obj;
1020
1021         switch (Z_TYPE_P(zbody)) {
1022                 case IS_RESOURCE:
1023                         php_stream_from_zval_no_verify(s, &zbody);
1024                         if (!s) {
1025                                 php_http_error(HE_THROW, PHP_HTTP_E_CLIENT, "not a valid stream resource");
1026                                 return FAILURE;
1027                         }
1028
1029                         is_resource:
1030
1031                         body = php_http_message_body_init(NULL, s TSRMLS_CC);
1032                         if (SUCCESS != php_http_new(&ov, php_http_message_body_get_class_entry(), (php_http_new_t) php_http_message_body_object_new_ex, NULL, body, NULL TSRMLS_CC)) {
1033                                 php_http_message_body_free(&body);
1034                                 return FAILURE;
1035                         }
1036                         MAKE_STD_ZVAL(tmp);
1037                         ZVAL_OBJVAL(tmp, ov, 0);
1038                         zbody = tmp;
1039                         break;
1040
1041                 case IS_OBJECT:
1042                         if (instanceof_function(Z_OBJCE_P(zbody), php_http_message_body_get_class_entry() TSRMLS_CC)) {
1043                                 Z_OBJ_ADDREF_P(zbody);
1044                                 break;
1045                         }
1046                         /* no break */
1047
1048                 default:
1049                         tmp = php_http_ztyp(IS_STRING, zbody);
1050                         s = php_stream_temp_new();
1051                         php_stream_write(s, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
1052                         zval_ptr_dtor(&tmp);
1053                         tmp = NULL;
1054                         goto is_resource;
1055
1056         }
1057
1058         body_obj = zend_object_store_get_object(zbody TSRMLS_CC);
1059
1060         if (msg_obj->body.handle) {
1061                 zend_objects_store_del_ref_by_handle(msg_obj->body.handle TSRMLS_CC);
1062                 php_http_message_body_dtor(&msg_obj->message->body);
1063         }
1064
1065         php_http_message_body_copy(body_obj->body, &msg_obj->message->body, 0);
1066         msg_obj->body = Z_OBJVAL_P(zbody);
1067
1068         if (tmp) {
1069                 zval_ptr_dtor(&tmp);
1070         }
1071
1072         return SUCCESS;
1073 }
1074
1075 zend_object_value php_http_message_object_new(zend_class_entry *ce TSRMLS_DC)
1076 {
1077         return php_http_message_object_new_ex(ce, NULL, NULL TSRMLS_CC);
1078 }
1079
1080 zend_object_value php_http_message_object_new_ex(zend_class_entry *ce, php_http_message_t *msg, php_http_message_object_t **ptr TSRMLS_DC)
1081 {
1082         zend_object_value ov;
1083         php_http_message_object_t *o;
1084
1085         o = ecalloc(1, sizeof(php_http_message_object_t));
1086         zend_object_std_init((zend_object *) o, ce TSRMLS_CC);
1087         object_properties_init((zend_object *) o, ce);
1088
1089         if (ptr) {
1090                 *ptr = o;
1091         }
1092
1093         if (msg) {
1094                 o->message = msg;
1095                 if (msg->parent) {
1096                         o->parent = php_http_message_object_new_ex(ce, msg->parent, NULL TSRMLS_CC);
1097                 }
1098                 o->body = php_http_message_body_object_new_ex(php_http_message_body_get_class_entry(), php_http_message_body_copy(&msg->body, NULL, 0), NULL TSRMLS_CC);
1099         }
1100
1101         ov.handle = zend_objects_store_put((zend_object *) o, NULL, php_http_message_object_free, NULL TSRMLS_CC);
1102         ov.handlers = &php_http_message_object_handlers;
1103
1104         return ov;
1105 }
1106
1107 zend_object_value php_http_message_object_clone(zval *this_ptr TSRMLS_DC)
1108 {
1109         zend_object_value new_ov;
1110         php_http_message_object_t *new_obj = NULL;
1111         php_http_message_object_t *old_obj = zend_object_store_get_object(this_ptr TSRMLS_CC);
1112
1113         new_ov = php_http_message_object_new_ex(old_obj->zo.ce, php_http_message_copy(old_obj->message, NULL), &new_obj TSRMLS_CC);
1114         zend_objects_clone_members(&new_obj->zo, new_ov, &old_obj->zo, Z_OBJ_HANDLE_P(this_ptr) TSRMLS_CC);
1115
1116         return new_ov;
1117 }
1118
1119 void php_http_message_object_free(void *object TSRMLS_DC)
1120 {
1121         php_http_message_object_t *o = (php_http_message_object_t *) object;
1122
1123         if (o->iterator) {
1124                 zval_ptr_dtor(&o->iterator);
1125                 o->iterator = NULL;
1126         }
1127         if (o->message) {
1128                 /* do NOT free recursivly */
1129                 php_http_message_dtor(o->message);
1130                 efree(o->message);
1131                 o->message = NULL;
1132         }
1133         if (o->parent.handle) {
1134                 zend_objects_store_del_ref_by_handle(o->parent.handle TSRMLS_CC);
1135         }
1136         if (o->body.handle) {
1137                 zend_objects_store_del_ref_by_handle(o->body.handle TSRMLS_CC);
1138         }
1139         zend_object_std_dtor((zend_object *) o TSRMLS_CC);
1140         efree(o);
1141 }
1142
1143
1144 static zval **php_http_message_object_get_prop_ptr(zval *object, zval *member PHP_HTTP_ZEND_LITERAL_DC TSRMLS_DC)
1145 {
1146         php_http_message_object_prophandler_t *handler;
1147         zval *copy = php_http_ztyp(IS_STRING, member);
1148
1149         if (SUCCESS == php_http_message_object_get_prophandler(Z_STRVAL_P(copy), Z_STRLEN_P(copy), &handler)) {
1150                 zval_ptr_dtor(&copy);
1151                 return &php_http_property_proxy_init(NULL, object, member, NULL TSRMLS_CC)->myself;
1152         }
1153         zval_ptr_dtor(&copy);
1154
1155         return zend_get_std_object_handlers()->get_property_ptr_ptr(object, member PHP_HTTP_ZEND_LITERAL_CC TSRMLS_CC);
1156 }
1157
1158 static zval *php_http_message_object_read_prop(zval *object, zval *member, int type PHP_HTTP_ZEND_LITERAL_DC TSRMLS_DC)
1159 {
1160         php_http_message_object_t *obj = zend_object_store_get_object(object TSRMLS_CC);
1161         php_http_message_object_prophandler_t *handler;
1162         zval *return_value, *copy = php_http_ztyp(IS_STRING, member);
1163
1164         if (SUCCESS == php_http_message_object_get_prophandler(Z_STRVAL_P(copy), Z_STRLEN_P(copy), &handler)) {
1165                 if (type == BP_VAR_R) {
1166                         ALLOC_ZVAL(return_value);
1167                         Z_SET_REFCOUNT_P(return_value, 0);
1168                         Z_UNSET_ISREF_P(return_value);
1169
1170                         handler->read(obj, return_value TSRMLS_CC);
1171                 } else {
1172                         zend_error(E_ERROR, "Cannot access HttpMessage properties by reference or array key/index");
1173                         return_value = NULL;
1174                 }
1175         } else {
1176                 return_value = zend_get_std_object_handlers()->read_property(object, member, type PHP_HTTP_ZEND_LITERAL_CC TSRMLS_CC);
1177         }
1178
1179         zval_ptr_dtor(&copy);
1180
1181         return return_value;
1182 }
1183
1184 static void php_http_message_object_write_prop(zval *object, zval *member, zval *value PHP_HTTP_ZEND_LITERAL_DC TSRMLS_DC)
1185 {
1186         php_http_message_object_t *obj = zend_object_store_get_object(object TSRMLS_CC);
1187         php_http_message_object_prophandler_t *handler;
1188         zval *copy = php_http_ztyp(IS_STRING, member);
1189
1190         if (SUCCESS == php_http_message_object_get_prophandler(Z_STRVAL_P(copy), Z_STRLEN_P(copy), &handler)) {
1191                 handler->write(obj, value TSRMLS_CC);
1192         } else {
1193                 zend_get_std_object_handlers()->write_property(object, member, value PHP_HTTP_ZEND_LITERAL_CC TSRMLS_CC);
1194         }
1195
1196         zval_ptr_dtor(&copy);
1197 }
1198
1199
1200 static HashTable *php_http_message_object_get_props(zval *object TSRMLS_DC)
1201 {
1202         zval *headers;
1203         php_http_message_object_t *obj = zend_object_store_get_object(object TSRMLS_CC);
1204         php_http_message_t *msg = obj->message;
1205         HashTable *props = zend_get_std_object_handlers()->get_properties(object TSRMLS_CC);
1206         zval array, *parent, *body;
1207         char *version;
1208
1209         INIT_PZVAL_ARRAY(&array, props);
1210
1211 #define ASSOC_PROP(array, ptype, name, val) \
1212         { \
1213                 char *m_prop_name; \
1214                 int m_prop_len; \
1215                 zend_mangle_property_name(&m_prop_name, &m_prop_len, "*", 1, name, lenof(name), 0); \
1216                 add_assoc_ ##ptype## _ex(&array, m_prop_name, sizeof(name)+3, val); \
1217                 efree(m_prop_name); \
1218         }
1219 #define ASSOC_STRING(array, name, val) ASSOC_STRINGL(array, name, val, strlen(val))
1220 #define ASSOC_STRINGL(array, name, val, len) ASSOC_STRINGL_EX(array, name, val, len, 1)
1221 #define ASSOC_STRINGL_EX(array, name, val, len, cpy) \
1222         { \
1223                 char *m_prop_name; \
1224                 int m_prop_len; \
1225                 zend_mangle_property_name(&m_prop_name, &m_prop_len, "*", 1, name, lenof(name), 0); \
1226                 add_assoc_stringl_ex(&array, m_prop_name, sizeof(name)+3, val, len, cpy); \
1227                 efree(m_prop_name); \
1228         }
1229
1230         ASSOC_PROP(array, long, "type", msg->type);
1231         ASSOC_STRINGL_EX(array, "httpVersion", version, spprintf(&version, 0, "%u.%u", msg->http.version.major, msg->http.version.minor), 0);
1232
1233         switch (msg->type) {
1234                 case PHP_HTTP_REQUEST:
1235                         ASSOC_PROP(array, long, "responseCode", 0);
1236                         ASSOC_STRINGL(array, "responseStatus", "", 0);
1237                         ASSOC_STRING(array, "requestMethod", STR_PTR(msg->http.info.request.method));
1238                         ASSOC_STRING(array, "requestUrl", STR_PTR(msg->http.info.request.url));
1239                         break;
1240
1241                 case PHP_HTTP_RESPONSE:
1242                         ASSOC_PROP(array, long, "responseCode", msg->http.info.response.code);
1243                         ASSOC_STRING(array, "responseStatus", STR_PTR(msg->http.info.response.status));
1244                         ASSOC_STRINGL(array, "requestMethod", "", 0);
1245                         ASSOC_STRINGL(array, "requestUrl", "", 0);
1246                         break;
1247
1248                 case PHP_HTTP_NONE:
1249                 default:
1250                         ASSOC_PROP(array, long, "responseCode", 0);
1251                         ASSOC_STRINGL(array, "responseStatus", "", 0);
1252                         ASSOC_STRINGL(array, "requestMethod", "", 0);
1253                         ASSOC_STRINGL(array, "requestUrl", "", 0);
1254                         break;
1255         }
1256
1257         MAKE_STD_ZVAL(headers);
1258         array_init(headers);
1259         zend_hash_copy(Z_ARRVAL_P(headers), &msg->hdrs, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
1260         ASSOC_PROP(array, zval, "headers", headers);
1261
1262         MAKE_STD_ZVAL(body);
1263         if (!obj->body.handle) {
1264                 php_http_new(&obj->body, php_http_message_body_get_class_entry(), (php_http_new_t) php_http_message_body_object_new_ex, NULL, (void *) php_http_message_body_copy(&obj->message->body, NULL, 0), NULL TSRMLS_CC);
1265         }
1266         ZVAL_OBJVAL(body, obj->body, 1);
1267         ASSOC_PROP(array, zval, "body", body);
1268
1269         MAKE_STD_ZVAL(parent);
1270         if (msg->parent) {
1271                 ZVAL_OBJVAL(parent, obj->parent, 1);
1272         } else {
1273                 ZVAL_NULL(parent);
1274         }
1275         ASSOC_PROP(array, zval, "parentMessage", parent);
1276
1277         return props;
1278 }
1279
1280 /* PHP */
1281
1282 PHP_METHOD(HttpMessage, __construct)
1283 {
1284         zval *zmessage = NULL;
1285         php_http_message_t *msg = NULL;
1286         php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1287
1288         with_error_handling(EH_THROW, php_http_exception_get_class_entry()) {
1289                 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z!", &zmessage) && zmessage) {
1290                         if (Z_TYPE_P(zmessage) == IS_RESOURCE) {
1291                                 php_stream *s;
1292                                 php_http_message_parser_t p;
1293
1294                                 php_stream_from_zval(s, &zmessage);
1295                                 if (s && php_http_message_parser_init(&p TSRMLS_CC)) {
1296                                         php_http_message_parser_parse_stream(&p, s, &msg);
1297                                         php_http_message_parser_dtor(&p);
1298                                 }
1299                         } else {
1300                                 zmessage = php_http_ztyp(IS_STRING, zmessage);
1301                                 msg = php_http_message_parse(NULL, Z_STRVAL_P(zmessage), Z_STRLEN_P(zmessage) TSRMLS_CC);
1302                                 zval_ptr_dtor(&zmessage);
1303                         }
1304
1305                         if (msg) {
1306                                 php_http_message_dtor(obj->message);
1307                                 obj->message = msg;
1308                                 if (obj->message->parent) {
1309                                         obj->parent = php_http_message_object_new_ex(Z_OBJCE_P(getThis()), obj->message->parent, NULL TSRMLS_CC);
1310                                 }
1311                         } else {
1312                                 php_http_error(HE_THROW, PHP_HTTP_E_MESSAGE, "could not parse message: %.*s", 25, Z_STRVAL_P(zmessage));
1313                         }
1314                 }
1315                 if (!obj->message) {
1316                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1317                 }
1318         } end_error_handling();
1319
1320 }
1321
1322 PHP_METHOD(HttpMessage, getBody)
1323 {
1324         with_error_handling(EH_THROW, php_http_exception_get_class_entry()) {
1325                 if (SUCCESS == zend_parse_parameters_none()) {
1326                         php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1327
1328                         if (!obj->message) {
1329                                 obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1330                         }
1331
1332                         if (obj->body.handle || SUCCESS == php_http_new(&obj->body, php_http_message_body_get_class_entry(), (php_http_new_t) php_http_message_body_object_new_ex, NULL, (void *) php_http_message_body_copy(&obj->message->body, NULL, 0), NULL TSRMLS_CC)) {
1333                                 RETVAL_OBJVAL(obj->body, 1);
1334                         }
1335                 }
1336         } end_error_handling();
1337 }
1338
1339 PHP_METHOD(HttpMessage, setBody)
1340 {
1341         zval *zbody;
1342
1343         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &zbody, php_http_message_body_get_class_entry())) {
1344                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1345                 php_http_message_body_object_t *body_obj = zend_object_store_get_object(zbody TSRMLS_CC);
1346
1347                 if (!obj->message) {
1348                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1349                 }
1350                 php_http_message_object_prophandler_set_body(obj, zbody TSRMLS_CC);
1351         }
1352         RETVAL_ZVAL(getThis(), 1, 0);
1353 }
1354
1355 PHP_METHOD(HttpMessage, addBody)
1356 {
1357         zval *new_body;
1358
1359         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &new_body, php_http_message_body_get_class_entry())) {
1360                 php_http_message_body_object_t *old_obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1361                 php_http_message_body_object_t *new_obj = zend_object_store_get_object(new_body TSRMLS_CC);
1362
1363                 php_http_message_body_to_callback(old_obj->body, (php_http_pass_callback_t) php_http_message_body_append, new_obj->body, 0, 0);
1364         }
1365         RETVAL_ZVAL(getThis(), 1, 0);
1366 }
1367
1368
1369 PHP_METHOD(HttpMessage, getHeader)
1370 {
1371         char *header_str;
1372         int header_len;
1373
1374         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &header_str, &header_len)) {
1375                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1376                 zval *header;
1377
1378                 if (!obj->message) {
1379                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1380                 }
1381
1382                 if ((header = php_http_message_header(obj->message, header_str, header_len, 0))) {
1383                         RETURN_ZVAL(header, 1, 1);
1384                 }
1385         }
1386         RETURN_FALSE;
1387 }
1388
1389 PHP_METHOD(HttpMessage, getHeaders)
1390 {
1391         if (SUCCESS == zend_parse_parameters_none()) {
1392                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1393
1394                 if (!obj->message) {
1395                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1396                 }
1397
1398                 array_init(return_value);
1399                 array_copy(&obj->message->hdrs, Z_ARRVAL_P(return_value));
1400         }
1401 }
1402
1403 PHP_METHOD(HttpMessage, setHeader)
1404 {
1405         zval *zvalue = NULL;
1406         char *name_str;
1407         int name_len;
1408
1409         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z!", &name_str, &name_len, &zvalue)) {
1410                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1411                 char *name = php_http_pretty_key(estrndup(name_str, name_len), name_len, 1, 1);
1412
1413                 if (!obj->message) {
1414                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1415                 }
1416
1417                 if (!zvalue) {
1418                         zend_symtable_del(&obj->message->hdrs, name, name_len + 1);
1419                 } else {
1420                         Z_ADDREF_P(zvalue);
1421                         zend_symtable_update(&obj->message->hdrs, name, name_len + 1, &zvalue, sizeof(void *), NULL);
1422                 }
1423                 efree(name);
1424         }
1425         RETVAL_ZVAL(getThis(), 1, 0);
1426 }
1427
1428 PHP_METHOD(HttpMessage, setHeaders)
1429 {
1430         zval *new_headers = NULL;
1431
1432         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/!", &new_headers)) {
1433                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1434
1435                 if (!obj->message) {
1436                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1437                 }
1438
1439                 zend_hash_clean(&obj->message->hdrs);
1440                 if (new_headers) {
1441                         array_join(Z_ARRVAL_P(new_headers), &obj->message->hdrs, 0, ARRAY_JOIN_PRETTIFY|ARRAY_JOIN_STRONLY);
1442                 }
1443         }
1444         RETVAL_ZVAL(getThis(), 1, 0);
1445 }
1446
1447 PHP_METHOD(HttpMessage, addHeader)
1448 {
1449         zval *zvalue;
1450         char *name_str;
1451         int name_len;
1452
1453         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &name_str, &name_len, &zvalue)) {
1454                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1455                 char *name = php_http_pretty_key(estrndup(name_str, name_len), name_len, 1, 1);
1456                 zval *header;
1457
1458                 if (!obj->message) {
1459                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1460                 }
1461
1462                 Z_ADDREF_P(zvalue);
1463                 if ((header = php_http_message_header(obj->message, name, name_len, 0))) {
1464                         convert_to_array(header);
1465                         zend_hash_next_index_insert(Z_ARRVAL_P(header), &zvalue, sizeof(void *), NULL);
1466                 } else {
1467                         zend_symtable_update(&obj->message->hdrs, name, name_len + 1, &zvalue, sizeof(void *), NULL);
1468                 }
1469                 efree(name);
1470         }
1471         RETVAL_ZVAL(getThis(), 1, 0);
1472 }
1473
1474 PHP_METHOD(HttpMessage, addHeaders)
1475 {
1476         zval *new_headers;
1477         zend_bool append = 0;
1478
1479         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|b", &new_headers, &append)) {
1480                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1481
1482                 if (!obj->message) {
1483                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1484                 }
1485
1486                 array_join(Z_ARRVAL_P(new_headers), &obj->message->hdrs, append, ARRAY_JOIN_STRONLY|ARRAY_JOIN_PRETTIFY);
1487         }
1488         RETVAL_ZVAL(getThis(), 1, 0);
1489 }
1490
1491 PHP_METHOD(HttpMessage, getType)
1492 {
1493         if (SUCCESS == zend_parse_parameters_none()) {
1494                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1495
1496                 if (!obj->message) {
1497                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1498                 }
1499
1500                 RETURN_LONG(obj->message->type);
1501         }
1502 }
1503
1504 PHP_METHOD(HttpMessage, setType)
1505 {
1506         long type;
1507
1508         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &type)) {
1509                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1510
1511                 if (!obj->message) {
1512                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1513                 }
1514
1515                 php_http_message_set_type(obj->message, type);
1516         }
1517         RETVAL_ZVAL(getThis(), 1, 0);
1518 }
1519
1520 PHP_METHOD(HttpMessage, getInfo)
1521 {
1522         if (SUCCESS == zend_parse_parameters_none()) {
1523                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1524
1525                 if (!obj->message) {
1526                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1527                 }
1528
1529                 switch (obj->message->type) {
1530                         case PHP_HTTP_REQUEST:
1531                                 Z_STRLEN_P(return_value) = spprintf(&Z_STRVAL_P(return_value), 0, PHP_HTTP_INFO_REQUEST_FMT_ARGS(&obj->message->http, ""));
1532                                 break;
1533                         case PHP_HTTP_RESPONSE:
1534                                 Z_STRLEN_P(return_value) = spprintf(&Z_STRVAL_P(return_value), 0, PHP_HTTP_INFO_RESPONSE_FMT_ARGS(&obj->message->http, ""));
1535                                 break;
1536                         default:
1537                                 RETURN_NULL();
1538                                 break;
1539                 }
1540                 Z_TYPE_P(return_value) = IS_STRING;
1541                 return;
1542         }
1543         RETURN_FALSE;
1544 }
1545
1546 PHP_METHOD(HttpMessage, setInfo)
1547 {
1548         char *str;
1549         int len;
1550         php_http_info_t inf;
1551
1552         if (    SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &len)
1553         &&              php_http_info_parse(&inf, str TSRMLS_CC)) {
1554                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1555
1556                 if (!obj->message) {
1557                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1558                 }
1559
1560                 php_http_message_set_info(obj->message, &inf);
1561                 php_http_info_dtor(&inf);
1562         }
1563         RETVAL_ZVAL(getThis(), 1, 0);
1564 }
1565
1566 PHP_METHOD(HttpMessage, getHttpVersion)
1567 {
1568         if (SUCCESS == zend_parse_parameters_none()) {
1569                 char *str;
1570                 size_t len;
1571                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1572
1573                 if (!obj->message) {
1574                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1575                 }
1576
1577                 php_http_version_to_string(&obj->message->http.version, &str, &len, NULL, NULL TSRMLS_CC);
1578                 RETURN_STRINGL(str, len, 0);
1579         }
1580
1581         RETURN_FALSE;
1582 }
1583
1584 PHP_METHOD(HttpMessage, setHttpVersion)
1585 {
1586         char *v_str;
1587         int v_len;
1588
1589         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &v_str, &v_len)) {
1590                 php_http_version_t version;
1591                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1592
1593                 if (!obj->message) {
1594                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1595                 }
1596
1597                 if (php_http_version_parse(&version, v_str TSRMLS_CC)) {
1598                         obj->message->http.version = version;
1599                 }
1600         }
1601         RETVAL_ZVAL(getThis(), 1, 0);
1602 }
1603
1604 PHP_METHOD(HttpMessage, getResponseCode)
1605 {
1606         if (SUCCESS == zend_parse_parameters_none()) {
1607                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1608
1609                 if (!obj->message) {
1610                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1611                 }
1612
1613                 PHP_HTTP_MESSAGE_TYPE_CHECK(RESPONSE, obj->message, RETURN_FALSE);
1614                 RETURN_LONG(obj->message->http.info.response.code);
1615         }
1616         RETURN_FALSE;
1617 }
1618
1619 PHP_METHOD(HttpMessage, setResponseCode)
1620 {
1621         long code;
1622         zend_bool strict = 1;
1623
1624         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|b", &code, &strict)) {
1625                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1626
1627                 if (!obj->message) {
1628                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1629                 }
1630
1631                 PHP_HTTP_MESSAGE_TYPE_CHECK(RESPONSE, obj->message, RETURN_FALSE);
1632                 if (strict && (code < 100 || code > 599)) {
1633                         php_http_error(HE_WARNING, PHP_HTTP_E_INVALID_PARAM, "Invalid response code (100-599): %ld", code);
1634                         RETURN_FALSE;
1635                 }
1636
1637                 obj->message->http.info.response.code = code;
1638                 STR_SET(obj->message->http.info.response.status, estrdup(php_http_env_get_response_status_for_code(code)));
1639         }
1640         RETVAL_ZVAL(getThis(), 1, 0);
1641 }
1642
1643 PHP_METHOD(HttpMessage, getResponseStatus)
1644 {
1645         if (SUCCESS == zend_parse_parameters_none()) {
1646                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1647
1648                 if (!obj->message) {
1649                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1650                 }
1651
1652                 PHP_HTTP_MESSAGE_TYPE_CHECK(RESPONSE, obj->message, RETURN_FALSE);
1653                 if (obj->message->http.info.response.status) {
1654                         RETURN_STRING(obj->message->http.info.response.status, 1);
1655                 } else {
1656                         RETURN_EMPTY_STRING();
1657                 }
1658         }
1659
1660         RETURN_FALSE;
1661 }
1662
1663 PHP_METHOD(HttpMessage, setResponseStatus)
1664 {
1665         char *status;
1666         int status_len;
1667
1668         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &status, &status_len)) {
1669                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1670
1671                 if (!obj->message) {
1672                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1673                 }
1674
1675                 PHP_HTTP_MESSAGE_TYPE_CHECK(RESPONSE, obj->message, RETURN_FALSE);
1676                 STR_SET(obj->message->http.info.response.status, estrndup(status, status_len));
1677         }
1678         RETVAL_ZVAL(getThis(), 1, 0);
1679 }
1680
1681 PHP_METHOD(HttpMessage, getRequestMethod)
1682 {
1683         if (SUCCESS == zend_parse_parameters_none()) {
1684                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1685
1686                 if (!obj->message) {
1687                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1688                 }
1689
1690                 PHP_HTTP_MESSAGE_TYPE_CHECK(REQUEST, obj->message, RETURN_FALSE);
1691                 if (obj->message->http.info.request.method) {
1692                         RETURN_STRING(obj->message->http.info.request.method, 1);
1693                 } else {
1694                         RETURN_EMPTY_STRING();
1695                 }
1696         }
1697
1698         RETURN_FALSE;
1699 }
1700
1701 PHP_METHOD(HttpMessage, setRequestMethod)
1702 {
1703         char *method;
1704         int method_len;
1705
1706         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &method, &method_len)) {
1707                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1708
1709                 if (!obj->message) {
1710                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1711                 }
1712
1713                 PHP_HTTP_MESSAGE_TYPE_CHECK(REQUEST, obj->message, RETURN_FALSE);
1714                 if (method_len < 1) {
1715                         php_http_error(HE_WARNING, PHP_HTTP_E_INVALID_PARAM, "Cannot set HttpMessage::requestMethod to an empty string");
1716                         RETURN_FALSE;
1717                 }
1718
1719                 STR_SET(obj->message->http.info.request.method, estrndup(method, method_len));
1720         }
1721         RETVAL_ZVAL(getThis(), 1, 0);
1722 }
1723
1724 PHP_METHOD(HttpMessage, getRequestUrl)
1725 {
1726         if (SUCCESS == zend_parse_parameters_none()) {
1727                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1728
1729                 if (!obj->message) {
1730                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1731                 }
1732
1733                 PHP_HTTP_MESSAGE_TYPE_CHECK(REQUEST, obj->message, RETURN_FALSE);
1734                 if (obj->message->http.info.request.url) {
1735                         RETURN_STRING(obj->message->http.info.request.url, 1);
1736                 } else {
1737                         RETURN_EMPTY_STRING();
1738                 }
1739         }
1740
1741         RETURN_FALSE;
1742 }
1743
1744 PHP_METHOD(HttpMessage, setRequestUrl)
1745 {
1746         char *url_str;
1747         int url_len;
1748
1749         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &url_str, &url_len)) {
1750                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1751
1752                 if (!obj->message) {
1753                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1754                 }
1755
1756                 PHP_HTTP_MESSAGE_TYPE_CHECK(REQUEST, obj->message, RETURN_FALSE);
1757                 if (url_len < 1) {
1758                         php_http_error(HE_WARNING, PHP_HTTP_E_INVALID_PARAM, "Cannot set HttpMessage::requestUrl to an empty string");
1759                         RETURN_FALSE;
1760                 }
1761                 STR_SET(obj->message->http.info.request.url, estrndup(url_str, url_len));
1762         }
1763         RETVAL_ZVAL(getThis(), 1, 0);
1764 }
1765
1766
1767 PHP_METHOD(HttpMessage, getParentMessage)
1768 {
1769         with_error_handling(EH_THROW, php_http_exception_get_class_entry()) {
1770                 if (SUCCESS == zend_parse_parameters_none()) {
1771                         php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1772
1773                         if (!obj->message) {
1774                                 obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1775                         }
1776
1777                         if (obj->message->parent) {
1778                                 RETVAL_OBJVAL(obj->parent, 1);
1779                         } else {
1780                                 php_http_error(HE_WARNING, PHP_HTTP_E_RUNTIME, "HttpMessage does not have a parent message");
1781                         }
1782                 }
1783         } end_error_handling();
1784 }
1785
1786 PHP_METHOD(HttpMessage, toString)
1787 {
1788         zend_bool include_parent = 0;
1789
1790         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &include_parent)) {
1791                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1792                 char *string;
1793                 size_t length;
1794
1795                 if (!obj->message) {
1796                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1797                 }
1798
1799                 if (include_parent) {
1800                         php_http_message_serialize(obj->message, &string, &length);
1801                 } else {
1802                         php_http_message_to_string(obj->message, &string, &length);
1803                 }
1804                 if (string) {
1805                         RETURN_STRINGL(string, length, 0);
1806                 }
1807         }
1808         RETURN_EMPTY_STRING();
1809 }
1810
1811 PHP_METHOD(HttpMessage, toStream)
1812 {
1813         zval *zstream;
1814
1815         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zstream)) {
1816                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1817                 php_stream *s;
1818
1819                 php_stream_from_zval(s, &zstream);
1820
1821                 if (!obj->message) {
1822                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1823                 }
1824
1825                 php_http_message_to_callback(obj->message, (php_http_pass_callback_t) _php_stream_write, s);
1826         }
1827 }
1828
1829 PHP_METHOD(HttpMessage, toCallback)
1830 {
1831         php_http_pass_fcall_arg_t fcd;
1832
1833         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "f", &fcd.fci, &fcd.fcc)) {
1834                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1835
1836                 fcd.fcz = getThis();
1837                 Z_ADDREF_P(fcd.fcz);
1838                 TSRMLS_SET_CTX(fcd.ts);
1839
1840                 php_http_message_to_callback(obj->message, php_http_pass_fcall_callback, &fcd);
1841                 zend_fcall_info_args_clear(&fcd.fci, 1);
1842
1843                 zval_ptr_dtor(&fcd.fcz);
1844                 RETURN_TRUE;
1845         }
1846         RETURN_FALSE;
1847 }
1848
1849 PHP_METHOD(HttpMessage, serialize)
1850 {
1851         if (SUCCESS == zend_parse_parameters_none()) {
1852                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1853                 char *string;
1854                 size_t length;
1855
1856                 if (!obj->message) {
1857                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1858                 }
1859
1860                 php_http_message_serialize(obj->message, &string, &length);
1861                 RETURN_STRINGL(string, length, 0);
1862         }
1863         RETURN_EMPTY_STRING();
1864 }
1865
1866 PHP_METHOD(HttpMessage, unserialize)
1867 {
1868         int length;
1869         char *serialized;
1870
1871         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &serialized, &length)) {
1872                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1873                 php_http_message_t *msg;
1874
1875                 if (obj->message) {
1876                         php_http_message_dtor(obj->message);
1877                         efree(obj->message);
1878                 }
1879                 if ((msg = php_http_message_parse(NULL, serialized, (size_t) length TSRMLS_CC))) {
1880                         obj->message = msg;
1881                 } else {
1882                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1883                         php_http_error(HE_ERROR, PHP_HTTP_E_RUNTIME, "Could not unserialize HttpMessage");
1884                 }
1885         }
1886 }
1887
1888 PHP_METHOD(HttpMessage, detach)
1889 {
1890         with_error_handling(EH_THROW, php_http_exception_get_class_entry()) {
1891                 if (SUCCESS == zend_parse_parameters_none()) {
1892                         php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1893
1894                         if (!obj->message) {
1895                                 obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1896                         }
1897
1898                         RETVAL_OBJVAL(php_http_message_object_new_ex(obj->zo.ce, php_http_message_copy(obj->message, NULL), NULL TSRMLS_CC), 0);
1899                 }
1900         } end_error_handling();
1901 }
1902
1903 PHP_METHOD(HttpMessage, prepend)
1904 {
1905         zval *prepend;
1906         zend_bool top = 1;
1907
1908         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|b", &prepend, php_http_message_class_entry, &top)) {
1909                 php_http_message_t *msg[2];
1910                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1911                 php_http_message_object_t *prepend_obj = zend_object_store_get_object(prepend TSRMLS_CC);
1912
1913                 if (!obj->message) {
1914                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1915                 }
1916                 if (!prepend_obj->message) {
1917                         prepend_obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1918                 }
1919
1920                 /* safety check */
1921                 for (msg[0] = obj->message; msg[0]; msg[0] = msg[0]->parent) {
1922                         for (msg[1] = prepend_obj->message; msg[1]; msg[1] = msg[1]->parent) {
1923                                 if (msg[0] == msg[1]) {
1924                                         php_http_error(HE_THROW, PHP_HTTP_E_INVALID_PARAM, "Cannot prepend a message located within the same message chain");
1925                                         return;
1926                                 }
1927                         }
1928                 }
1929
1930                 php_http_message_object_prepend(getThis(), prepend, top TSRMLS_CC);
1931         }
1932 }
1933
1934 PHP_METHOD(HttpMessage, reverse)
1935 {
1936         if (SUCCESS == zend_parse_parameters_none()) {
1937                 php_http_message_object_reverse(getThis(), return_value TSRMLS_CC);
1938         }
1939 }
1940
1941 PHP_METHOD(HttpMessage, isMultipart)
1942 {
1943         zval *zboundary = NULL;
1944
1945         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &zboundary)) {
1946                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1947                 char *boundary = NULL;
1948
1949                 RETVAL_BOOL(php_http_message_is_multipart(obj->message, zboundary ? &boundary : NULL));
1950
1951                 if (zboundary && boundary) {
1952                         zval_dtor(zboundary);
1953                         ZVAL_STRING(zboundary, boundary, 0);
1954                 }
1955         }
1956 }
1957
1958 PHP_METHOD(HttpMessage, splitMultipartBody)
1959 {
1960         if (SUCCESS == zend_parse_parameters_none()) {
1961                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1962                 char *boundary = NULL;
1963
1964                 if (php_http_message_is_multipart(obj->message, &boundary)) {
1965                         php_http_message_t *msg;
1966
1967                         if ((msg = php_http_message_body_split(&obj->message->body, boundary))) {
1968                                 RETVAL_OBJVAL(php_http_message_object_new_ex(php_http_message_class_entry, msg, NULL TSRMLS_CC), 0);
1969                         }
1970                 }
1971                 STR_FREE(boundary);
1972         }
1973 }
1974
1975 PHP_METHOD(HttpMessage, count)
1976 {
1977         if (SUCCESS == zend_parse_parameters_none()) {
1978                 long i = 0;
1979                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1980
1981                 if (!obj->message) {
1982                         obj->message = php_http_message_init(NULL, 0 TSRMLS_CC);
1983                 }
1984
1985                 php_http_message_count(i, obj->message);
1986                 RETURN_LONG(i);
1987         }
1988         RETURN_FALSE;
1989 }
1990
1991 PHP_METHOD(HttpMessage, rewind)
1992 {
1993         if (SUCCESS == zend_parse_parameters_none()) {
1994                 zval *zobj = getThis();
1995                 php_http_message_object_t *obj = zend_object_store_get_object(zobj TSRMLS_CC);
1996
1997                 if (obj->iterator) {
1998                         zval_ptr_dtor(&obj->iterator);
1999                 }
2000                 Z_ADDREF_P(zobj);
2001                 obj->iterator = zobj;
2002         }
2003 }
2004
2005 PHP_METHOD(HttpMessage, valid)
2006 {
2007         if (SUCCESS == zend_parse_parameters_none()) {
2008                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
2009
2010                 RETURN_BOOL(obj->iterator != NULL);
2011         }
2012 }
2013
2014 PHP_METHOD(HttpMessage, next)
2015 {
2016         if (SUCCESS == zend_parse_parameters_none()) {
2017                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
2018
2019                 if (obj->iterator) {
2020                         php_http_message_object_t *itr = zend_object_store_get_object(obj->iterator TSRMLS_CC);
2021
2022                         if (itr && itr->parent.handle) {
2023                                 zval *old = obj->iterator;
2024                                 MAKE_STD_ZVAL(obj->iterator);
2025                                 ZVAL_OBJVAL(obj->iterator, itr->parent, 1);
2026                                 zval_ptr_dtor(&old);
2027                         } else {
2028                                 zval_ptr_dtor(&obj->iterator);
2029                                 obj->iterator = NULL;
2030                         }
2031                 }
2032         }
2033 }
2034
2035 PHP_METHOD(HttpMessage, key)
2036 {
2037         if (SUCCESS == zend_parse_parameters_none()) {
2038                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
2039
2040                 RETURN_LONG(obj->iterator ? obj->iterator->value.obj.handle:0);
2041         }
2042 }
2043
2044 PHP_METHOD(HttpMessage, current)
2045 {
2046         if (SUCCESS == zend_parse_parameters_none()) {
2047                 php_http_message_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
2048
2049                 if (obj->iterator) {
2050                         RETURN_ZVAL(obj->iterator, 1, 0);
2051                 }
2052         }
2053 }
2054
2055 /*
2056  * Local variables:
2057  * tab-width: 4
2058  * c-basic-offset: 4
2059  * End:
2060  * vim600: noet sw=4 ts=4 fdm=marker
2061  * vim<600: noet sw=4 ts=4
2062  */
2063