git.m6w6.name Git - m6w6/ext-http/blob - php_http_request.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-2010, Michael Wallner <mike@php.net>            |
  10     +--------------------------------------------------------------------+
  11 */
  12
  13 /* $Id: php_http_request_api.c 298591 2010-04-26 11:46:55Z mike $ */
  14
  15 #include "php_http.h"
  16
  17 #include <ext/spl/spl_observer.h>
  18 #include <ext/spl/spl_iterators.h>
  19 #include <Zend/zend_interfaces.h>
  20
  21
  22 PHP_HTTP_API php_http_request_t *php_http_request_init(php_http_request_t *h, php_http_request_ops_t *ops, void *init_arg TSRMLS_DC)
  23 {
  24         php_http_request_t *free_h = NULL;
  25
  26         if (!h) {
  27                 free_h = h = emalloc(sizeof(*h));
  28         }
  29         memset(h, 0, sizeof(*h));
  30
  31         h->ops = ops;
  32         h->buffer = php_http_buffer_init(NULL TSRMLS_CC);
  33         h->parser = php_http_message_parser_init(NULL TSRMLS_CC);
  34         h->message = php_http_message_init(NULL, 0 TSRMLS_CC);
  35
  36         TSRMLS_SET_CTX(h->ts);
  37
  38         if (h->ops->init) {
  39                 if (!(h = h->ops->init(h, init_arg))) {
  40                         php_http_error(HE_WARNING, PHP_HTTP_E_REQUEST, "Could not initialize request");
  41                         if (free_h) {
  42                                 efree(free_h);
  43                         }
  44                 }
  45         }
  46
  47         return h;
  48 }
  49
  50 PHP_HTTP_API void php_http_request_dtor(php_http_request_t *h)
  51 {
  52         if (h->ops->dtor) {
  53                 h->ops->dtor(h);
  54         }
  55
  56         php_http_message_parser_free(&h->parser);
  57         php_http_message_free(&h->message);
  58         php_http_buffer_free(&h->buffer);
  59 }
  60
  61 PHP_HTTP_API void php_http_request_free(php_http_request_t **h)
  62 {
  63         if (*h) {
  64                 php_http_request_dtor(*h);
  65                 efree(*h);
  66                 *h = NULL;
  67         }
  68 }
  69
  70 PHP_HTTP_API php_http_request_t *php_http_request_copy(php_http_request_t *from, php_http_request_t *to)
  71 {
  72         if (from->ops->copy) {
  73                 return from->ops->copy(from, to);
  74         }
  75         return NULL;
  76 }
  77
  78 PHP_HTTP_API STATUS php_http_request_exec(php_http_request_t *h, php_http_request_method_t meth, const char *url, php_http_message_body_t *body)
  79 {
  80         if (h->ops->exec) {
  81                 return h->ops->exec(h, meth, url, body);
  82         }
  83         return FAILURE;
  84 }
  85
  86 PHP_HTTP_API STATUS php_http_request_reset(php_http_request_t *h)
  87 {
  88         if (h->ops->reset) {
  89                 return h->ops->reset(h);
  90         }
  91         return FAILURE;
  92 }
  93
  94 PHP_HTTP_API STATUS php_http_request_setopt(php_http_request_t *h, php_http_request_setopt_opt_t opt, void *arg)
  95 {
  96         if (h->ops->setopt) {
  97                 return h->ops->setopt(h, opt, arg);
  98         }
  99         return FAILURE;
 100 }
 101
 102 PHP_HTTP_API STATUS php_http_request_getopt(php_http_request_t *h, php_http_request_getopt_opt_t opt, void *arg)
 103 {
 104         if (h->ops->getopt) {
 105                 return h->ops->getopt(h, opt, arg);
 106         }
 107         return FAILURE;
 108 }
 109
 110 #define PHP_HTTP_BEGIN_ARGS(method, req_args)   PHP_HTTP_BEGIN_ARGS_EX(HttpRequest, method, 0, req_args)
 111 #define PHP_HTTP_EMPTY_ARGS(method)                             PHP_HTTP_EMPTY_ARGS_EX(HttpRequest, method, 0)
 112 #define PHP_HTTP_REQUEST_ME(method, visibility) PHP_ME(HttpRequest, method, PHP_HTTP_ARGS(HttpRequest, method), visibility)
 113 #define PHP_HTTP_REQUEST_ALIAS(method, func)    PHP_HTTP_STATIC_ME_ALIAS(method, func, PHP_HTTP_ARGS(HttpRequest, method))
 114 #define PHP_HTTP_REQUEST_MALIAS(me, al, vis)    ZEND_FENTRY(me, ZEND_MN(HttpRequest_##al), PHP_HTTP_ARGS(HttpRequest, al), vis)
 115
 116 PHP_HTTP_EMPTY_ARGS(__construct);
 117
 118 PHP_HTTP_EMPTY_ARGS(getOptions);
 119 PHP_HTTP_BEGIN_ARGS(setOptions, 0)
 120         PHP_HTTP_ARG_VAL(options, 0)
 121 PHP_HTTP_END_ARGS;
 122
 123 PHP_HTTP_EMPTY_ARGS(getSslOptions);
 124 PHP_HTTP_BEGIN_ARGS(setSslOptions, 0)
 125         PHP_HTTP_ARG_VAL(ssl_options, 0)
 126 PHP_HTTP_END_ARGS;
 127
 128 PHP_HTTP_BEGIN_ARGS(addSslOptions, 0)
 129         PHP_HTTP_ARG_VAL(ssl_optins, 0)
 130 PHP_HTTP_END_ARGS;
 131
 132 PHP_HTTP_EMPTY_ARGS(getHeaders);
 133 PHP_HTTP_BEGIN_ARGS(setHeaders, 0)
 134         PHP_HTTP_ARG_VAL(headers, 0)
 135 PHP_HTTP_END_ARGS;
 136
 137 PHP_HTTP_BEGIN_ARGS(addHeaders, 1)
 138         PHP_HTTP_ARG_VAL(headers, 0)
 139 PHP_HTTP_END_ARGS;
 140
 141 PHP_HTTP_EMPTY_ARGS(getCookies);
 142 PHP_HTTP_BEGIN_ARGS(setCookies, 0)
 143         PHP_HTTP_ARG_VAL(cookies, 0)
 144 PHP_HTTP_END_ARGS;
 145
 146 PHP_HTTP_BEGIN_ARGS(addCookies, 1)
 147         PHP_HTTP_ARG_VAL(cookies, 0)
 148 PHP_HTTP_END_ARGS;
 149
 150 PHP_HTTP_EMPTY_ARGS(enableCookies);
 151 PHP_HTTP_BEGIN_ARGS(resetCookies, 0)
 152         PHP_HTTP_ARG_VAL(session_only, 0)
 153 PHP_HTTP_END_ARGS;
 154 PHP_HTTP_EMPTY_ARGS(flushCookies);
 155
 156 PHP_HTTP_EMPTY_ARGS(getUrl);
 157 PHP_HTTP_BEGIN_ARGS(setUrl, 1)
 158         PHP_HTTP_ARG_VAL(url, 0)
 159 PHP_HTTP_END_ARGS;
 160
 161 PHP_HTTP_EMPTY_ARGS(getMethod);
 162 PHP_HTTP_BEGIN_ARGS(setMethod, 1)
 163         PHP_HTTP_ARG_VAL(request_method, 0)
 164 PHP_HTTP_END_ARGS;
 165
 166 PHP_HTTP_EMPTY_ARGS(getContentType);
 167 PHP_HTTP_BEGIN_ARGS(setContentType, 1)
 168         PHP_HTTP_ARG_VAL(content_type, 0)
 169 PHP_HTTP_END_ARGS;
 170
 171 PHP_HTTP_EMPTY_ARGS(getQueryData);
 172 PHP_HTTP_BEGIN_ARGS(setQueryData, 0)
 173         PHP_HTTP_ARG_VAL(query_data, 0)
 174 PHP_HTTP_END_ARGS;
 175
 176 PHP_HTTP_BEGIN_ARGS(addQueryData, 1)
 177         PHP_HTTP_ARG_VAL(query_data, 0)
 178 PHP_HTTP_END_ARGS;
 179
 180
 181 PHP_HTTP_EMPTY_ARGS(getBody);
 182 PHP_HTTP_BEGIN_ARGS(setBody, 0)
 183         PHP_HTTP_ARG_OBJ(http\\message\\Body, body, 0)
 184 PHP_HTTP_END_ARGS;
 185
 186 PHP_HTTP_BEGIN_ARGS(addBody, 1)
 187         PHP_HTTP_ARG_OBJ(http\\message\\Body, body, 0)
 188 PHP_HTTP_END_ARGS;
 189
 190 PHP_HTTP_BEGIN_ARGS(getResponseCookies, 0)
 191         PHP_HTTP_ARG_VAL(flags, 0)
 192         PHP_HTTP_ARG_VAL(allowed_extras, 0)
 193 PHP_HTTP_END_ARGS;
 194
 195 PHP_HTTP_EMPTY_ARGS(getResponseBody);
 196 PHP_HTTP_EMPTY_ARGS(getResponseCode);
 197 PHP_HTTP_EMPTY_ARGS(getResponseStatus);
 198 PHP_HTTP_BEGIN_ARGS(getResponseHeader, 0)
 199         PHP_HTTP_ARG_VAL(header_name, 0)
 200 PHP_HTTP_END_ARGS;
 201
 202 PHP_HTTP_EMPTY_ARGS(getMessageClass);
 203 PHP_HTTP_BEGIN_ARGS(setMessageClass, 1)
 204         PHP_HTTP_ARG_VAL(message_class_name, 0)
 205 PHP_HTTP_END_ARGS;
 206
 207 PHP_HTTP_EMPTY_ARGS(getResponseMessage);
 208 PHP_HTTP_EMPTY_ARGS(getRawResponseMessage);
 209 PHP_HTTP_EMPTY_ARGS(getRequestMessage);
 210 PHP_HTTP_EMPTY_ARGS(getRawRequestMessage);
 211 PHP_HTTP_EMPTY_ARGS(getHistory);
 212 PHP_HTTP_EMPTY_ARGS(clearHistory);
 213 PHP_HTTP_EMPTY_ARGS(send);
 214
 215 PHP_HTTP_EMPTY_ARGS(getObservers);
 216 PHP_HTTP_BEGIN_ARGS(attach, 1)
 217         PHP_HTTP_ARG_OBJ(SplObserver, observer, 0)
 218 PHP_HTTP_END_ARGS;
 219 PHP_HTTP_BEGIN_ARGS(detach, 1)
 220         PHP_HTTP_ARG_OBJ(SplObserver, observer, 0)
 221 PHP_HTTP_END_ARGS;
 222 PHP_HTTP_EMPTY_ARGS(notify);
 223 PHP_HTTP_EMPTY_ARGS(getProgress);
 224 PHP_HTTP_BEGIN_ARGS(getTransferInfo, 0)
 225         PHP_HTTP_ARG_VAL(name, 0)
 226 PHP_HTTP_END_ARGS;
 227
 228
 229 zend_class_entry *php_http_request_class_entry;
 230 zend_function_entry php_http_request_method_entry[] = {
 231         PHP_HTTP_REQUEST_ME(__construct, ZEND_ACC_PRIVATE|ZEND_ACC_CTOR)
 232
 233         PHP_HTTP_REQUEST_ME(getObservers, ZEND_ACC_PUBLIC)
 234         PHP_HTTP_REQUEST_ME(notify, ZEND_ACC_PUBLIC)
 235         PHP_HTTP_REQUEST_ME(attach, ZEND_ACC_PUBLIC)
 236         PHP_HTTP_REQUEST_ME(detach, ZEND_ACC_PUBLIC)
 237         PHP_HTTP_REQUEST_ME(getProgress, ZEND_ACC_PUBLIC)
 238         PHP_HTTP_REQUEST_ME(getTransferInfo, ZEND_ACC_PUBLIC)
 239
 240         PHP_HTTP_REQUEST_ME(setOptions, ZEND_ACC_PUBLIC)
 241         PHP_HTTP_REQUEST_ME(getOptions, ZEND_ACC_PUBLIC)
 242         PHP_HTTP_REQUEST_ME(setSslOptions, ZEND_ACC_PUBLIC)
 243         PHP_HTTP_REQUEST_ME(getSslOptions, ZEND_ACC_PUBLIC)
 244         PHP_HTTP_REQUEST_ME(addSslOptions, ZEND_ACC_PUBLIC)
 245
 246         PHP_HTTP_REQUEST_ME(addHeaders, ZEND_ACC_PUBLIC)
 247         PHP_HTTP_REQUEST_ME(getHeaders, ZEND_ACC_PUBLIC)
 248         PHP_HTTP_REQUEST_ME(setHeaders, ZEND_ACC_PUBLIC)
 249
 250         PHP_HTTP_REQUEST_ME(addCookies, ZEND_ACC_PUBLIC)
 251         PHP_HTTP_REQUEST_ME(getCookies, ZEND_ACC_PUBLIC)
 252         PHP_HTTP_REQUEST_ME(setCookies, ZEND_ACC_PUBLIC)
 253
 254         PHP_HTTP_REQUEST_ME(enableCookies, ZEND_ACC_PUBLIC)
 255         PHP_HTTP_REQUEST_ME(resetCookies, ZEND_ACC_PUBLIC)
 256         PHP_HTTP_REQUEST_ME(flushCookies, ZEND_ACC_PUBLIC)
 257
 258         PHP_HTTP_REQUEST_ME(setMethod, ZEND_ACC_PUBLIC)
 259         PHP_HTTP_REQUEST_ME(getMethod, ZEND_ACC_PUBLIC)
 260
 261         PHP_HTTP_REQUEST_ME(setUrl, ZEND_ACC_PUBLIC)
 262         PHP_HTTP_REQUEST_ME(getUrl, ZEND_ACC_PUBLIC)
 263
 264         PHP_HTTP_REQUEST_ME(setContentType, ZEND_ACC_PUBLIC)
 265         PHP_HTTP_REQUEST_ME(getContentType, ZEND_ACC_PUBLIC)
 266
 267         PHP_HTTP_REQUEST_ME(setQueryData, ZEND_ACC_PUBLIC)
 268         PHP_HTTP_REQUEST_ME(getQueryData, ZEND_ACC_PUBLIC)
 269         PHP_HTTP_REQUEST_ME(addQueryData, ZEND_ACC_PUBLIC)
 270
 271         PHP_HTTP_REQUEST_ME(setBody, ZEND_ACC_PUBLIC)
 272         PHP_HTTP_REQUEST_ME(getBody, ZEND_ACC_PUBLIC)
 273         PHP_HTTP_REQUEST_ME(addBody, ZEND_ACC_PUBLIC)
 274
 275         PHP_HTTP_REQUEST_ME(send, ZEND_ACC_PUBLIC)
 276
 277         PHP_HTTP_REQUEST_ME(getResponseHeader, ZEND_ACC_PUBLIC)
 278         PHP_HTTP_REQUEST_ME(getResponseCookies, ZEND_ACC_PUBLIC)
 279         PHP_HTTP_REQUEST_ME(getResponseCode, ZEND_ACC_PUBLIC)
 280         PHP_HTTP_REQUEST_ME(getResponseStatus, ZEND_ACC_PUBLIC)
 281         PHP_HTTP_REQUEST_ME(getResponseBody, ZEND_ACC_PUBLIC)
 282         PHP_HTTP_REQUEST_ME(getResponseMessage, ZEND_ACC_PUBLIC)
 283         PHP_HTTP_REQUEST_ME(getRequestMessage, ZEND_ACC_PUBLIC)
 284         PHP_HTTP_REQUEST_ME(getHistory, ZEND_ACC_PUBLIC)
 285         PHP_HTTP_REQUEST_ME(clearHistory, ZEND_ACC_PUBLIC)
 286
 287         PHP_HTTP_REQUEST_ME(getMessageClass, ZEND_ACC_PUBLIC)
 288         PHP_HTTP_REQUEST_ME(setMessageClass, ZEND_ACC_PUBLIC)
 289
 290         EMPTY_FUNCTION_ENTRY
 291 };
 292 static zend_object_handlers php_http_request_object_handlers;
 293
 294 zend_object_value php_http_request_object_new(zend_class_entry *ce TSRMLS_DC)
 295 {
 296         return php_http_request_object_new_ex(ce, NULL, NULL TSRMLS_CC);
 297 }
 298
 299 zend_object_value php_http_request_object_new_ex(zend_class_entry *ce, php_http_request_t *r, php_http_request_object_t **ptr TSRMLS_DC)
 300 {
 301         zend_object_value ov;
 302         php_http_request_object_t *o;
 303
 304         o = ecalloc(1, sizeof(php_http_request_object_t));
 305         zend_object_std_init((zend_object *) o, ce TSRMLS_CC);
 306         object_properties_init((zend_object *) o, ce);
 307
 308         if (!(o->request = r)) {
 309                 o->request = php_http_request_init(NULL, NULL, NULL TSRMLS_CC);
 310         }
 311
 312         if (ptr) {
 313                 *ptr = o;
 314         }
 315
 316         ov.handle = zend_objects_store_put(o, NULL, php_http_request_object_free, NULL TSRMLS_CC);
 317         ov.handlers = &php_http_request_object_handlers;
 318
 319         return ov;
 320 }
 321
 322 zend_object_value php_http_request_object_clone(zval *this_ptr TSRMLS_DC)
 323 {
 324         zend_object_value new_ov;
 325         php_http_request_object_t *new_obj, *old_obj = zend_object_store_get_object(this_ptr TSRMLS_CC);
 326
 327         new_ov = php_http_request_object_new_ex(old_obj->zo.ce, php_http_request_copy(old_obj->request, NULL), &new_obj TSRMLS_CC);
 328         zend_objects_clone_members(&new_obj->zo, new_ov, &old_obj->zo, Z_OBJ_HANDLE_P(this_ptr) TSRMLS_CC);
 329
 330         return new_ov;
 331 }
 332
 333 void php_http_request_object_free(void *object TSRMLS_DC)
 334 {
 335         php_http_request_object_t *o = (php_http_request_object_t *) object;
 336
 337         php_http_request_free(&o->request);
 338         zend_object_std_dtor((zend_object *) o TSRMLS_CC);
 339         efree(o);
 340 }
 341
 342 static inline void php_http_request_object_check_request_content_type(zval *this_ptr TSRMLS_DC)
 343 {
 344         zval *ctype = zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("contentType"), 0 TSRMLS_CC);
 345
 346         if (Z_STRLEN_P(ctype)) {
 347                 zval **headers, *opts = zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("options"), 0 TSRMLS_CC);
 348
 349                 if (    (Z_TYPE_P(opts) == IS_ARRAY) &&
 350                                 (SUCCESS == zend_hash_find(Z_ARRVAL_P(opts), ZEND_STRS("headers"), (void *) &headers)) &&
 351                                 (Z_TYPE_PP(headers) == IS_ARRAY)) {
 352                         zval **ct_header;
 353
 354                         /* only override if not already set */
 355                         if ((SUCCESS != zend_hash_find(Z_ARRVAL_PP(headers), ZEND_STRS("Content-Type"), (void *) &ct_header))) {
 356                                 add_assoc_stringl(*headers, "Content-Type", Z_STRVAL_P(ctype), Z_STRLEN_P(ctype), 1);
 357                         } else
 358                         /* or not a string, zero length string or a string of spaces */
 359                         if ((Z_TYPE_PP(ct_header) != IS_STRING) || !Z_STRLEN_PP(ct_header)) {
 360                                 add_assoc_stringl(*headers, "Content-Type", Z_STRVAL_P(ctype), Z_STRLEN_P(ctype), 1);
 361                         } else {
 362                                 int i, only_space = 1;
 363
 364                                 /* check for spaces only */
 365                                 for (i = 0; i < Z_STRLEN_PP(ct_header); ++i) {
 366                                         if (!PHP_HTTP_IS_CTYPE(space, Z_STRVAL_PP(ct_header)[i])) {
 367                                                 only_space = 0;
 368                                                 break;
 369                                         }
 370                                 }
 371                                 if (only_space) {
 372                                         add_assoc_stringl(*headers, "Content-Type", Z_STRVAL_P(ctype), Z_STRLEN_P(ctype), 1);
 373                                 }
 374                         }
 375                 } else {
 376                         zval *headers;
 377
 378                         MAKE_STD_ZVAL(headers);
 379                         array_init(headers);
 380                         add_assoc_stringl(headers, "Content-Type", Z_STRVAL_P(ctype), Z_STRLEN_P(ctype), 1);
 381                         zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "addheaders", NULL, headers);
 382                         zval_ptr_dtor(&headers);
 383                 }
 384         }
 385 }
 386
 387 static inline zend_object_value php_http_request_object_message(zval *this_ptr, php_http_message_t *msg TSRMLS_DC)
 388 {
 389         zend_object_value ov;
 390         zval *zcn = zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("messageClass"), 0 TSRMLS_CC);
 391         zend_class_entry *class_entry;
 392
 393         if (Z_STRLEN_P(zcn)
 394         &&      (class_entry = zend_fetch_class(Z_STRVAL_P(zcn), Z_STRLEN_P(zcn), 0 TSRMLS_CC))
 395         &&      (SUCCESS == php_http_new(&ov, class_entry, (php_http_new_t) php_http_message_object_new_ex, php_http_message_class_entry, msg, NULL TSRMLS_CC))) {
 396                 return ov;
 397         } else {
 398                 return php_http_message_object_new_ex(php_http_message_class_entry, msg, NULL TSRMLS_CC);
 399         }
 400 }
 401
 402 STATUS php_http_request_object_requesthandler(php_http_request_object_t *obj, zval *this_ptr, php_http_request_method_t *meth, char **url, php_http_message_body_t **body TSRMLS_DC)
 403 {
 404         zval *zoptions;
 405         php_http_request_progress_t *progress;
 406
 407         /* reset request handle */
 408         php_http_request_reset(obj->request);
 409         /* reset transfer info */
 410         zend_update_property_null(php_http_request_class_entry, getThis(), ZEND_STRL("info") TSRMLS_CC);
 411
 412         if (meth) {
 413                 *meth = (php_http_request_method_t) Z_LVAL_P(zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("method"), 0 TSRMLS_CC));
 414         }
 415
 416         if (url) {
 417                 php_url *tmp, qdu = {0};
 418                 zval *zurl = zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("url"), 0 TSRMLS_CC);
 419                 zval *zqdata = zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("queryData"), 0 TSRMLS_CC);
 420
 421                 if (Z_STRLEN_P(zqdata)) {
 422                         qdu.query = Z_STRVAL_P(zqdata);
 423                 }
 424                 php_http_url(0, tmp = php_url_parse(Z_STRVAL_P(zurl)), &qdu, NULL, url, NULL TSRMLS_CC);
 425                 php_url_free(tmp);
 426         }
 427
 428         if (body) {
 429                 zval *zbody = zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("requestBody"), 0 TSRMLS_CC);
 430
 431                 if (Z_TYPE_P(zbody) == IS_OBJECT) {
 432                         *body = ((php_http_message_body_object_t *)zend_object_store_get_object(zbody TSRMLS_CC))->body;
 433                 }
 434         }
 435
 436         php_http_request_object_check_request_content_type(getThis() TSRMLS_CC);
 437         zoptions = zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("options"), 0 TSRMLS_CC);
 438         php_http_request_setopt(obj->request, PHP_HTTP_REQUEST_OPT_SETTINGS, Z_ARRVAL_P(zoptions));
 439
 440         if (SUCCESS == php_http_request_getopt(obj->request, PHP_HTTP_REQUEST_OPT_PROGRESS_INFO, &progress)) {
 441                 if (!progress->callback) {
 442                         zval *pcb;
 443                         int no = 0;
 444
 445                         MAKE_STD_ZVAL(pcb);
 446                         array_init(pcb);
 447                         Z_ADDREF_P(getThis());
 448                         add_next_index_zval(pcb, getThis());
 449                         add_next_index_stringl(pcb, ZEND_STRL("notify"), 1);
 450
 451                         php_http_request_setopt(obj->request, PHP_HTTP_REQUEST_OPT_PROGRESS_CALLBACK, pcb);
 452                         php_http_request_setopt(obj->request, PHP_HTTP_REQUEST_OPT_PROGRESS_CALLBACK_WANTS_STATE, &no);
 453                         zval_ptr_dtor(&pcb);
 454                 }
 455                 php_http_request_progress_notify(progress TSRMLS_CC);
 456                 progress->state.started = 1;
 457         }
 458         return SUCCESS;
 459 }
 460
 461 STATUS php_http_request_object_responsehandler(php_http_request_object_t *obj, zval *this_ptr TSRMLS_DC)
 462 {
 463         STATUS ret = SUCCESS;
 464         zval *info;
 465         php_http_message_t *msg;
 466         php_http_request_progress_t *progress;
 467
 468         /* always fetch info */
 469         MAKE_STD_ZVAL(info);
 470         array_init(info);
 471         php_http_request_getopt(obj->request, PHP_HTTP_REQUEST_OPT_TRANSFER_INFO, Z_ARRVAL_P(info));
 472         zend_update_property(php_http_request_class_entry, getThis(), ZEND_STRL("transferInfo"), info TSRMLS_CC);
 473         zval_ptr_dtor(&info);
 474
 475         /* update history * /
 476         if (i_zend_is_true(zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("recordHistory"), 0 TSRMLS_CC))) {
 477                 zval *new_hist, *old_hist = zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("history"), 0 TSRMLS_CC);
 478                 zend_object_value ov = php_http_request_object_message(getThis(), obj->request->message_parser.message TSRMLS_CC);
 479
 480                 MAKE_STD_ZVAL(new_hist);
 481                 ZVAL_OBJVAL(new_hist, ov, 0);
 482
 483                 if (Z_TYPE_P(old_hist) == IS_OBJECT) {
 484                         php_http_message_object_prepend(new_hist, old_hist, 0 TSRMLS_CC);
 485                 }
 486
 487                 zend_update_property(php_http_request_class_entry, getThis(), ZEND_STRL("history"), new_hist TSRMLS_CC);
 488                 zval_ptr_dtor(&new_hist);
 489         }
 490 */
 491 //      if ((msg = obj->request->_current.request)) {
 492 //              /* update request message */
 493 //              zval *message;
 494 //
 495 //              MAKE_STD_ZVAL(message);
 496 //              ZVAL_OBJVAL(message, php_http_request_object_message(getThis(), msg TSRMLS_CC), 1);
 497 //              zend_update_property(php_http_request_class_entry, getThis(), ZEND_STRL("requestMessage"), message TSRMLS_CC);
 498 //      }
 499 // fprintf(stderr, "RESPONSE MESSAGE: %p\n", obj->request->parser.msg);
 500         if ((msg = obj->request->message)) {
 501                 /* update properties with response info */
 502                 zval *message;
 503
 504                 zend_update_property_long(php_http_request_class_entry, getThis(), ZEND_STRL("responseCode"), msg->http.info.response.code TSRMLS_CC);
 505                 zend_update_property_string(php_http_request_class_entry, getThis(), ZEND_STRL("responseStatus"), STR_PTR(msg->http.info.response.status) TSRMLS_CC);
 506
 507                 MAKE_STD_ZVAL(message);
 508                 ZVAL_OBJVAL(message, php_http_request_object_message(getThis(), msg TSRMLS_CC), 0);
 509                 zend_update_property(php_http_request_class_entry, getThis(), ZEND_STRL("responseMessage"), message TSRMLS_CC);
 510                 zval_ptr_dtor(&message);
 511                 obj->request->message = php_http_message_init(NULL, 0 TSRMLS_CC);
 512         } else {
 513                 /* update properties with empty values */
 514                 zval *znull;
 515
 516                 MAKE_STD_ZVAL(znull);
 517                 ZVAL_NULL(znull);
 518                 zend_update_property(php_http_request_class_entry, getThis(), ZEND_STRL("responseMessage"), znull TSRMLS_CC);
 519                 zval_ptr_dtor(&znull);
 520
 521                 zend_update_property_long(php_http_request_class_entry, getThis(), ZEND_STRL("responseCode"), 0 TSRMLS_CC);
 522                 zend_update_property_string(php_http_request_class_entry, getThis(), ZEND_STRL("responseStatus"), "" TSRMLS_CC);
 523         }
 524
 525         if (SUCCESS == php_http_request_getopt(obj->request, PHP_HTTP_REQUEST_OPT_PROGRESS_INFO, &progress)) {
 526                 progress->state.finished = 1;
 527                 php_http_request_progress_notify(progress TSRMLS_CC);
 528         }
 529         php_http_request_setopt(obj->request, PHP_HTTP_REQUEST_OPT_PROGRESS_CALLBACK, NULL);
 530
 531         return ret;
 532 }
 533
 534 static int apply_pretty_key(void *pDest, int num_args, va_list args, zend_hash_key *hash_key)
 535 {
 536         if (hash_key->arKey && hash_key->nKeyLength > 1) {
 537                 hash_key->h = zend_hash_func(php_http_pretty_key(hash_key->arKey, hash_key->nKeyLength - 1, 1, 0), hash_key->nKeyLength);
 538         }
 539         return ZEND_HASH_APPLY_KEEP;
 540 }
 541
 542 static inline void php_http_request_object_set_options_subr(INTERNAL_FUNCTION_PARAMETERS, char *key, size_t len, int overwrite, int prettify_keys)
 543 {
 544         zval *old_opts, *new_opts, *opts = NULL, **entry = NULL;
 545
 546         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a/!", &opts)) {
 547                 MAKE_STD_ZVAL(new_opts);
 548                 array_init(new_opts);
 549                 old_opts = zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("options"), 0 TSRMLS_CC);
 550                 if (Z_TYPE_P(old_opts) == IS_ARRAY) {
 551                         array_copy(Z_ARRVAL_P(old_opts), Z_ARRVAL_P(new_opts));
 552                 }
 553
 554                 if (SUCCESS == zend_hash_find(Z_ARRVAL_P(new_opts), key, len, (void *) &entry)) {
 555                         if (overwrite) {
 556                                 zend_hash_clean(Z_ARRVAL_PP(entry));
 557                         }
 558                         if (opts && zend_hash_num_elements(Z_ARRVAL_P(opts))) {
 559                                 if (overwrite) {
 560                                         array_copy(Z_ARRVAL_P(opts), Z_ARRVAL_PP(entry));
 561                                 } else {
 562                                         array_join(Z_ARRVAL_P(opts), Z_ARRVAL_PP(entry), 0, prettify_keys ? ARRAY_JOIN_PRETTIFY : 0);
 563                                 }
 564                         }
 565                 } else if (opts) {
 566                         if (prettify_keys) {
 567                                 zend_hash_apply_with_arguments(Z_ARRVAL_P(opts) TSRMLS_CC, apply_pretty_key, 0, NULL);
 568                         }
 569                         Z_ADDREF_P(opts);
 570                         add_assoc_zval_ex(new_opts, key, len, opts);
 571                 }
 572                 zend_update_property(php_http_request_class_entry, getThis(), ZEND_STRL("options"), new_opts TSRMLS_CC);
 573                 zval_ptr_dtor(&new_opts);
 574         }
 575
 576         RETVAL_ZVAL(getThis(), 1, 0);
 577 }
 578
 579 static inline void php_http_request_object_get_options_subr(INTERNAL_FUNCTION_PARAMETERS, char *key, size_t len)
 580 {
 581         if (SUCCESS == zend_parse_parameters_none()) {
 582                 zval *opts, **options;
 583
 584                 opts = zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("options"), 0 TSRMLS_CC);
 585                 array_init(return_value);
 586
 587                 if (    (Z_TYPE_P(opts) == IS_ARRAY) &&
 588                                 (SUCCESS == zend_hash_find(Z_ARRVAL_P(opts), key, len, (void *) &options))) {
 589                         convert_to_array(*options);
 590                         array_copy(Z_ARRVAL_PP(options), Z_ARRVAL_P(return_value));
 591                 }
 592         }
 593 }
 594
 595
 596 PHP_METHOD(HttpRequest, __construct)
 597 {
 598         with_error_handling(EH_THROW, PHP_HTTP_EX_CE(runtime)) {
 599                 zend_parse_parameters_none();
 600         } end_error_handling();
 601 }
 602
 603 PHP_METHOD(HttpRequest, getObservers)
 604 {
 605         with_error_handling(EH_THROW, PHP_HTTP_EX_CE(runtime)) {
 606                 if (SUCCESS == zend_parse_parameters_none()) {
 607                         RETVAL_PROP(php_http_request_class_entry, "observers");
 608                 }
 609         } end_error_handling();
 610 }
 611
 612 static int notify(zend_object_iterator *iter, void *puser TSRMLS_DC)
 613 {
 614         zval **observer = NULL;
 615
 616         iter->funcs->get_current_data(iter, &observer TSRMLS_CC);
 617         if (observer) {
 618                 zval *retval;
 619
 620                 zend_call_method_with_1_params(observer, NULL, NULL, "update", &retval, puser);
 621                 zval_ptr_dtor(&retval);
 622                 return SUCCESS;
 623         }
 624         return FAILURE;
 625 }
 626
 627 PHP_METHOD(HttpRequest, notify)
 628 {
 629         if (SUCCESS == zend_parse_parameters_none()) {
 630                 zval *observers = zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("observers"), 0 TSRMLS_CC);
 631
 632                 if (Z_TYPE_P(observers) == IS_OBJECT) {
 633                         Z_ADDREF_P(getThis());
 634                         spl_iterator_apply(observers, notify, getThis() TSRMLS_CC);
 635                         zval_ptr_dtor(&getThis());
 636                 }
 637         }
 638
 639         RETVAL_ZVAL(getThis(), 1, 0);
 640 }
 641
 642 PHP_METHOD(HttpRequest, attach)
 643 {
 644         zval *observer;
 645
 646         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &observer, spl_ce_SplObserver)) {
 647                 zval *retval, *observers = zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("observers"), 0 TSRMLS_CC);
 648                 zend_call_method_with_1_params(&observers, NULL, NULL, "attach", &retval, observer);
 649                 zval_ptr_dtor(&retval);
 650         }
 651
 652         RETVAL_ZVAL(getThis(), 1, 0);
 653 }
 654
 655 PHP_METHOD(HttpRequest, detach)
 656 {
 657         zval *observer;
 658
 659         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &observer, spl_ce_SplObserver)) {
 660                 zval *retval, *observers = zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("observers"), 0 TSRMLS_CC);
 661                 zend_call_method_with_1_params(&observers, NULL, NULL, "detach", &retval, observer);
 662                 zval_ptr_dtor(&retval);
 663         }
 664
 665         RETVAL_ZVAL(getThis(), 1, 0);
 666 }
 667
 668 PHP_METHOD(HttpRequest, getProgress)
 669 {
 670         if (SUCCESS == zend_parse_parameters_none()) {
 671                 php_http_request_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 672                 php_http_request_progress_t *progress;
 673
 674                 php_http_request_getopt(obj->request, PHP_HTTP_REQUEST_OPT_PROGRESS_INFO, &progress);
 675                 object_init(return_value);
 676                 add_property_bool(return_value, "started", progress->state.started);
 677                 add_property_bool(return_value, "finished", progress->state.finished);
 678                 add_property_double(return_value, "dltotal", progress->state.dl.total);
 679                 add_property_double(return_value, "dlnow", progress->state.dl.now);
 680                 add_property_double(return_value, "ultotal", progress->state.ul.total);
 681                 add_property_double(return_value, "ulnow", progress->state.ul.now);
 682         }
 683 }
 684
 685 PHP_METHOD(HttpRequest, getTransferInfo)
 686 {
 687         char *info_name = NULL;
 688         int info_len = 0;
 689
 690         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &info_name, &info_len)) {
 691                 zval **infop, *temp = NULL, *info = zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("transferInfo"), 0 TSRMLS_CC);
 692
 693                 /* request completed? */
 694                 if (Z_TYPE_P(info) != IS_ARRAY) {
 695                         php_http_request_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 696
 697                         MAKE_STD_ZVAL(temp);
 698                         array_init(temp);
 699                         php_http_request_getopt(obj->request, PHP_HTTP_REQUEST_OPT_TRANSFER_INFO, Z_ARRVAL_P(temp));
 700                         info = temp;
 701                 }
 702
 703                 if (info_len && info_name) {
 704                         if (SUCCESS == zend_hash_find(Z_ARRVAL_P(info), php_http_pretty_key(info_name, info_len, 0, 0), info_len + 1, (void *) &infop)) {
 705                                 RETVAL_ZVAL(*infop, 1, 0);
 706                         } else {
 707                                 php_http_error(HE_NOTICE, PHP_HTTP_E_INVALID_PARAM, "Could not find transfer info named %s", info_name);
 708                                 RETVAL_FALSE;
 709                         }
 710                 } else {
 711                         RETVAL_ZVAL(info, 1, 0);
 712                 }
 713
 714                 if (temp) {
 715                         zval_ptr_dtor(&temp);
 716                 }
 717                 return;
 718         }
 719         RETURN_FALSE;
 720 }
 721
 722 PHP_METHOD(HttpRequest, setOptions)
 723 {
 724         php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
 725         HashPosition pos;
 726         zval *opts = NULL, *old_opts, *new_opts, *add_opts, **opt;
 727
 728         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a!/", &opts)) {
 729                 RETURN_FALSE;
 730         }
 731
 732         MAKE_STD_ZVAL(new_opts);
 733         array_init(new_opts);
 734
 735         if (!opts || !zend_hash_num_elements(Z_ARRVAL_P(opts))) {
 736                 zend_update_property(php_http_request_class_entry, getThis(), ZEND_STRL("options"), new_opts TSRMLS_CC);
 737                 zval_ptr_dtor(&new_opts);
 738         } else {
 739                 MAKE_STD_ZVAL(add_opts);
 740                 array_init(add_opts);
 741                 /* some options need extra attention -- thus cannot use array_merge() directly */
 742                 FOREACH_KEYVAL(pos, opts, key, opt) {
 743                         if (key.type == HASH_KEY_IS_STRING) {
 744 #define KEYMATCH(k, s) ((sizeof(s)==k.len) && !strcasecmp(k.str, s))
 745                                 if (KEYMATCH(key, "headers")) {
 746                                         zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "addheaders", NULL, *opt);
 747                                 } else if (KEYMATCH(key, "cookies")) {
 748                                         zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "addcookies", NULL, *opt);
 749                                 } else if (KEYMATCH(key, "ssl")) {
 750                                         zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "addssloptions", NULL, *opt);
 751                                 } else if (KEYMATCH(key, "url") || KEYMATCH(key, "uri")) {
 752                                         zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "seturl", NULL, *opt);
 753                                 } else if (KEYMATCH(key, "method")) {
 754                                         zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "setmethod", NULL, *opt);
 755                                 } else if (KEYMATCH(key, "flushcookies")) {
 756                                         if (i_zend_is_true(*opt)) {
 757                                                 php_http_request_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 758
 759                                                 php_http_request_setopt(obj->request, PHP_HTTP_REQUEST_OPT_COOKIES_FLUSH, NULL);
 760                                         }
 761                                 } else if (KEYMATCH(key, "resetcookies")) {
 762                                         php_http_request_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 763
 764                                         php_http_request_setopt(obj->request, PHP_HTTP_REQUEST_OPT_COOKIES_RESET, NULL);
 765                                 } else if (KEYMATCH(key, "enablecookies")) {
 766                                         php_http_request_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 767
 768                                         php_http_request_setopt(obj->request, PHP_HTTP_REQUEST_OPT_COOKIES_ENABLE, NULL);
 769                                 } else if (KEYMATCH(key, "recordHistory")) {
 770                                         zend_update_property(php_http_request_class_entry, getThis(), ZEND_STRL("recordHistory"), *opt TSRMLS_CC);
 771                                 } else if (KEYMATCH(key, "messageClass")) {
 772                                         zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "setmessageclass", NULL, *opt);
 773                                 } else if (Z_TYPE_PP(opt) == IS_NULL) {
 774                                         old_opts = zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("options"), 0 TSRMLS_CC);
 775                                         if (Z_TYPE_P(old_opts) == IS_ARRAY) {
 776                                                 zend_hash_del(Z_ARRVAL_P(old_opts), key.str, key.len);
 777                                         }
 778                                 } else {
 779                                         Z_ADDREF_P(*opt);
 780                                         add_assoc_zval_ex(add_opts, key.str, key.len, *opt);
 781                                 }
 782                         }
 783                 }
 784
 785                 old_opts = zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("options"), 0 TSRMLS_CC);
 786                 if (Z_TYPE_P(old_opts) == IS_ARRAY) {
 787                         array_copy(Z_ARRVAL_P(old_opts), Z_ARRVAL_P(new_opts));
 788                 }
 789                 array_join(Z_ARRVAL_P(add_opts), Z_ARRVAL_P(new_opts), 0, 0);
 790                 zend_update_property(php_http_request_class_entry, getThis(), ZEND_STRL("options"), new_opts TSRMLS_CC);
 791                 zval_ptr_dtor(&new_opts);
 792                 zval_ptr_dtor(&add_opts);
 793         }
 794
 795         RETVAL_ZVAL(getThis(), 1, 0);
 796 }
 797
 798
 799
 800 PHP_METHOD(HttpRequest, getOptions)
 801 {
 802         if (SUCCESS == zend_parse_parameters_none()) {
 803                 RETURN_PROP(php_http_request_class_entry, "options");
 804         }
 805         RETURN_FALSE;
 806 }
 807
 808 PHP_METHOD(HttpRequest, setSslOptions)
 809 {
 810         php_http_request_object_set_options_subr(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_STRS("ssl"), 1, 0);
 811 }
 812
 813 PHP_METHOD(HttpRequest, addSslOptions)
 814 {
 815         php_http_request_object_set_options_subr(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_STRS("ssl"), 0, 0);
 816 }
 817
 818 PHP_METHOD(HttpRequest, getSslOptions)
 819 {
 820         php_http_request_object_get_options_subr(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_STRS("ssl"));
 821 }
 822
 823 PHP_METHOD(HttpRequest, addHeaders)
 824 {
 825         php_http_request_object_set_options_subr(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_STRS("headers"), 0, 1);
 826 }
 827
 828 PHP_METHOD(HttpRequest, setHeaders)
 829 {
 830         php_http_request_object_set_options_subr(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_STRS("headers"), 1, 1);
 831 }
 832
 833 PHP_METHOD(HttpRequest, getHeaders)
 834 {
 835         php_http_request_object_get_options_subr(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_STRS("headers"));
 836 }
 837
 838 PHP_METHOD(HttpRequest, setCookies)
 839 {
 840         php_http_request_object_set_options_subr(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_STRS("cookies"), 1, 0);
 841 }
 842
 843 PHP_METHOD(HttpRequest, addCookies)
 844 {
 845         php_http_request_object_set_options_subr(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_STRS("cookies"), 0, 0);
 846 }
 847
 848 PHP_METHOD(HttpRequest, getCookies)
 849 {
 850         php_http_request_object_get_options_subr(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_STRS("cookies"));
 851 }
 852
 853 PHP_METHOD(HttpRequest, enableCookies)
 854 {
 855         if (SUCCESS == zend_parse_parameters_none()){
 856                 php_http_request_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 857
 858                 php_http_request_setopt(obj->request, PHP_HTTP_REQUEST_OPT_COOKIES_ENABLE, NULL);
 859         }
 860         RETVAL_ZVAL(getThis(), 1, 0);
 861 }
 862
 863 PHP_METHOD(HttpRequest, resetCookies)
 864 {
 865         zend_bool session_only = 0;
 866
 867         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &session_only)) {
 868                 php_http_request_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 869                 if (session_only) {
 870                         php_http_request_setopt(obj->request, PHP_HTTP_REQUEST_OPT_COOKIES_RESET_SESSION, NULL);
 871                 } else {
 872                         php_http_request_setopt(obj->request, PHP_HTTP_REQUEST_OPT_COOKIES_RESET, NULL);
 873                 }
 874         }
 875         RETVAL_ZVAL(getThis(), 1, 0);
 876 }
 877
 878 PHP_METHOD(HttpRequest, flushCookies)
 879 {
 880         if (SUCCESS == zend_parse_parameters_none()) {
 881                 php_http_request_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
 882
 883                 php_http_request_setopt(obj->request, PHP_HTTP_REQUEST_OPT_COOKIES_FLUSH, NULL);
 884         }
 885         RETVAL_ZVAL(getThis(), 1, 0);
 886 }
 887
 888 PHP_METHOD(HttpRequest, setUrl)
 889 {
 890         char *url_str = NULL;
 891         int url_len;
 892
 893         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &url_str, &url_len)) {
 894                 zend_update_property_stringl(php_http_request_class_entry, getThis(), ZEND_STRL("url"), url_str, url_len TSRMLS_CC);
 895         }
 896         RETVAL_ZVAL(getThis(), 1, 0);
 897 }
 898
 899 PHP_METHOD(HttpRequest, getUrl)
 900 {
 901         if (SUCCESS == zend_parse_parameters_none()) {
 902                 RETURN_PROP(php_http_request_class_entry, "url");
 903         }
 904         RETURN_FALSE;
 905 }
 906
 907 PHP_METHOD(HttpRequest, setMethod)
 908 {
 909         long meth;
 910
 911         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &meth)) {
 912                 zend_update_property_long(php_http_request_class_entry, getThis(), ZEND_STRL("method"), meth TSRMLS_CC);
 913         }
 914         RETVAL_ZVAL(getThis(), 1, 0);
 915 }
 916
 917 PHP_METHOD(HttpRequest, getMethod)
 918 {
 919         if (SUCCESS == zend_parse_parameters_none()) {
 920                 RETURN_PROP(php_http_request_class_entry, "method");
 921         }
 922         RETURN_FALSE;
 923 }
 924
 925 PHP_METHOD(HttpRequest, setContentType)
 926 {
 927         char *ctype;
 928         int ct_len;
 929
 930         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &ctype, &ct_len)) {
 931                 int invalid = 0;
 932
 933                 if (ct_len) {
 934                         PHP_HTTP_CHECK_CONTENT_TYPE(ctype, invalid = 1);
 935                 }
 936
 937                 if (!invalid) {
 938                         zend_update_property_stringl(php_http_request_class_entry, getThis(), ZEND_STRL("contentType"), ctype, ct_len TSRMLS_CC);
 939                 }
 940         }
 941         RETVAL_ZVAL(getThis(), 1, 0);
 942 }
 943
 944 PHP_METHOD(HttpRequest, getContentType)
 945 {
 946         if (SUCCESS == zend_parse_parameters_none()) {
 947                 RETURN_PROP(php_http_request_class_entry, "contentType");
 948         }
 949         RETURN_FALSE;
 950 }
 951
 952 PHP_METHOD(HttpRequest, setQueryData)
 953 {
 954         zval *qdata = NULL;
 955
 956         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z!", &qdata)) {
 957                 if ((!qdata) || Z_TYPE_P(qdata) == IS_NULL) {
 958                         zend_update_property_stringl(php_http_request_class_entry, getThis(), ZEND_STRL("queryData"), "", 0 TSRMLS_CC);
 959                 } else if ((Z_TYPE_P(qdata) == IS_ARRAY) || (Z_TYPE_P(qdata) == IS_OBJECT)) {
 960                         char *query_data_str = NULL;
 961                         size_t query_data_len;
 962
 963                         if (SUCCESS == php_http_url_encode_hash(HASH_OF(qdata), 0, NULL, 0, &query_data_str, &query_data_len TSRMLS_CC)) {
 964                                 zend_update_property_stringl(php_http_request_class_entry, getThis(), ZEND_STRL("queryData"), query_data_str, query_data_len TSRMLS_CC);
 965                                 efree(query_data_str);
 966                         }
 967                 } else {
 968                         zval *data = php_http_zsep(IS_STRING, qdata);
 969
 970                         zend_update_property_stringl(php_http_request_class_entry, getThis(), ZEND_STRL("queryData"), Z_STRVAL_P(data), Z_STRLEN_P(data) TSRMLS_CC);
 971                         zval_ptr_dtor(&data);
 972                 }
 973         }
 974         RETVAL_ZVAL(getThis(), 1, 0);
 975 }
 976
 977 PHP_METHOD(HttpRequest, getQueryData)
 978 {
 979         if (SUCCESS == zend_parse_parameters_none()) {
 980                 RETURN_PROP(php_http_request_class_entry, "queryData");
 981         }
 982         RETURN_FALSE;
 983 }
 984
 985 PHP_METHOD(HttpRequest, addQueryData)
 986 {
 987         zval *qdata;
 988
 989         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/", &qdata)) {
 990                 char *query_data_str = NULL;
 991                 size_t query_data_len = 0;
 992                 zval *old_qdata = zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("queryData"), 0 TSRMLS_CC);
 993
 994                 if (SUCCESS == php_http_url_encode_hash(HASH_OF(qdata), 1, Z_STRVAL_P(old_qdata), Z_STRLEN_P(old_qdata), &query_data_str, &query_data_len TSRMLS_CC)) {
 995                         zend_update_property_stringl(php_http_request_class_entry, getThis(), ZEND_STRL("queryData"), query_data_str, query_data_len TSRMLS_CC);
 996                         efree(query_data_str);
 997                 }
 998         }
 999         RETVAL_ZVAL(getThis(), 1, 0);
