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