1000
1001 }
1002
1003 PHP_METHOD(HttpRequest, setBody)
1004 {
1005         zval *body = NULL;
1006
1007         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|O!", &body, php_http_message_body_class_entry)) {
1008                 if (body && Z_TYPE_P(body) != IS_NULL) {
1009                         zend_update_property(php_http_request_class_entry, getThis(), ZEND_STRL("requestBody"), body TSRMLS_CC);
1010                 } else {
1011                         zend_update_property_null(php_http_request_class_entry, getThis(), ZEND_STRL("requestBody") TSRMLS_CC);
1012                 }
1013         }
1014         RETVAL_ZVAL(getThis(), 1, 0);
1015 }
1016
1017 PHP_METHOD(HttpRequest, addBody)
1018 {
1019         zval *new_body;
1020
1021         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &new_body, php_http_message_body_class_entry)) {
1022                 zval *old_body = zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("requestBody"), 0 TSRMLS_CC);
1023
1024                 if (Z_TYPE_P(old_body) == IS_OBJECT) {
1025                         php_http_message_body_object_t *old_obj = zend_object_store_get_object(old_body TSRMLS_CC);
1026                         php_http_message_body_object_t *new_obj = zend_object_store_get_object(new_body TSRMLS_CC);
1027
1028                         php_http_message_body_to_callback(old_obj->body, (php_http_pass_callback_t) php_http_message_body_append, new_obj->body, 0, 0);
1029                 } else {
1030                         zend_update_property(php_http_request_class_entry, getThis(), ZEND_STRL("requestBody"), new_body TSRMLS_CC);
1031                 }
1032         }
1033         RETVAL_ZVAL(getThis(), 1, 0);
1034 }
1035
1036 PHP_METHOD(HttpRequest, getBody)
1037 {
1038         if (SUCCESS == zend_parse_parameters_none()) {
1039                 RETURN_PROP(php_http_request_class_entry, "requestBody");
1040         }
1041         RETURN_FALSE;
1042 }
1043
1044 PHP_METHOD(HttpRequest, getResponseHeader)
1045 {
1046         zval *header;
1047         char *header_name = NULL;
1048         int header_len = 0;
1049
1050         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &header_name, &header_len)) {
1051                 zval *message = zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("responseMessage"), 0 TSRMLS_CC);
1052
1053                 if (Z_TYPE_P(message) == IS_OBJECT) {
1054                         php_http_message_object_t *msg = zend_object_store_get_object(message TSRMLS_CC);
1055
1056                         if (header_len) {
1057                                 if ((header = php_http_message_header(msg->message, header_name, header_len + 1, 0))) {
1058                                         RETURN_ZVAL(header, 1, 1);
1059                                 }
1060                         } else {
1061                                 array_init(return_value);
1062                                 zend_hash_copy(Z_ARRVAL_P(return_value), &msg->message->hdrs, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
1063                                 return;
1064                         }
1065                 }
1066         }
1067         RETURN_FALSE;
1068 }
1069
1070 PHP_METHOD(HttpRequest, getResponseCookies)
1071 {
1072         long flags = 0;
1073         zval *allowed_extras_array = NULL;
1074
1075         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|la!", &flags, &allowed_extras_array)) {
1076                 int i = 0;
1077                 php_http_array_hashkey_t key = php_http_array_hashkey_init(0);
1078                 char **allowed_extras = NULL;
1079                 zval **header = NULL, **entry = NULL, *message = zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("responseMessage"), 0 TSRMLS_CC);
1080                 HashPosition pos, pos1, pos2;
1081
1082                 if (Z_TYPE_P(message) == IS_OBJECT) {
1083                         php_http_message_object_t *msg = zend_object_store_get_object(message TSRMLS_CC);
1084
1085                         array_init(return_value);
1086
1087                         if (allowed_extras_array) {
1088                                 allowed_extras = ecalloc(zend_hash_num_elements(Z_ARRVAL_P(allowed_extras_array)) + 1, sizeof(char *));
1089                                 FOREACH_VAL(pos, allowed_extras_array, entry) {
1090                                         zval *data = php_http_zsep(IS_STRING, *entry);
1091                                         allowed_extras[i++] = estrndup(Z_STRVAL_P(data), Z_STRLEN_P(data));
1092                                         zval_ptr_dtor(&data);
1093                                 }
1094                         }
1095
1096                         FOREACH_HASH_KEYVAL(pos1, &msg->message->hdrs, key, header) {
1097                                 if (key.type == HASH_KEY_IS_STRING && !strcasecmp(key.str, "Set-Cookie")) {
1098                                         php_http_cookie_list_t *list;
1099
1100                                         if (Z_TYPE_PP(header) == IS_ARRAY) {
1101                                                 zval **single_header;
1102
1103                                                 FOREACH_VAL(pos2, *header, single_header) {
1104                                                         zval *data = php_http_zsep(IS_STRING, *single_header);
1105
1106                                                         if ((list = php_http_cookie_list_parse(NULL, Z_STRVAL_P(data), flags, allowed_extras TSRMLS_CC))) {
1107                                                                 zval *cookie;
1108
1109                                                                 MAKE_STD_ZVAL(cookie);
1110                                                                 ZVAL_OBJVAL(cookie, php_http_cookie_object_new_ex(php_http_cookie_class_entry, list, NULL TSRMLS_CC), 0);
1111                                                                 add_next_index_zval(return_value, cookie);
1112                                                         }
1113                                                         zval_ptr_dtor(&data);
1114                                                 }
1115                                         } else {
1116                                                 zval *data = php_http_zsep(IS_STRING, *header);
1117                                                 if ((list = php_http_cookie_list_parse(NULL, Z_STRVAL_P(data), flags, allowed_extras TSRMLS_CC))) {
1118                                                         zval *cookie;
1119
1120                                                         MAKE_STD_ZVAL(cookie);
1121                                                         ZVAL_OBJVAL(cookie, php_http_cookie_object_new_ex(php_http_cookie_class_entry, list, NULL TSRMLS_CC), 0);
1122                                                         add_next_index_zval(return_value, cookie);
1123                                                 }
1124                                                 zval_ptr_dtor(&data);
1125                                         }
1126                                 }
1127                         }
1128
1129                         if (allowed_extras) {
1130                                 for (i = 0; allowed_extras[i]; ++i) {
1131                                         efree(allowed_extras[i]);
1132                                 }
1133                                 efree(allowed_extras);
1134                         }
1135
1136                         return;
1137                 }
1138         }
1139         RETURN_FALSE;
1140 }
1141
1142 PHP_METHOD(HttpRequest, getResponseBody)
1143 {
1144         if (SUCCESS == zend_parse_parameters_none()) {
1145                 zval *message = zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("responseMessage"), 0 TSRMLS_CC);
1146
1147                 RETURN_OBJVAL(((php_http_message_object_t *)zend_object_store_get_object(message TSRMLS_CC))->body, 1);
1148         }
1149         RETURN_FALSE;
1150 }
1151
1152 PHP_METHOD(HttpRequest, getResponseCode)
1153 {
1154         if (SUCCESS == zend_parse_parameters_none()) {
1155                 RETURN_PROP(php_http_request_class_entry, "responseCode");
1156         }
1157         RETURN_FALSE;
1158 }
1159
1160 PHP_METHOD(HttpRequest, getResponseStatus)
1161 {
1162         if (SUCCESS == zend_parse_parameters_none()) {
1163                 RETURN_PROP(php_http_request_class_entry, "responseStatus");
1164         }
1165         RETURN_FALSE;
1166 }
1167
1168 PHP_METHOD(HttpRequest, getResponseMessage)
1169 {
1170         with_error_handling(EH_THROW, PHP_HTTP_EX_CE(runtime)) {
1171                 if (SUCCESS == zend_parse_parameters_none()) {
1172                         zval *message = zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("responseMessage"), 0 TSRMLS_CC);
1173
1174                         if (Z_TYPE_P(message) == IS_OBJECT) {
1175                                 RETVAL_OBJECT(message, 1);
1176                         } else {
1177                                 php_http_error(HE_WARNING, PHP_HTTP_E_RUNTIME, "HttpRequest does not contain a response message");
1178                         }
1179                 }
1180         } end_error_handling();
1181 }
1182
1183 PHP_METHOD(HttpRequest, getRequestMessage)
1184 {
1185         with_error_handling(EH_THROW, PHP_HTTP_EX_CE(runtime)) {
1186                 if (SUCCESS == zend_parse_parameters_none()) {
1187                         zval *message = zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("requestMessage"), 0 TSRMLS_CC);
1188
1189                         if (Z_TYPE_P(message) == IS_OBJECT) {
1190                                 RETVAL_OBJECT(message, 1);
1191                         } else {
1192                                 php_http_error(HE_WARNING, PHP_HTTP_E_RUNTIME, "HttpRequest does not contain a request message");
1193                         }
1194                 }
1195         } end_error_handling();
1196 }
1197
1198 PHP_METHOD(HttpRequest, getHistory)
1199 {
1200         with_error_handling(EH_THROW, PHP_HTTP_EX_CE(runtime)) {
1201                 if (SUCCESS == zend_parse_parameters_none()) {
1202                         zval *hist = zend_read_property(php_http_request_class_entry, getThis(), ZEND_STRL("history"), 0 TSRMLS_CC);
1203
1204                         if (Z_TYPE_P(hist) == IS_OBJECT) {
1205                                 RETVAL_OBJECT(hist, 1);
1206                         } else {
1207                                 php_http_error(HE_WARNING, PHP_HTTP_E_RUNTIME, "The history is empty");
1208                         }
1209                 }
1210         } end_error_handling();
1211 }
1212
1213 PHP_METHOD(HttpRequest, clearHistory)
1214 {
1215         if (SUCCESS == zend_parse_parameters_none()) {
1216                 zend_update_property_null(php_http_request_class_entry, getThis(), ZEND_STRL("history") TSRMLS_CC);
1217         }
1218         RETVAL_ZVAL(getThis(), 1, 0);
1219 }
1220
1221 PHP_METHOD(HttpRequest, getMessageClass)
1222 {
1223         if (SUCCESS == zend_parse_parameters_none()) {
1224                 RETURN_PROP(php_http_request_class_entry, "messageClass");
1225         }
1226         RETURN_FALSE;
1227 }
1228
1229 PHP_METHOD(HttpRequest, setMessageClass)
1230 {
1231         char *cn;
1232         int cl;
1233
1234         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &cn, &cl)) {
1235                 zend_update_property_stringl(php_http_request_class_entry, getThis(), ZEND_STRL("messageClass"), cn, cl TSRMLS_CC);
1236         }
1237         RETVAL_ZVAL(getThis(), 1, 0);
1238 }
1239
1240 PHP_METHOD(HttpRequest, send)
1241 {
1242         RETVAL_FALSE;
1243
1244         with_error_handling(EH_THROW, PHP_HTTP_EX_CE(runtime)) {
1245                 if (SUCCESS == zend_parse_parameters_none()) {
1246                         php_http_request_object_t *obj = zend_object_store_get_object(getThis() TSRMLS_CC);
1247                         php_http_request_method_t meth = PHP_HTTP_NO_REQUEST_METHOD;
1248                         php_http_message_body_t *body = NULL;
1249                         char *url = NULL;
1250
1251                         if (SUCCESS == php_http_request_object_requesthandler(obj, getThis(), &meth, &url, &body TSRMLS_CC)) {
1252                                 php_http_request_exec(obj->request, meth, url, body);
1253                                 if (SUCCESS == php_http_request_object_responsehandler(obj, getThis() TSRMLS_CC)) {
1254                                         RETVAL_PROP(php_http_request_class_entry, "responseMessage");
1255                                 } else {
1256                                         php_http_error(HE_WARNING, PHP_HTTP_E_REQUEST, "Failed to handle response");
1257                                 }
1258                         } else {
1259                                 php_http_error(HE_WARNING, PHP_HTTP_E_REQUEST, "Failed to handle request");
1260                         }
1261
1262                         STR_FREE(url);
1263                 }
1264         } end_error_handling();
1265 }
1266
1267 PHP_MINIT_FUNCTION(http_request)
1268 {
1269         PHP_HTTP_REGISTER_CLASS(http, Request, http_request, php_http_object_class_entry, 0);
1270         php_http_request_class_entry->create_object = php_http_request_object_new;
1271         memcpy(&php_http_request_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
1272         php_http_request_object_handlers.clone_obj = php_http_request_object_clone;
1273
1274         zend_class_implements(php_http_request_class_entry TSRMLS_CC, 2, spl_ce_SplSubject, php_http_fluently_callable_class_entry);
1275
1276         zend_declare_property_null(php_http_request_class_entry, ZEND_STRL("observers"), ZEND_ACC_PRIVATE TSRMLS_CC);
1277         zend_declare_property_null(php_http_request_class_entry, ZEND_STRL("options"), ZEND_ACC_PRIVATE TSRMLS_CC);
1278         zend_declare_property_null(php_http_request_class_entry, ZEND_STRL("transferInfo"), ZEND_ACC_PRIVATE TSRMLS_CC);
1279         zend_declare_property_null(php_http_request_class_entry, ZEND_STRL("responseMessage"), ZEND_ACC_PRIVATE TSRMLS_CC);
1280         zend_declare_property_long(php_http_request_class_entry, ZEND_STRL("responseCode"), 0, ZEND_ACC_PRIVATE TSRMLS_CC);
1281         zend_declare_property_string(php_http_request_class_entry, ZEND_STRL("responseStatus"), "", ZEND_ACC_PRIVATE TSRMLS_CC);
1282         zend_declare_property_null(php_http_request_class_entry, ZEND_STRL("requestMessage"), ZEND_ACC_PRIVATE TSRMLS_CC);
1283         zend_declare_property_long(php_http_request_class_entry, ZEND_STRL("method"), PHP_HTTP_GET, ZEND_ACC_PRIVATE TSRMLS_CC);
1284         zend_declare_property_string(php_http_request_class_entry, ZEND_STRL("url"), "", ZEND_ACC_PRIVATE TSRMLS_CC);
1285         zend_declare_property_string(php_http_request_class_entry, ZEND_STRL("contentType"), "", ZEND_ACC_PRIVATE TSRMLS_CC);
1286         zend_declare_property_string(php_http_request_class_entry, ZEND_STRL("requestBody"), "", ZEND_ACC_PRIVATE TSRMLS_CC);
1287         zend_declare_property_string(php_http_request_class_entry, ZEND_STRL("queryData"), "", ZEND_ACC_PRIVATE TSRMLS_CC);
1288         zend_declare_property_null(php_http_request_class_entry, ZEND_STRL("history"), ZEND_ACC_PRIVATE TSRMLS_CC);
1289         zend_declare_property_bool(php_http_request_class_entry, ZEND_STRL("recordHistory"), 0, ZEND_ACC_PUBLIC TSRMLS_CC);
1290         zend_declare_property_string(php_http_request_class_entry, ZEND_STRL("messageClass"), "", ZEND_ACC_PRIVATE TSRMLS_CC);
1291
1292         return SUCCESS;
1293 }
1294
1295 /*
1296  * Local variables:
1297  * tab-width: 4
1298  * c-basic-offset: 4
1299  * End:
1300  * vim600: noet sw=4 ts=4 fdm=marker
1301  * vim<600: noet sw=4 ts=4
1302  */
1303