git.m6w6.name Git - m6w6/ext-http/blob - http_request_object.c

   1 /*
   2     +--------------------------------------------------------------------+
   3     | PECL :: http                                                       |
   4     +--------------------------------------------------------------------+
   5     | Redistribution and use in source and binary forms, with or without |
   6     | modification, are permitted provided that the conditions mentioned |
   7     | in the accompanying LICENSE file are met.                          |
   8     +--------------------------------------------------------------------+
   9     | Copyright (c) 2004-2007, Michael Wallner <mike@php.net>            |
  10     +--------------------------------------------------------------------+
  11 */
  12
  13 /* $Id$ */
  14
  15 #define HTTP_WANT_CURL
  16 #include "php_http.h"
  17
  18 #if defined(ZEND_ENGINE_2) && defined(HTTP_HAVE_CURL)
  19
  20 #include "zend_interfaces.h"
  21
  22 #include "php_http_api.h"
  23 #include "php_http_cookie_api.h"
  24 #include "php_http_exception_object.h"
  25 #include "php_http_message_api.h"
  26 #include "php_http_message_object.h"
  27 #include "php_http_request_api.h"
  28 #include "php_http_request_object.h"
  29 #include "php_http_request_pool_api.h"
  30 #include "php_http_url_api.h"
  31
  32 #define HTTP_BEGIN_ARGS(method, req_args)       HTTP_BEGIN_ARGS_EX(HttpRequest, method, 0, req_args)
  33 #define HTTP_EMPTY_ARGS(method)                         HTTP_EMPTY_ARGS_EX(HttpRequest, method, 0)
  34 #define HTTP_REQUEST_ME(method, visibility)     PHP_ME(HttpRequest, method, HTTP_ARGS(HttpRequest, method), visibility)
  35 #define HTTP_REQUEST_ALIAS(method, func)        HTTP_STATIC_ME_ALIAS(method, func, HTTP_ARGS(HttpRequest, method))
  36 #define HTTP_REQUEST_MALIAS(me, al, vis)        ZEND_FENTRY(me, ZEND_MN(HttpRequest_##al), HTTP_ARGS(HttpRequest, al), vis)
  37
  38 HTTP_BEGIN_ARGS(__construct, 0)
  39         HTTP_ARG_VAL(url, 0)
  40         HTTP_ARG_VAL(method, 0)
  41         HTTP_ARG_VAL(options, 0)
  42 HTTP_END_ARGS;
  43
  44 HTTP_BEGIN_ARGS(factory, 0)
  45         HTTP_ARG_VAL(url, 0)
  46         HTTP_ARG_VAL(method, 0)
  47         HTTP_ARG_VAL(options, 0)
  48         HTTP_ARG_VAL(class_name, 0)
  49 HTTP_END_ARGS;
  50
  51 HTTP_EMPTY_ARGS(getOptions);
  52 HTTP_BEGIN_ARGS(setOptions, 0)
  53         HTTP_ARG_VAL(options, 0)
  54 HTTP_END_ARGS;
  55
  56 HTTP_EMPTY_ARGS(getSslOptions);
  57 HTTP_BEGIN_ARGS(setSslOptions, 0)
  58         HTTP_ARG_VAL(ssl_options, 0)
  59 HTTP_END_ARGS;
  60
  61 HTTP_BEGIN_ARGS(addSslOptions, 0)
  62         HTTP_ARG_VAL(ssl_optins, 0)
  63 HTTP_END_ARGS;
  64
  65 HTTP_EMPTY_ARGS(getHeaders);
  66 HTTP_BEGIN_ARGS(setHeaders, 0)
  67         HTTP_ARG_VAL(headers, 0)
  68 HTTP_END_ARGS;
  69
  70 HTTP_BEGIN_ARGS(addHeaders, 1)
  71         HTTP_ARG_VAL(headers, 0)
  72 HTTP_END_ARGS;
  73
  74 HTTP_EMPTY_ARGS(getCookies);
  75 HTTP_BEGIN_ARGS(setCookies, 0)
  76         HTTP_ARG_VAL(cookies, 0)
  77 HTTP_END_ARGS;
  78
  79 HTTP_BEGIN_ARGS(addCookies, 1)
  80         HTTP_ARG_VAL(cookies, 0)
  81 HTTP_END_ARGS;
  82
  83 HTTP_EMPTY_ARGS(enableCookies);
  84 HTTP_BEGIN_ARGS(resetCookies, 0)
  85         HTTP_ARG_VAL(session_only, 0)
  86 HTTP_END_ARGS;
  87 HTTP_EMPTY_ARGS(flushCookies);
  88
  89 HTTP_EMPTY_ARGS(getUrl);
  90 HTTP_BEGIN_ARGS(setUrl, 1)
  91         HTTP_ARG_VAL(url, 0)
  92 HTTP_END_ARGS;
  93
  94 HTTP_EMPTY_ARGS(getMethod);
  95 HTTP_BEGIN_ARGS(setMethod, 1)
  96         HTTP_ARG_VAL(request_method, 0)
  97 HTTP_END_ARGS;
  98
  99 HTTP_EMPTY_ARGS(getContentType);
 100 HTTP_BEGIN_ARGS(setContentType, 1)
 101         HTTP_ARG_VAL(content_type, 0)
 102 HTTP_END_ARGS;
 103
 104 HTTP_EMPTY_ARGS(getQueryData);
 105 HTTP_BEGIN_ARGS(setQueryData, 0)
 106         HTTP_ARG_VAL(query_data, 0)
 107 HTTP_END_ARGS;
 108
 109 HTTP_BEGIN_ARGS(addQueryData, 1)
 110         HTTP_ARG_VAL(query_data, 0)
 111 HTTP_END_ARGS;
 112
 113 HTTP_EMPTY_ARGS(getPostFields);
 114 HTTP_BEGIN_ARGS(setPostFields, 0)
 115         HTTP_ARG_VAL(post_fields, 0)
 116 HTTP_END_ARGS;
 117
 118 HTTP_BEGIN_ARGS(addPostFields, 1)
 119         HTTP_ARG_VAL(post_fields, 0)
 120 HTTP_END_ARGS;
 121
 122 HTTP_EMPTY_ARGS(getPostFiles);
 123 HTTP_BEGIN_ARGS(setPostFiles, 0)
 124         HTTP_ARG_VAL(post_files, 0)
 125 HTTP_END_ARGS;
 126
 127 HTTP_BEGIN_ARGS(addPostFile, 2)
 128         HTTP_ARG_VAL(formname, 0)
 129         HTTP_ARG_VAL(filename, 0)
 130         HTTP_ARG_VAL(content_type, 0)
 131 HTTP_END_ARGS;
 132
 133 HTTP_EMPTY_ARGS(getBody);
 134 HTTP_BEGIN_ARGS(setBody, 0)
 135         HTTP_ARG_VAL(request_body_data, 0)
 136 HTTP_END_ARGS;
 137
 138 HTTP_BEGIN_ARGS(addBody, 1)
 139         HTTP_ARG_VAL(request_body_data, 0)
 140 HTTP_END_ARGS;
 141
 142 HTTP_EMPTY_ARGS(getPutFile);
 143 HTTP_BEGIN_ARGS(setPutFile, 0)
 144         HTTP_ARG_VAL(filename, 0)
 145 HTTP_END_ARGS;
 146
 147 HTTP_EMPTY_ARGS(getPutData);
 148 HTTP_BEGIN_ARGS(setPutData, 0)
 149         HTTP_ARG_VAL(put_data, 0)
 150 HTTP_END_ARGS;
 151
 152 HTTP_BEGIN_ARGS(addPutData, 1)
 153         HTTP_ARG_VAL(put_data, 0)
 154 HTTP_END_ARGS;
 155
 156 HTTP_EMPTY_ARGS(getResponseData);
 157 HTTP_BEGIN_ARGS(getResponseHeader, 0)
 158         HTTP_ARG_VAL(name, 0)
 159 HTTP_END_ARGS;
 160
 161 HTTP_BEGIN_ARGS(getResponseCookies, 0)
 162         HTTP_ARG_VAL(flags, 0)
 163         HTTP_ARG_VAL(allowed_extras, 0)
 164 HTTP_END_ARGS;
 165
 166 HTTP_EMPTY_ARGS(getResponseBody);
 167 HTTP_EMPTY_ARGS(getResponseCode);
 168 HTTP_EMPTY_ARGS(getResponseStatus);
 169 HTTP_BEGIN_ARGS(getResponseInfo, 0)
 170         HTTP_ARG_VAL(name, 0)
 171 HTTP_END_ARGS;
 172
 173 HTTP_EMPTY_ARGS(getResponseMessage);
 174 HTTP_EMPTY_ARGS(getRawResponseMessage);
 175 HTTP_EMPTY_ARGS(getRequestMessage);
 176 HTTP_EMPTY_ARGS(getRawRequestMessage);
 177 HTTP_EMPTY_ARGS(getHistory);
 178 HTTP_EMPTY_ARGS(clearHistory);
 179 HTTP_EMPTY_ARGS(send);
 180
 181 HTTP_BEGIN_ARGS(get, 1)
 182         HTTP_ARG_VAL(url, 0)
 183         HTTP_ARG_VAL(options, 0)
 184         HTTP_ARG_VAL(info, 1)
 185 HTTP_END_ARGS;
 186
 187 HTTP_BEGIN_ARGS(head, 1)
 188         HTTP_ARG_VAL(url, 0)
 189         HTTP_ARG_VAL(options, 0)
 190         HTTP_ARG_VAL(info, 1)
 191 HTTP_END_ARGS;
 192
 193 HTTP_BEGIN_ARGS(postData, 2)
 194         HTTP_ARG_VAL(url, 0)
 195         HTTP_ARG_VAL(data, 0)
 196         HTTP_ARG_VAL(options, 0)
 197         HTTP_ARG_VAL(info, 1)
 198 HTTP_END_ARGS;
 199
 200 HTTP_BEGIN_ARGS(postFields, 2)
 201         HTTP_ARG_VAL(url, 0)
 202         HTTP_ARG_VAL(data, 0)
 203         HTTP_ARG_VAL(options, 0)
 204         HTTP_ARG_VAL(info, 1)
 205 HTTP_END_ARGS;
 206
 207 HTTP_BEGIN_ARGS(putData, 2)
 208         HTTP_ARG_VAL(url, 0)
 209         HTTP_ARG_VAL(data, 0)
 210         HTTP_ARG_VAL(options, 0)
 211         HTTP_ARG_VAL(info, 1)
 212 HTTP_END_ARGS;
 213
 214 HTTP_BEGIN_ARGS(putFile, 2)
 215         HTTP_ARG_VAL(url, 0)
 216         HTTP_ARG_VAL(file, 0)
 217         HTTP_ARG_VAL(options, 0)
 218         HTTP_ARG_VAL(info, 1)
 219 HTTP_END_ARGS;
 220
 221 HTTP_BEGIN_ARGS(putStream, 2)
 222         HTTP_ARG_VAL(url, 0)
 223         HTTP_ARG_VAL(stream, 0)
 224         HTTP_ARG_VAL(options, 0)
 225         HTTP_ARG_VAL(info, 1)
 226 HTTP_END_ARGS;
 227
 228 HTTP_BEGIN_ARGS(methodRegister, 1)
 229         HTTP_ARG_VAL(method_name, 0)
 230 HTTP_END_ARGS;
 231
 232 HTTP_BEGIN_ARGS(methodUnregister, 1)
 233         HTTP_ARG_VAL(method, 0)
 234 HTTP_END_ARGS;
 235
 236 HTTP_BEGIN_ARGS(methodName, 1)
 237         HTTP_ARG_VAL(method_id, 0)
 238 HTTP_END_ARGS;
 239
 240 HTTP_BEGIN_ARGS(methodExists, 1)
 241         HTTP_ARG_VAL(method, 0)
 242 HTTP_END_ARGS;
 243
 244 #ifdef HAVE_CURL_FORMGET
 245 HTTP_BEGIN_ARGS(encodeBody, 2)
 246         HTTP_ARG_VAL(fields, 0)
 247         HTTP_ARG_VAL(files, 0)
 248 HTTP_END_ARGS;
 249 #endif
 250
 251 #define THIS_CE http_request_object_ce
 252 zend_class_entry *http_request_object_ce;
 253 zend_function_entry http_request_object_fe[] = {
 254         HTTP_REQUEST_ME(__construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
 255
 256         HTTP_REQUEST_ME(setOptions, ZEND_ACC_PUBLIC)
 257         HTTP_REQUEST_ME(getOptions, ZEND_ACC_PUBLIC)
 258         HTTP_REQUEST_ME(setSslOptions, ZEND_ACC_PUBLIC)
 259         HTTP_REQUEST_ME(getSslOptions, ZEND_ACC_PUBLIC)
 260         HTTP_REQUEST_ME(addSslOptions, ZEND_ACC_PUBLIC)
 261
 262         HTTP_REQUEST_ME(addHeaders, ZEND_ACC_PUBLIC)
 263         HTTP_REQUEST_ME(getHeaders, ZEND_ACC_PUBLIC)
 264         HTTP_REQUEST_ME(setHeaders, ZEND_ACC_PUBLIC)
 265
 266         HTTP_REQUEST_ME(addCookies, ZEND_ACC_PUBLIC)
 267         HTTP_REQUEST_ME(getCookies, ZEND_ACC_PUBLIC)
 268         HTTP_REQUEST_ME(setCookies, ZEND_ACC_PUBLIC)
 269
 270         HTTP_REQUEST_ME(enableCookies, ZEND_ACC_PUBLIC)
 271         HTTP_REQUEST_ME(resetCookies, ZEND_ACC_PUBLIC)
 272         HTTP_REQUEST_ME(flushCookies, ZEND_ACC_PUBLIC)
 273
 274         HTTP_REQUEST_ME(setMethod, ZEND_ACC_PUBLIC)
 275         HTTP_REQUEST_ME(getMethod, ZEND_ACC_PUBLIC)
 276
 277         HTTP_REQUEST_ME(setUrl, ZEND_ACC_PUBLIC)
 278         HTTP_REQUEST_ME(getUrl, ZEND_ACC_PUBLIC)
 279
 280         HTTP_REQUEST_ME(setContentType, ZEND_ACC_PUBLIC)
 281         HTTP_REQUEST_ME(getContentType, ZEND_ACC_PUBLIC)
 282
 283         HTTP_REQUEST_ME(setQueryData, ZEND_ACC_PUBLIC)
 284         HTTP_REQUEST_ME(getQueryData, ZEND_ACC_PUBLIC)
 285         HTTP_REQUEST_ME(addQueryData, ZEND_ACC_PUBLIC)
 286
 287         HTTP_REQUEST_ME(setPostFields, ZEND_ACC_PUBLIC)
 288         HTTP_REQUEST_ME(getPostFields, ZEND_ACC_PUBLIC)
 289         HTTP_REQUEST_ME(addPostFields, ZEND_ACC_PUBLIC)
 290
 291         HTTP_REQUEST_ME(setBody, ZEND_ACC_PUBLIC)
 292         HTTP_REQUEST_ME(getBody, ZEND_ACC_PUBLIC)
 293         HTTP_REQUEST_ME(addBody, ZEND_ACC_PUBLIC)
 294         HTTP_REQUEST_MALIAS(setRawPostData, setBody, ZEND_ACC_PUBLIC|ZEND_ACC_DEPRECATED)
 295         HTTP_REQUEST_MALIAS(getRawPostData, getBody, ZEND_ACC_PUBLIC|ZEND_ACC_DEPRECATED)
 296         HTTP_REQUEST_MALIAS(addRawPostData, addBody, ZEND_ACC_PUBLIC|ZEND_ACC_DEPRECATED)
 297
 298         HTTP_REQUEST_ME(setPostFiles, ZEND_ACC_PUBLIC)
 299         HTTP_REQUEST_ME(addPostFile, ZEND_ACC_PUBLIC)
 300         HTTP_REQUEST_ME(getPostFiles, ZEND_ACC_PUBLIC)
 301
 302         HTTP_REQUEST_ME(setPutFile, ZEND_ACC_PUBLIC)
 303         HTTP_REQUEST_ME(getPutFile, ZEND_ACC_PUBLIC)
 304
 305         HTTP_REQUEST_ME(setPutData, ZEND_ACC_PUBLIC)
 306         HTTP_REQUEST_ME(getPutData, ZEND_ACC_PUBLIC)
 307         HTTP_REQUEST_ME(addPutData, ZEND_ACC_PUBLIC)
 308
 309         HTTP_REQUEST_ME(send, ZEND_ACC_PUBLIC)
 310
 311         HTTP_REQUEST_ME(getResponseData, ZEND_ACC_PUBLIC)
 312         HTTP_REQUEST_ME(getResponseHeader, ZEND_ACC_PUBLIC)
 313         HTTP_REQUEST_ME(getResponseCookies, ZEND_ACC_PUBLIC)
 314         HTTP_REQUEST_ME(getResponseCode, ZEND_ACC_PUBLIC)
 315         HTTP_REQUEST_ME(getResponseStatus, ZEND_ACC_PUBLIC)
 316         HTTP_REQUEST_ME(getResponseBody, ZEND_ACC_PUBLIC)
 317         HTTP_REQUEST_ME(getResponseInfo, ZEND_ACC_PUBLIC)
 318         HTTP_REQUEST_ME(getResponseMessage, ZEND_ACC_PUBLIC)
 319         HTTP_REQUEST_ME(getRawResponseMessage, ZEND_ACC_PUBLIC)
 320         HTTP_REQUEST_ME(getRequestMessage, ZEND_ACC_PUBLIC)
 321         HTTP_REQUEST_ME(getRawRequestMessage, ZEND_ACC_PUBLIC)
 322         HTTP_REQUEST_ME(getHistory, ZEND_ACC_PUBLIC)
 323         HTTP_REQUEST_ME(clearHistory, ZEND_ACC_PUBLIC)
 324
 325         HTTP_REQUEST_ME(factory, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 326
 327         HTTP_REQUEST_ALIAS(get, http_get)
 328         HTTP_REQUEST_ALIAS(head, http_head)
 329         HTTP_REQUEST_ALIAS(postData, http_post_data)
 330         HTTP_REQUEST_ALIAS(postFields, http_post_fields)
 331         HTTP_REQUEST_ALIAS(putData, http_put_data)
 332         HTTP_REQUEST_ALIAS(putFile, http_put_file)
 333         HTTP_REQUEST_ALIAS(putStream, http_put_stream)
 334
 335         HTTP_REQUEST_ALIAS(methodRegister, http_request_method_register)
 336         HTTP_REQUEST_ALIAS(methodUnregister, http_request_method_unregister)
 337         HTTP_REQUEST_ALIAS(methodName, http_request_method_name)
 338         HTTP_REQUEST_ALIAS(methodExists, http_request_method_exists)
 339 #ifdef HAVE_CURL_FORMGET
 340         HTTP_REQUEST_ALIAS(encodeBody, http_request_body_encode)
 341 #endif
 342         EMPTY_FUNCTION_ENTRY
 343 };
 344 static zend_object_handlers http_request_object_handlers;
 345
 346 PHP_MINIT_FUNCTION(http_request_object)
 347 {
 348         HTTP_REGISTER_CLASS_EX(HttpRequest, http_request_object, NULL, 0);
 349         http_request_object_handlers.clone_obj = _http_request_object_clone_obj;
 350
 351         zend_declare_property_null(THIS_CE, ZEND_STRS("options")-1, ZEND_ACC_PRIVATE TSRMLS_CC);
 352         zend_declare_property_null(THIS_CE, ZEND_STRS("postFields")-1, ZEND_ACC_PRIVATE TSRMLS_CC);
 353         zend_declare_property_null(THIS_CE, ZEND_STRS("postFiles")-1, ZEND_ACC_PRIVATE TSRMLS_CC);
 354         zend_declare_property_null(THIS_CE, ZEND_STRS("responseInfo")-1, ZEND_ACC_PRIVATE TSRMLS_CC);
 355         zend_declare_property_null(THIS_CE, ZEND_STRS("responseMessage")-1, ZEND_ACC_PRIVATE TSRMLS_CC);
 356         zend_declare_property_long(THIS_CE, ZEND_STRS("responseCode")-1, 0, ZEND_ACC_PRIVATE TSRMLS_CC);
 357         zend_declare_property_string(THIS_CE, ZEND_STRS("responseStatus")-1, "", ZEND_ACC_PRIVATE TSRMLS_CC);
 358         zend_declare_property_long(THIS_CE, ZEND_STRS("method")-1, HTTP_GET, ZEND_ACC_PRIVATE TSRMLS_CC);
 359         zend_declare_property_string(THIS_CE, ZEND_STRS("url")-1, "", ZEND_ACC_PRIVATE TSRMLS_CC);
 360         zend_declare_property_string(THIS_CE, ZEND_STRS("contentType")-1, "", ZEND_ACC_PRIVATE TSRMLS_CC);
 361         zend_declare_property_string(THIS_CE, ZEND_STRS("requestBody")-1, "", ZEND_ACC_PRIVATE TSRMLS_CC);
 362         zend_declare_property_string(THIS_CE, ZEND_STRS("queryData")-1, "", ZEND_ACC_PRIVATE TSRMLS_CC);
 363         zend_declare_property_string(THIS_CE, ZEND_STRS("putFile")-1, "", ZEND_ACC_PRIVATE TSRMLS_CC);
 364         zend_declare_property_string(THIS_CE, ZEND_STRS("putData")-1, "", ZEND_ACC_PRIVATE TSRMLS_CC);
 365         zend_declare_property_null(THIS_CE, ZEND_STRS("history")-1, ZEND_ACC_PRIVATE TSRMLS_CC);
 366         zend_declare_property_bool(THIS_CE, ZEND_STRS("recordHistory")-1, 0, ZEND_ACC_PUBLIC TSRMLS_CC);
 367
 368 #ifndef WONKY
 369         /*
 370          * Request Method Constants
 371         */
 372         /* HTTP/1.1 */
 373         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_GET")-1, HTTP_GET TSRMLS_CC);
 374         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_HEAD")-1, HTTP_HEAD TSRMLS_CC);
 375         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_POST")-1, HTTP_POST TSRMLS_CC);
 376         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_PUT")-1, HTTP_PUT TSRMLS_CC);
 377         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_DELETE")-1, HTTP_DELETE TSRMLS_CC);
 378         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_OPTIONS")-1, HTTP_OPTIONS TSRMLS_CC);
 379         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_TRACE")-1, HTTP_TRACE TSRMLS_CC);
 380         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_CONNECT")-1, HTTP_CONNECT TSRMLS_CC);
 381         /* WebDAV - RFC 2518 */
 382         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_PROPFIND")-1, HTTP_PROPFIND TSRMLS_CC);
 383         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_PROPPATCH")-1, HTTP_PROPPATCH TSRMLS_CC);
 384         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_MKCOL")-1, HTTP_MKCOL TSRMLS_CC);
 385         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_COPY")-1, HTTP_COPY TSRMLS_CC);
 386         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_MOVE")-1, HTTP_MOVE TSRMLS_CC);
 387         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_LOCK")-1, HTTP_LOCK TSRMLS_CC);
 388         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_UNLOCK")-1, HTTP_UNLOCK TSRMLS_CC);
 389         /* WebDAV Versioning - RFC 3253 */
 390         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_VERSION_CONTROL")-1, HTTP_VERSION_CONTROL TSRMLS_CC);
 391         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_REPORT")-1, HTTP_REPORT TSRMLS_CC);
 392         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_CHECKOUT")-1, HTTP_CHECKOUT TSRMLS_CC);
 393         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_CHECKIN")-1, HTTP_CHECKIN TSRMLS_CC);
 394         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_UNCHECKOUT")-1, HTTP_UNCHECKOUT TSRMLS_CC);
 395         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_MKWORKSPACE")-1, HTTP_MKWORKSPACE TSRMLS_CC);
 396         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_UPDATE")-1, HTTP_UPDATE TSRMLS_CC);
 397         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_LABEL")-1, HTTP_LABEL TSRMLS_CC);
 398         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_MERGE")-1, HTTP_MERGE TSRMLS_CC);
 399         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_BASELINE_CONTROL")-1, HTTP_BASELINE_CONTROL TSRMLS_CC);
 400         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_MKACTIVITY")-1, HTTP_MKACTIVITY TSRMLS_CC);
 401         /* WebDAV Access Control - RFC 3744 */
 402         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("METH_ACL")-1, HTTP_ACL TSRMLS_CC);
 403
 404         /*
 405         * HTTP Protocol Version Constants
 406         */
 407         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("VERSION_1_0")-1, CURL_HTTP_VERSION_1_0 TSRMLS_CC);
 408         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("VERSION_1_1")-1, CURL_HTTP_VERSION_1_1 TSRMLS_CC);
 409         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("VERSION_NONE")-1, CURL_HTTP_VERSION_NONE TSRMLS_CC); /* to be removed */
 410         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("VERSION_ANY")-1, CURL_HTTP_VERSION_NONE TSRMLS_CC);
 411
 412         /*
 413         * SSL Version Constants
 414         */
 415         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("SSL_VERSION_TLSv1")-1, CURL_SSLVERSION_TLSv1 TSRMLS_CC);
 416         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("SSL_VERSION_SSLv2")-1, CURL_SSLVERSION_SSLv2 TSRMLS_CC);
 417         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("SSL_VERSION_SSLv3")-1, CURL_SSLVERSION_SSLv3 TSRMLS_CC);
 418         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("SSL_VERSION_ANY")-1, CURL_SSLVERSION_DEFAULT TSRMLS_CC);
 419
 420         /*
 421         * DNS IPvX resolving
 422         */
 423         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("IPRESOLVE_V4")-1, CURL_IPRESOLVE_V4 TSRMLS_CC);
 424         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("IPRESOLVE_V6")-1, CURL_IPRESOLVE_V6 TSRMLS_CC);
 425         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("IPRESOLVE_ANY")-1, CURL_IPRESOLVE_WHATEVER TSRMLS_CC);
 426
 427         /*
 428         * Auth Constants
 429         */
 430         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("AUTH_BASIC")-1, CURLAUTH_BASIC TSRMLS_CC);
 431         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("AUTH_DIGEST")-1, CURLAUTH_DIGEST TSRMLS_CC);
 432 #if HTTP_CURL_VERSION(7,19,3)
 433         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("AUTH_DIGEST_IE")-1, CURLAUTH_DIGEST_IE TSRMLS_CC);
 434 #endif
 435         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("AUTH_NTLM")-1, CURLAUTH_NTLM TSRMLS_CC);
 436         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("AUTH_GSSNEG")-1, CURLAUTH_GSSNEGOTIATE TSRMLS_CC);
 437         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("AUTH_ANY")-1, CURLAUTH_ANY TSRMLS_CC);
 438
 439         /*
 440         * Proxy Type Constants
 441         */
 442 #       if HTTP_CURL_VERSION(7,15,2)
 443         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("PROXY_SOCKS4")-1, CURLPROXY_SOCKS4 TSRMLS_CC);
 444 #       endif
 445 #if HTTP_CURL_VERSION(7,18,0)
 446         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("PROXY_SOCKS4A")-1, CURLPROXY_SOCKS5 TSRMLS_CC);
 447         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("PROXY_SOCKS5_HOSTNAME")-1, CURLPROXY_SOCKS5 TSRMLS_CC);
 448 #endif
 449         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("PROXY_SOCKS5")-1, CURLPROXY_SOCKS5 TSRMLS_CC);
 450         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("PROXY_HTTP")-1, CURLPROXY_HTTP TSRMLS_CC);
 451 #       if HTTP_CURL_VERSION(7,19,4)
 452         zend_declare_class_constant_long(THIS_CE, ZEND_STRS("PROXY_HTTP_1_0")-1, CURLPROXY_HTTP_1_0 TSRMLS_CC);
 453 #       endif
 454 #endif /* WONKY */
 455
 456         return SUCCESS;
 457 }
 458
 459 zend_object_value _http_request_object_new(zend_class_entry *ce TSRMLS_DC)
 460 {
 461         return http_request_object_new_ex(ce, NULL, NULL);
 462 }
 463
 464 zend_object_value _http_request_object_new_ex(zend_class_entry *ce, CURL *ch, http_request_object **ptr TSRMLS_DC)
 465 {
 466         zend_object_value ov;
 467         http_request_object *o;
 468
 469         o = ecalloc(1, sizeof(http_request_object));
 470         o->zo.ce = ce;
 471         o->request = http_request_init_ex(NULL, ch, 0, NULL);
 472
 473         if (ptr) {
 474                 *ptr = o;
 475         }
 476
 477         ALLOC_HASHTABLE(OBJ_PROP(o));
 478         zend_hash_init(OBJ_PROP(o), zend_hash_num_elements(&ce->default_properties), NULL, ZVAL_PTR_DTOR, 0);
 479         zend_hash_copy(OBJ_PROP(o), &ce->default_properties, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
 480
 481         ov.handle = putObject(http_request_object, o);
 482         ov.handlers = &http_request_object_handlers;
 483
 484         return ov;
 485 }
 486
 487 zend_object_value _http_request_object_clone_obj(zval *this_ptr TSRMLS_DC)
 488 {
 489         zend_object_value new_ov;
 490         http_request_object *new_obj;
 491         getObject(http_request_object, old_obj);
 492
 493         new_ov = http_request_object_new_ex(old_obj->zo.ce, NULL, &new_obj);
 494         if (old_obj->request->ch) {
 495                 http_curl_init_ex(http_curl_copy(old_obj->request->ch), new_obj->request);
 496         }
 497
 498         zend_objects_clone_members(&new_obj->zo, new_ov, &old_obj->zo, Z_OBJ_HANDLE_P(this_ptr) TSRMLS_CC);
 499         phpstr_append(&new_obj->request->conv.request, old_obj->request->conv.request.data, old_obj->request->conv.request.used);
 500         phpstr_append(&new_obj->request->conv.response, old_obj->request->conv.response.data, old_obj->request->conv.response.used);
 501
 502         return new_ov;
 503 }
 504
 505 void _http_request_object_free(zend_object *object TSRMLS_DC)
 506 {
 507         http_request_object *o = (http_request_object *) object;
 508
 509         http_request_free(&o->request);
 510         freeObject(o);
 511 }
 512
 513 #define http_request_object_check_request_content_type(t) _http_request_object_check_request_content_type((t) TSRMLS_CC)
 514 static inline void _http_request_object_check_request_content_type(zval *this_ptr TSRMLS_DC)
 515 {
 516         zval *ctype = zend_read_property(THIS_CE, getThis(), ZEND_STRS("contentType")-1, 0 TSRMLS_CC);
 517
 518         if (Z_STRLEN_P(ctype)) {
 519                 zval **headers, *opts = zend_read_property(THIS_CE, getThis(), ZEND_STRS("options")-1, 0 TSRMLS_CC);
 520
 521                 if (    (Z_TYPE_P(opts) == IS_ARRAY) &&
 522                                 (SUCCESS == zend_hash_find(Z_ARRVAL_P(opts), "headers", sizeof("headers"), (void *) &headers)) &&
 523                                 (Z_TYPE_PP(headers) == IS_ARRAY)) {
 524                         zval **ct_header;
 525
 526                         /* only override if not already set */
 527                         if ((SUCCESS != zend_hash_find(Z_ARRVAL_PP(headers), "Content-Type", sizeof("Content-Type"), (void *) &ct_header))) {
 528                                 add_assoc_stringl(*headers, "Content-Type", Z_STRVAL_P(ctype), Z_STRLEN_P(ctype), 1);
 529                         } else
 530                         /* or not a string, zero length string or a string of spaces */
 531                         if ((Z_TYPE_PP(ct_header) != IS_STRING) || !Z_STRLEN_PP(ct_header)) {
 532                                 add_assoc_stringl(*headers, "Content-Type", Z_STRVAL_P(ctype), Z_STRLEN_P(ctype), 1);
 533                         } else {
 534                                 int i, only_space = 1;
 535
 536                                 /* check for spaces only */
 537                                 for (i = 0; i < Z_STRLEN_PP(ct_header); ++i) {
 538                                         if (!HTTP_IS_CTYPE(space, Z_STRVAL_PP(ct_header)[i])) {
 539                                                 only_space = 0;
 540                                                 break;
 541                                         }
 542                                 }
 543                                 if (only_space) {
 544                                         add_assoc_stringl(*headers, "Content-Type", Z_STRVAL_P(ctype), Z_STRLEN_P(ctype), 1);
 545                                 }
 546                         }
 547                 } else {
 548                         zval *headers;
 549
 550                         MAKE_STD_ZVAL(headers);
 551                         array_init(headers);
 552                         add_assoc_stringl(headers, "Content-Type", Z_STRVAL_P(ctype), Z_STRLEN_P(ctype), 1);
 553                         zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "addheaders", NULL, headers);
 554                         zval_ptr_dtor(&headers);
 555                 }
 556         }
 557 }
 558
 559 STATUS _http_request_object_requesthandler(http_request_object *obj, zval *this_ptr TSRMLS_DC)
 560 {
 561         STATUS status = SUCCESS;
 562         char *url = http_absolute_url(Z_STRVAL_P(zend_read_property(THIS_CE, getThis(), ZEND_STRS("url")-1, 0 TSRMLS_CC)));
 563
 564         if (!url) {
 565                 return FAILURE;
 566         }
 567
 568         http_request_reset(obj->request);
 569         obj->request->url = url;
 570         HTTP_CHECK_CURL_INIT(obj->request->ch, http_curl_init(obj->request), return FAILURE);
 571
 572         switch (obj->request->meth = Z_LVAL_P(zend_read_property(THIS_CE, getThis(), ZEND_STRS("method")-1, 0 TSRMLS_CC)))
 573         {
 574                 case HTTP_GET:
 575                 case HTTP_HEAD:
 576                         break;
 577
 578                 case HTTP_PUT:
 579                 {
 580                         zval *put_file = zend_read_property(THIS_CE, getThis(), ZEND_STRS("putFile")-1, 0 TSRMLS_CC);
 581
 582                         http_request_object_check_request_content_type(getThis());
 583
 584                         if (Z_STRLEN_P(put_file)) {
 585                                 php_stream_statbuf ssb;
 586                                 php_stream *stream = php_stream_open_wrapper_ex(Z_STRVAL_P(put_file), "rb", REPORT_ERRORS|ENFORCE_SAFE_MODE, NULL, HTTP_DEFAULT_STREAM_CONTEXT);
 587
 588                                 if (stream && SUCCESS == php_stream_stat(stream, &ssb)) {
 589                                         obj->request->body = http_request_body_init_ex(obj->request->body, HTTP_REQUEST_BODY_UPLOADFILE, stream, ssb.sb.st_size, 1);
 590                                 } else {
 591                                         status = FAILURE;
 592                                 }
 593                         } else {
 594                                 zval *put_data = zend_read_property(THIS_CE, getThis(), ZEND_STRS("putData")-1, 0 TSRMLS_CC);
 595                                 obj->request->body = http_request_body_init_ex(obj->request->body, HTTP_REQUEST_BODY_CSTRING,
 596                                         estrndup(Z_STRVAL_P(put_data), Z_STRLEN_P(put_data)), Z_STRLEN_P(put_data), 1);
 597                         }
 598                         break;
 599                 }
 600
 601                 case HTTP_POST:
 602                 default:
 603                 {
 604                         /* check for raw request body */
 605                         zval *raw_data = zend_read_property(THIS_CE, getThis(), ZEND_STRS("requestBody")-1, 0 TSRMLS_CC);
 606
 607                         if (Z_STRLEN_P(raw_data)) {
 608                                 http_request_object_check_request_content_type(getThis());
 609                                 obj->request->body = http_request_body_init_ex(obj->request->body, HTTP_REQUEST_BODY_CSTRING,
 610                                         estrndup(Z_STRVAL_P(raw_data), Z_STRLEN_P(raw_data)), Z_STRLEN_P(raw_data), 1);
 611                         } else {
 612                                 zval *zfields = zend_read_property(THIS_CE, getThis(), ZEND_STRS("postFields")-1, 0 TSRMLS_CC), *zfiles = zend_read_property(THIS_CE, getThis(), ZEND_STRS("postFiles")-1, 0 TSRMLS_CC);
 613                                 HashTable *fields;
 614                                 HashTable *files;
 615
 616                                 fields = (Z_TYPE_P(zfields) == IS_ARRAY) ? Z_ARRVAL_P(zfields) : NULL;
 617                                 files = (Z_TYPE_P(zfiles) == IS_ARRAY) ? Z_ARRVAL_P(zfiles) : NULL;
 618
 619                                 if ((fields && zend_hash_num_elements(fields)) || (files && zend_hash_num_elements(files))) {
 620                                         if (!(obj->request->body = http_request_body_fill(obj->request->body, fields, files))) {
 621                                                 status = FAILURE;
 622                                         }
 623                                 }
 624                         }
 625                         break;
 626                 }
 627         }
 628
 629         if (status == SUCCESS) {
 630                 zval *qdata = zend_read_property(THIS_CE, getThis(), ZEND_STRS("queryData")-1, 0 TSRMLS_CC);
 631                 zval *options = zend_read_property(THIS_CE, getThis(), ZEND_STRS("options")-1, 0 TSRMLS_CC);
 632
 633                 if (Z_STRLEN_P(qdata)) {
 634                         if (!strchr(obj->request->url, '?')) {
 635                                 strlcat(obj->request->url, "?", HTTP_URL_MAXLEN);
 636                         } else {
 637                                 strlcat(obj->request->url, "&", HTTP_URL_MAXLEN);
 638                         }
 639                         strlcat(obj->request->url, Z_STRVAL_P(qdata), HTTP_URL_MAXLEN);
 640                 }
 641
 642                 http_request_prepare(obj->request, Z_ARRVAL_P(options));
 643
 644                 /* check if there's a onProgress method and add it as progress callback if one isn't already set */
 645                 if (zend_hash_exists(&Z_OBJCE_P(getThis())->function_table, "onprogress", sizeof("onprogress"))) {
 646                         zval **entry, *pcb;
 647
 648                         if (    (Z_TYPE_P(options) != IS_ARRAY)
 649                                 ||      (SUCCESS != zend_hash_find(Z_ARRVAL_P(options), "onprogress", sizeof("onprogress"), (void *) &entry)
 650                                 ||      (!IS_CALLABLE(*entry, 0, NULL)))) {
 651                                 MAKE_STD_ZVAL(pcb);
 652                                 array_init(pcb);
 653                                 ZVAL_ADDREF(getThis());
 654                                 add_next_index_zval(pcb, getThis());
 655                                 add_next_index_stringl(pcb, "onprogress", lenof("onprogress"), 1);
 656                                 http_request_set_progress_callback(obj->request, pcb);
 657                                 zval_ptr_dtor(&pcb);
 658                         }
 659                 }
 660         }
 661
 662         return status;
 663 }
 664
 665 STATUS _http_request_object_responsehandler(http_request_object *obj, zval *this_ptr TSRMLS_DC)
 666 {
 667         STATUS ret;
 668         zval *info;
 669         http_message *msg;
 670
 671         /* always fetch info */
 672         MAKE_STD_ZVAL(info);
 673         array_init(info);
 674         http_request_info(obj->request, Z_ARRVAL_P(info));
 675         zend_update_property(THIS_CE, getThis(), ZEND_STRS("responseInfo")-1, info TSRMLS_CC);
 676         zval_ptr_dtor(&info);
 677
 678         /* parse response message */
 679         phpstr_fix(&obj->request->conv.request);
 680         phpstr_fix(&obj->request->conv.response);
 681
 682         if ((msg = http_message_parse(PHPSTR_VAL(&obj->request->conv.response), PHPSTR_LEN(&obj->request->conv.response)))) {
 683                 zval *message;
 684
 685                 if (i_zend_is_true(zend_read_property(THIS_CE, getThis(), ZEND_STRS("recordHistory")-1, 0 TSRMLS_CC))) {
 686                         zval *hist, *history = zend_read_property(THIS_CE, getThis(), ZEND_STRS("history")-1, 0 TSRMLS_CC);
 687                         http_message *response = http_message_parse(PHPSTR_VAL(&obj->request->conv.response), PHPSTR_LEN(&obj->request->conv.response));
 688                         http_message *request = http_message_parse(PHPSTR_VAL(&obj->request->conv.request), PHPSTR_LEN(&obj->request->conv.request));
 689
 690                         MAKE_STD_ZVAL(hist);
 691                         ZVAL_OBJVAL(hist, http_message_object_new_ex(http_message_object_ce, http_message_interconnect(response, request), NULL), 0);
 692                         if (Z_TYPE_P(history) == IS_OBJECT) {
 693                                 http_message_object_prepend(hist, history);
 694                         }
 695                         zend_update_property(THIS_CE, getThis(), ZEND_STRS("history")-1, hist TSRMLS_CC);
 696                         zval_ptr_dtor(&hist);
 697                 }
 698
 699                 zend_update_property_long(THIS_CE, getThis(), ZEND_STRS("responseCode")-1, msg->http.info.response.code TSRMLS_CC);
 700                 zend_update_property_string(THIS_CE, getThis(), ZEND_STRS("responseStatus")-1, STR_PTR(msg->http.info.response.status) TSRMLS_CC);
 701
 702                 MAKE_STD_ZVAL(message);
 703                 ZVAL_OBJVAL(message, http_message_object_new_ex(http_message_object_ce, msg, NULL), 0);
 704                 zend_update_property(THIS_CE, getThis(), ZEND_STRS("responseMessage")-1, message TSRMLS_CC);
 705                 zval_ptr_dtor(&message);
 706
 707                 ret = SUCCESS;
 708         } else {
 709                 /* update properties with empty values*/
 710                 zval *znull;
 711
 712                 MAKE_STD_ZVAL(znull);
 713                 ZVAL_NULL(znull);
 714                 zend_update_property(THIS_CE, getThis(), ZEND_STRS("responseMessage")-1, znull TSRMLS_CC);
 715                 zval_ptr_dtor(&znull);
 716
 717                 zend_update_property_long(THIS_CE, getThis(), ZEND_STRS("responseCode")-1, 0 TSRMLS_CC);
 718                 zend_update_property_string(THIS_CE, getThis(), ZEND_STRS("responseStatus")-1, "" TSRMLS_CC);
 719
 720                 /* append request message to history */
 721                 if (i_zend_is_true(zend_read_property(THIS_CE, getThis(), ZEND_STRS("recordHistory")-1, 0 TSRMLS_CC))) {
 722                         http_message *request;
 723
 724                         if ((request = http_message_parse(PHPSTR_VAL(&obj->request->conv.request), PHPSTR_LEN(&obj->request->conv.request)))) {
 725                                 zval *hist, *history = zend_read_property(THIS_CE, getThis(), ZEND_STRS("history")-1, 0 TSRMLS_CC);
 726
 727                                 MAKE_STD_ZVAL(hist);
 728                                 ZVAL_OBJVAL(hist, http_message_object_new_ex(http_message_object_ce, request, NULL), 0);
 729                                 if (Z_TYPE_P(history) == IS_OBJECT) {
 730                                         http_message_object_prepend(hist, history);
 731                                 }
 732                                 zend_update_property(THIS_CE, getThis(), ZEND_STRS("history")-1, hist TSRMLS_CC);
 733                                 zval_ptr_dtor(&hist);
 734                         }
 735                 }
 736
 737                 ret = FAILURE;
 738         }
 739
 740         http_request_set_progress_callback(obj->request, NULL);
 741
 742         if (!EG(exception) && zend_hash_exists(&Z_OBJCE_P(getThis())->function_table, "onfinish", sizeof("onfinish"))) {
 743                 zval *param;
 744
 745                 MAKE_STD_ZVAL(param);
 746                 ZVAL_BOOL(param, ret == SUCCESS);
 747                 with_error_handling(EH_NORMAL, NULL) {
 748                         zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "onfinish", NULL, param);
 749                 } end_error_handling();
 750                 zval_ptr_dtor(&param);
 751         }
 752
 753         return ret;
 754 }
 755
 756 static int apply_pretty_key(void *pDest, int num_args, va_list args, zend_hash_key *hash_key)
 757 {
 758         if (hash_key->arKey && hash_key->nKeyLength > 1) {
 759                 hash_key->h = zend_hash_func(pretty_key(hash_key->arKey, hash_key->nKeyLength - 1, 1, 0), hash_key->nKeyLength);
 760         }
 761         return ZEND_HASH_APPLY_KEEP;
 762 }
 763
 764 #define http_request_object_set_options_subr(key, ow, pk) \
 765         _http_request_object_set_options_subr(INTERNAL_FUNCTION_PARAM_PASSTHRU, (key), sizeof(key), (ow), (pk))
 766 static inline void _http_request_object_set_options_subr(INTERNAL_FUNCTION_PARAMETERS, char *key, size_t len, int overwrite, int prettify_keys)
 767 {
 768         zval *old_opts, *new_opts, *opts = NULL, **entry = NULL;
 769
 770         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a/!", &opts)) {
 771                 RETURN_FALSE;
 772         }
 773
 774         MAKE_STD_ZVAL(new_opts);
 775         array_init(new_opts);
 776         old_opts = zend_read_property(THIS_CE, getThis(), ZEND_STRS("options")-1, 0 TSRMLS_CC);
 777         if (Z_TYPE_P(old_opts) == IS_ARRAY) {
 778                 array_copy(Z_ARRVAL_P(old_opts), Z_ARRVAL_P(new_opts));
 779         }
 780
 781         if (SUCCESS == zend_hash_find(Z_ARRVAL_P(new_opts), key, len, (void *) &entry)) {
 782                 if (overwrite) {
 783                         zend_hash_clean(Z_ARRVAL_PP(entry));
 784                 }
 785                 if (opts && zend_hash_num_elements(Z_ARRVAL_P(opts))) {
 786                         if (overwrite) {
 787                                 array_copy(Z_ARRVAL_P(opts), Z_ARRVAL_PP(entry));
 788                         } else {
 789                                 array_join(Z_ARRVAL_P(opts), Z_ARRVAL_PP(entry), 0, prettify_keys ? ARRAY_JOIN_PRETTIFY : 0);
 790                         }
 791                 }
 792         } else if (opts) {
 793                 if (prettify_keys) {
 794                         zend_hash_apply_with_arguments(Z_ARRVAL_P(opts) HTTP_ZAPI_HASH_TSRMLS_CC, apply_pretty_key, 0, NULL);
 795                 }
 796                 ZVAL_ADDREF(opts);
 797                 add_assoc_zval_ex(new_opts, key, len, opts);
 798         }
 799         zend_update_property(THIS_CE, getThis(), ZEND_STRS("options")-1, new_opts TSRMLS_CC);
 800         zval_ptr_dtor(&new_opts);
 801
 802         RETURN_TRUE;
 803 }
 804
 805 #define http_request_object_get_options_subr(key) \
 806         _http_request_get_options_subr(INTERNAL_FUNCTION_PARAM_PASSTHRU, (key), sizeof(key))
 807 static inline void _http_request_get_options_subr(INTERNAL_FUNCTION_PARAMETERS, char *key, size_t len)
 808 {
 809         NO_ARGS;
 810
 811         if (return_value_used) {
 812                 zval *opts, **options;
 813
 814                 opts = zend_read_property(THIS_CE, getThis(), ZEND_STRS("options")-1, 0 TSRMLS_CC);
 815                 array_init(return_value);
 816
 817                 if (    (Z_TYPE_P(opts) == IS_ARRAY) &&
 818                                 (SUCCESS == zend_hash_find(Z_ARRVAL_P(opts), key, len, (void *) &options))) {
 819                         convert_to_array(*options);
 820                         array_copy(Z_ARRVAL_PP(options), Z_ARRVAL_P(return_value));
 821                 }
 822         }
 823 }
 824
 825
 826 /* ### USERLAND ### */
 827
 828 /* {{{ proto void HttpRequest::__construct([string url[, int request_method = HTTP_METH_GET[, array options]]])
 829         Create a new HttpRequest object instance. */
 830 PHP_METHOD(HttpRequest, __construct)
 831 {
 832         char *URL = NULL;
 833         int URL_len;
 834         long meth = -1;
 835         zval *options = NULL;
 836
 837         SET_EH_THROW_HTTP();
 838         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sla!", &URL, &URL_len, &meth, &options)) {
 839                 if (URL) {
 840                         zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("url")-1, URL, URL_len TSRMLS_CC);
 841                 }
 842                 if (meth > -1) {
 843                         zend_update_property_long(THIS_CE, getThis(), ZEND_STRS("method")-1, meth TSRMLS_CC);
 844                 }
 845                 if (options) {
 846                         zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "setoptions", NULL, options);
 847                 }
 848         }
 849         SET_EH_NORMAL();
 850 }
 851 /* }}} */
 852
 853 /* {{{ proto HttpRequest HttpRequest::factory([string url[, int request_method HTTP_METH_GET[, array options[, string class_name = "HttpRequest"]]]])
 854         Create a new HttpRequest object instance. */
 855 PHP_METHOD(HttpRequest, factory)
 856 {
 857         char *cn = NULL, *URL = NULL;
 858         int cl = 0, URL_len = 0;
 859         long meth = -1;
 860         zval *options = NULL;
 861         zend_object_value ov;
 862
 863         SET_EH_THROW_HTTP();
 864         if (    SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sla!s", &URL, &URL_len, &meth, &options, &cn, &cl) &&
 865                         SUCCESS == http_object_new(&ov, cn, cl, _http_request_object_new_ex, http_request_object_ce, NULL, NULL)) {
 866                 RETVAL_OBJVAL(ov, 0);
 867                 getThis() = return_value;
 868                 if (URL) {
 869                         zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("url")-1, URL, URL_len TSRMLS_CC);
 870                 }
 871                 if (meth > -1) {
 872                         zend_update_property_long(THIS_CE, getThis(), ZEND_STRS("method")-1, meth TSRMLS_CC);
 873                 }
 874                 if (options) {
 875                         zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "setoptions", NULL, options);
 876                 }
 877         }
 878         SET_EH_NORMAL();
 879 }
 880 /* }}} */
 881
 882 /* {{{ proto bool HttpRequest::setOptions([array options])
 883         Set the request options to use.  See http_get() for a full list of available options. */
 884 PHP_METHOD(HttpRequest, setOptions)
 885 {
 886         HashKey key = initHashKey(0);
 887         HashPosition pos;
 888         zval *opts = NULL, *old_opts, *new_opts, *add_opts, **opt;
 889
 890         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a!/", &opts)) {
 891                 RETURN_FALSE;
 892         }
 893
 894         MAKE_STD_ZVAL(new_opts);
 895         array_init(new_opts);
 896
 897         if (!opts || !zend_hash_num_elements(Z_ARRVAL_P(opts))) {
 898                 zend_update_property(THIS_CE, getThis(), ZEND_STRS("options")-1, new_opts TSRMLS_CC);
 899                 zval_ptr_dtor(&new_opts);
 900                 RETURN_TRUE;
 901         }
 902
 903         MAKE_STD_ZVAL(add_opts);
 904         array_init(add_opts);
 905         /* some options need extra attention -- thus cannot use array_merge() directly */
 906         FOREACH_KEYVAL(pos, opts, key, opt) {
 907                 if (key.type == HASH_KEY_IS_STRING) {
 908 #define KEYMATCH(k, s) ((sizeof(s)==k.len) && !strcasecmp(k.str, s))
 909                         if (KEYMATCH(key, "headers")) {
 910                                 zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "addheaders", NULL, *opt);
 911                         } else if (KEYMATCH(key, "cookies")) {
 912                                 zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "addcookies", NULL, *opt);
 913                         } else if (KEYMATCH(key, "ssl")) {
 914                                 zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "addssloptions", NULL, *opt);
 915                         } else if (KEYMATCH(key, "url") || KEYMATCH(key, "uri")) {
 916                                 zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "seturl", NULL, *opt);
 917                         } else if (KEYMATCH(key, "method")) {
 918                                 zend_call_method_with_1_params(&getThis(), Z_OBJCE_P(getThis()), NULL, "setmethod", NULL, *opt);
 919                         } else if (KEYMATCH(key, "flushcookies")) {
 920                                 getObject(http_request_object, obj);
 921                                 if (i_zend_is_true(*opt)) {
 922                                         http_request_flush_cookies(obj->request);
 923                                 }
 924                         } else if (KEYMATCH(key, "resetcookies")) {
 925                                 getObject(http_request_object, obj);
 926                                 http_request_reset_cookies(obj->request, (zend_bool) i_zend_is_true(*opt));
 927                         } else if (KEYMATCH(key, "enablecookies")) {
 928                                 getObject(http_request_object, obj);
 929                                 http_request_enable_cookies(obj->request);
 930                         } else if (KEYMATCH(key, "recordHistory")) {
 931                                 zend_update_property(THIS_CE, getThis(), ZEND_STRS("recordHistory")-1, *opt TSRMLS_CC);
 932                         } else if (Z_TYPE_PP(opt) == IS_NULL) {
 933                                 old_opts = zend_read_property(THIS_CE, getThis(), ZEND_STRS("options")-1, 0 TSRMLS_CC);
 934                                 if (Z_TYPE_P(old_opts) == IS_ARRAY) {
 935                                         zend_hash_del(Z_ARRVAL_P(old_opts), key.str, key.len);
 936                                 }
 937                         } else {
 938                                 ZVAL_ADDREF(*opt);
 939                                 add_assoc_zval_ex(add_opts, key.str, key.len, *opt);
 940                         }
 941                 }
 942         }
 943
 944         old_opts = zend_read_property(THIS_CE, getThis(), ZEND_STRS("options")-1, 0 TSRMLS_CC);
 945         if (Z_TYPE_P(old_opts) == IS_ARRAY) {
 946                 array_copy(Z_ARRVAL_P(old_opts), Z_ARRVAL_P(new_opts));
 947         }
 948         array_join(Z_ARRVAL_P(add_opts), Z_ARRVAL_P(new_opts), 0, 0);
 949         zend_update_property(THIS_CE, getThis(), ZEND_STRS("options")-1, new_opts TSRMLS_CC);
 950         zval_ptr_dtor(&new_opts);
 951         zval_ptr_dtor(&add_opts);
 952
 953         RETURN_TRUE;
 954 }
 955 /* }}} */
 956
 957 /* {{{ proto array HttpRequest::getOptions()
 958         Get currently set options. */
 959 PHP_METHOD(HttpRequest, getOptions)
 960 {
 961         NO_ARGS;
 962
 963         if (return_value_used) {
 964                 RETURN_PROP(options);
 965         }
 966 }
 967 /* }}} */
 968
 969 /* {{{ proto bool HttpRequest::setSslOptions([array options])
 970         Set SSL options. */
 971 PHP_METHOD(HttpRequest, setSslOptions)
 972 {
 973         http_request_object_set_options_subr("ssl", 1, 0);
 974 }
 975 /* }}} */
 976
 977 /* {{{ proto bool HttpRequest::addSslOptions(array options)
 978         Set additional SSL options. */
 979 PHP_METHOD(HttpRequest, addSslOptions)
 980 {
 981         http_request_object_set_options_subr("ssl", 0, 0);
 982 }
 983 /* }}} */
 984
 985 /* {{{ proto array HttpRequest::getSslOtpions()
 986         Get previously set SSL options. */
 987 PHP_METHOD(HttpRequest, getSslOptions)
 988 {
 989         http_request_object_get_options_subr("ssl");
 990 }
 991 /* }}} */
 992
 993 /* {{{ proto bool HttpRequest::addHeaders(array headers)
 994         Add request header name/value pairs. */
 995 PHP_METHOD(HttpRequest, addHeaders)
 996 {
 997         http_request_object_set_options_subr("headers", 0, 1);
 998 }
 999
1000 /* {{{ proto bool HttpRequest::setHeaders([array headers])
1001         Set request header name/value pairs. */
1002 PHP_METHOD(HttpRequest, setHeaders)
1003 {
1004         http_request_object_set_options_subr("headers", 1, 1);
1005 }
1006 /* }}} */
1007
1008 /* {{{ proto array HttpRequest::getHeaders()
1009         Get previously set request headers. */
1010 PHP_METHOD(HttpRequest, getHeaders)
1011 {
1012         http_request_object_get_options_subr("headers");
1013 }
1014 /* }}} */
1015
1016 /* {{{ proto bool HttpRequest::setCookies([array cookies])
1017         Set cookies. */
1018 PHP_METHOD(HttpRequest, setCookies)
1019 {
1020         http_request_object_set_options_subr("cookies", 1, 0);
1021 }
1022 /* }}} */
1023
1024 /* {{{ proto bool HttpRequest::addCookies(array cookies)
1025         Add cookies. */
1026 PHP_METHOD(HttpRequest, addCookies)
1027 {
1028         http_request_object_set_options_subr("cookies", 0, 0);
1029 }
1030 /* }}} */
1031
1032 /* {{{ proto array HttpRequest::getCookies()
1033         Get previously set cookies. */
1034 PHP_METHOD(HttpRequest, getCookies)
1035 {
1036         http_request_object_get_options_subr("cookies");
1037 }
1038 /* }}} */
1039
1040 /* {{{ proto bool HttpRequest::enableCookies()
1041         Enable automatic sending of received cookies. Note that customly set cookies will be sent anyway. */
1042 PHP_METHOD(HttpRequest, enableCookies)
1043 {
1044         NO_ARGS {
1045                 getObject(http_request_object, obj);
1046                 RETURN_SUCCESS(http_request_enable_cookies(obj->request));
1047         }
1048
1049 }
1050 /* }}} */
1051
1052 /* {{{ proto bool HttpRequest::resetCookies([bool session_only = FALSE])
1053         Reset all automatically received/sent cookies. Note that customly set cookies are not affected. */
1054 PHP_METHOD(HttpRequest, resetCookies)
1055 {
1056         zend_bool session_only = 0;
1057         getObject(http_request_object, obj);
1058
1059         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &session_only)) {
1060                 RETURN_FALSE;
1061         }
1062         RETURN_SUCCESS(http_request_reset_cookies(obj->request, session_only));
1063 }
1064 /* }}} */
1065
1066 /* {{{ proto bool HttpRequest::flushCookies()
1067         Flush internal cookies to the cookiestore file */
1068 PHP_METHOD(HttpRequest, flushCookies)
1069 {
1070         NO_ARGS {
1071                 getObject(http_request_object, obj);
1072                 RETURN_SUCCESS(http_request_flush_cookies(obj->request));
1073         }
1074 }
1075 /* }}} */
1076
1077 /* {{{ proto bool HttpRequest::setUrl(string url)
1078         Set the request URL. */
1079 PHP_METHOD(HttpRequest, setUrl)
1080 {
1081         char *URL = NULL;
1082         int URL_len;
1083
1084         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &URL, &URL_len)) {
1085                 RETURN_FALSE;
1086         }
1087
1088         zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("url")-1, URL, URL_len TSRMLS_CC);
1089         RETURN_TRUE;
1090 }
1091 /* }}} */
1092
1093 /* {{{ proto string HttpRequest::getUrl()
1094         Get the previously set request URL. */
1095 PHP_METHOD(HttpRequest, getUrl)
1096 {
1097         NO_ARGS;
1098
1099         if (return_value_used) {
1100                 RETURN_PROP(url);
1101         }
1102 }
1103 /* }}} */
1104
1105 /* {{{ proto bool HttpRequest::setMethod(int request_method)
1106         Set the request method. */
1107 PHP_METHOD(HttpRequest, setMethod)
1108 {
1109         long meth;
1110
1111         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &meth)) {
1112                 RETURN_FALSE;
1113         }
1114
1115         zend_update_property_long(THIS_CE, getThis(), ZEND_STRS("method")-1, meth TSRMLS_CC);
1116         RETURN_TRUE;
1117 }
1118 /* }}} */
1119
1120 /* {{{ proto int HttpRequest::getMethod()
1121         Get the previously set request method. */
1122 PHP_METHOD(HttpRequest, getMethod)
1123 {
1124         NO_ARGS;
1125
1126         if (return_value_used) {
1127                 RETURN_PROP(method);
1128         }
1129 }
1130 /* }}} */
1131
1132 /* {{{ proto bool HttpRequest::setContentType(string content_type)
1133         Set the content type the post request should have. */
1134 PHP_METHOD(HttpRequest, setContentType)
1135 {
1136         char *ctype;
1137         int ct_len;
1138
1139         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &ctype, &ct_len)) {
1140                 RETURN_FALSE;
1141         }
1142
1143         if (ct_len) {
1144                 HTTP_CHECK_CONTENT_TYPE(ctype, RETURN_FALSE);
1145         }
1146         zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("contentType")-1, ctype, ct_len TSRMLS_CC);
1147         RETURN_TRUE;
1148 }
1149 /* }}} */
1150
1151 /* {{{ proto string HttpRequest::getContentType()
1152         Get the previously content type. */
1153 PHP_METHOD(HttpRequest, getContentType)
1154 {
1155         NO_ARGS;
1156
1157         if (return_value_used) {
1158                 RETURN_PROP(contentType);
1159         }
1160 }
1161 /* }}} */
1162
1163 /* {{{ proto bool HttpRequest::setQueryData([mixed query_data])
1164         Set the URL query parameters to use, overwriting previously set query parameters. */
1165 PHP_METHOD(HttpRequest, setQueryData)
1166 {
1167         zval *qdata = NULL;
1168
1169         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z!", &qdata)) {
1170                 RETURN_FALSE;
1171         }
1172
1173         if ((!qdata) || Z_TYPE_P(qdata) == IS_NULL) {
1174                 zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("queryData")-1, "", 0 TSRMLS_CC);
1175         } else if ((Z_TYPE_P(qdata) == IS_ARRAY) || (Z_TYPE_P(qdata) == IS_OBJECT)) {
1176                 char *query_data = NULL;
1177
1178                 if (SUCCESS != http_urlencode_hash(HASH_OF(qdata), &query_data)) {
1179                         RETURN_FALSE;
1180                 }
1181
1182                 zend_update_property_string(THIS_CE, getThis(), ZEND_STRS("queryData")-1, query_data TSRMLS_CC);
1183                 efree(query_data);
1184         } else {
1185                 zval *data = http_zsep(IS_STRING, qdata);
1186
1187                 zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("queryData")-1, Z_STRVAL_P(data), Z_STRLEN_P(data) TSRMLS_CC);
1188                 zval_ptr_dtor(&data);
1189         }
1190         RETURN_TRUE;
1191 }
1192 /* }}} */
1193
1194 /* {{{ proto string HttpRequest::getQueryData()
1195         Get the current query data in form of an urlencoded query string. */
1196 PHP_METHOD(HttpRequest, getQueryData)
1197 {
1198         NO_ARGS;
1199
1200         if (return_value_used) {
1201                 RETURN_PROP(queryData);
1202         }
1203 }
1204 /* }}} */
1205
1206 /* {{{ proto bool HttpRequest::addQueryData(array query_params)
1207         Add parameters to the query parameter list, leaving previously set unchanged. */
1208 PHP_METHOD(HttpRequest, addQueryData)
1209 {
1210         zval *qdata, *old_qdata;
1211         char *query_data = NULL;
1212         size_t query_data_len = 0;
1213
1214         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/", &qdata)) {
1215                 RETURN_FALSE;
1216         }
1217
1218         old_qdata = zend_read_property(THIS_CE, getThis(), ZEND_STRS("queryData")-1, 0 TSRMLS_CC);
1219
1220         if (SUCCESS != http_urlencode_hash_ex(HASH_OF(qdata), 1, Z_STRVAL_P(old_qdata), Z_STRLEN_P(old_qdata), &query_data, &query_data_len)) {
1221                 RETURN_FALSE;
1222         }
1223
1224         zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("queryData")-1, query_data, query_data_len TSRMLS_CC);
1225         efree(query_data);
1226
1227         RETURN_TRUE;
1228 }
1229 /* }}} */
1230
1231 /* {{{ proto bool HttpRequest::addPostFields(array post_data)
1232         Adds POST data entries, leaving previously set unchanged, unless a post entry with the same name already exists. */
1233 PHP_METHOD(HttpRequest, addPostFields)
1234 {
1235         zval *post_data, *old_post, *new_post;
1236
1237         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/", &post_data)) {
1238                 RETURN_FALSE;
1239         }
1240
1241         if (zend_hash_num_elements(Z_ARRVAL_P(post_data))) {
1242                 MAKE_STD_ZVAL(new_post);
1243                 array_init(new_post);
1244                 old_post = zend_read_property(THIS_CE, getThis(), ZEND_STRS("postFields")-1, 0 TSRMLS_CC);
1245                 if (Z_TYPE_P(old_post) == IS_ARRAY) {
1246                         array_copy(Z_ARRVAL_P(old_post), Z_ARRVAL_P(new_post));
1247                 }
1248                 array_join(Z_ARRVAL_P(post_data), Z_ARRVAL_P(new_post), 0, 0);
1249                 zend_update_property(THIS_CE, getThis(), ZEND_STRS("postFields")-1, new_post TSRMLS_CC);
1250                 zval_ptr_dtor(&new_post);
1251         }
1252
1253         RETURN_TRUE;
1254 }
1255 /* }}} */
1256
1257 /* {{{ proto bool HttpRequest::setPostFields([array post_data])
1258         Set the POST data entries, overwriting previously set POST data. */
1259 PHP_METHOD(HttpRequest, setPostFields)
1260 {
1261         zval *post, *post_data = NULL;
1262
1263         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/!", &post_data)) {
1264                 RETURN_FALSE;
1265         }
1266
1267         MAKE_STD_ZVAL(post);
1268         array_init(post);
1269         if (post_data && zend_hash_num_elements(Z_ARRVAL_P(post_data))) {
1270                 array_copy(Z_ARRVAL_P(post_data), Z_ARRVAL_P(post));
1271         }
1272         zend_update_property(THIS_CE, getThis(), ZEND_STRS("postFields")-1, post TSRMLS_CC);
1273         zval_ptr_dtor(&post);
1274
1275         RETURN_TRUE;
1276 }
1277 /* }}}*/
1278
1279 /* {{{ proto array HttpRequest::getPostFields()
1280         Get previously set POST data. */
1281 PHP_METHOD(HttpRequest, getPostFields)
1282 {
1283         NO_ARGS;
1284
1285         if (return_value_used) {
1286                 RETURN_PROP(postFields);
1287         }
1288 }
1289 /* }}} */
1290
1291 /* {{{ proto bool HttpRequest::setBody([string request_body_data])
1292         Set request body to send, overwriting previously set request body. Don't forget to specify a content type. */
1293 PHP_METHOD(HttpRequest, setBody)
1294 {
1295         char *raw_data = NULL;
1296         int data_len = 0;
1297
1298         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &raw_data, &data_len)) {
1299                 RETURN_FALSE;
1300         }
1301
1302         if (!raw_data) {
1303                 raw_data = "";
1304         }
1305
1306         zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("requestBody")-1, raw_data, data_len TSRMLS_CC);
1307         RETURN_TRUE;
1308 }
1309 /* }}} */
1310
1311 /* {{{ proto bool HttpRequest::addBody(string request_body_data)
1312         Add request body data, leaving previously set request body data unchanged. */
1313 PHP_METHOD(HttpRequest, addBody)
1314 {
1315         char *raw_data;
1316         int data_len;
1317
1318         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &raw_data, &data_len)) {
1319                 RETURN_FALSE;
1320         }
1321
1322         if (data_len) {
1323                 zval *data = zend_read_property(THIS_CE, getThis(), ZEND_STRS("requestBody")-1, 0 TSRMLS_CC);
1324
1325                 if (Z_STRLEN_P(data)) {
1326                         Z_STRVAL_P(data) = erealloc(Z_STRVAL_P(data), (Z_STRLEN_P(data) += data_len) + 1);
1327                         Z_STRVAL_P(data)[Z_STRLEN_P(data)] = '\0';
1328                         memcpy(Z_STRVAL_P(data) + Z_STRLEN_P(data) - data_len, raw_data, data_len);
1329                 } else {
1330                         zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("requestBody")-1, raw_data, data_len TSRMLS_CC);
1331                 }
1332         }
1333
1334         RETURN_TRUE;
1335 }
1336 /* }}} */
1337
1338 /* {{{ proto string HttpRequest::getBody()
1339         Get previously set request body data. */
1340 PHP_METHOD(HttpRequest, getBody)
1341 {
1342         NO_ARGS;
1343
1344         if (return_value_used) {
1345                 RETURN_PROP(requestBody);
1346         }
1347 }
1348 /* }}} */
1349
1350 /* {{{ proto bool HttpRequest::addPostFile(string name, string file[, string content_type = "application/x-octetstream"])
1351         Add a file to the POST request, leaving previously set files unchanged. */
1352 PHP_METHOD(HttpRequest, addPostFile)
1353 {
1354         zval *entry, *old_post, *new_post;
1355         char *name, *file, *type = NULL;
1356         int name_len, file_len, type_len = 0;
1357
1358         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|s", &name, &name_len, &file, &file_len, &type, &type_len)) {
1359                 RETURN_FALSE;
1360         }
1361
1362         if (type_len) {
1363                 HTTP_CHECK_CONTENT_TYPE(type, RETURN_FALSE);
1364         } else {
1365                 type = "application/x-octetstream";
1366                 type_len = sizeof("application/x-octetstream") - 1;
1367         }
1368
1369         MAKE_STD_ZVAL(entry);
1370         array_init(entry);
1371
1372         add_assoc_stringl(entry, "name", name, name_len, 1);
1373         add_assoc_stringl(entry, "type", type, type_len, 1);
1374         add_assoc_stringl(entry, "file", file, file_len, 1);
1375
1376         MAKE_STD_ZVAL(new_post);
1377         array_init(new_post);
1378         old_post = zend_read_property(THIS_CE, getThis(), ZEND_STRS("postFiles")-1, 0 TSRMLS_CC);
1379         if (Z_TYPE_P(old_post) == IS_ARRAY) {
1380                 array_copy(Z_ARRVAL_P(old_post), Z_ARRVAL_P(new_post));
1381         }
1382         add_next_index_zval(new_post, entry);
1383         zend_update_property(THIS_CE, getThis(), ZEND_STRS("postFiles")-1, new_post TSRMLS_CC);
1384         zval_ptr_dtor(&new_post);
1385
1386         RETURN_TRUE;
1387 }
1388 /* }}} */
1389
1390 /* {{{ proto bool HttpRequest::setPostFiles([array post_files])
1391         Set files to post, overwriting previously set post files. */
1392 PHP_METHOD(HttpRequest, setPostFiles)
1393 {
1394         zval *files = NULL, *post;
1395
1396         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a!/", &files)) {
1397                 RETURN_FALSE;
1398         }
1399
1400         MAKE_STD_ZVAL(post);
1401         array_init(post);
1402         if (files && (Z_TYPE_P(files) == IS_ARRAY)) {
1403                 array_copy(Z_ARRVAL_P(files), Z_ARRVAL_P(post));
1404         }
1405         zend_update_property(THIS_CE, getThis(), ZEND_STRS("postFiles")-1, post TSRMLS_CC);
1406         zval_ptr_dtor(&post);
1407
1408         RETURN_TRUE;
1409 }
1410 /* }}} */
1411
1412 /* {{{ proto array HttpRequest::getPostFiles()
1413         Get all previously added POST files. */
1414 PHP_METHOD(HttpRequest, getPostFiles)
1415 {
1416         NO_ARGS;
1417
1418         if (return_value_used) {
1419                 RETURN_PROP(postFiles);
1420         }
1421 }
1422 /* }}} */
1423
1424 /* {{{ proto bool HttpRequest::setPutFile([string file])
1425         Set file to put. Affects only PUT requests. */
1426 PHP_METHOD(HttpRequest, setPutFile)
1427 {
1428         char *file = "";
1429         int file_len = 0;
1430
1431         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &file, &file_len)) {
1432                 RETURN_FALSE;
1433         }
1434
1435         zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("putFile")-1, file, file_len TSRMLS_CC);
1436         RETURN_TRUE;
1437 }
1438 /* }}} */
1439
1440 /* {{{ proto string HttpRequest::getPutFile()
1441         Get previously set put file. */
1442 PHP_METHOD(HttpRequest, getPutFile)
1443 {
1444         NO_ARGS;
1445
1446         if (return_value_used) {
1447                 RETURN_PROP(putFile);
1448         }
1449 }
1450 /* }}} */
1451
1452 /* {{{ proto bool HttpRequest::setPutData([string put_data])
1453         Set PUT data to send, overwriting previously set PUT data. */
1454 PHP_METHOD(HttpRequest, setPutData)
1455 {
1456         char *put_data = NULL;
1457         int data_len = 0;
1458
1459         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &put_data, &data_len)) {
1460                 RETURN_FALSE;
1461         }
1462
1463         if (!put_data) {
1464                 put_data = "";
1465         }
1466
1467         zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("putData")-1, put_data, data_len TSRMLS_CC);
1468         RETURN_TRUE;
1469 }
1470 /* }}} */
1471
1472 /* {{{ proto bool HttpRequest::addPutData(string put_data)
1473         Add PUT data, leaving previously set PUT data unchanged. */
1474 PHP_METHOD(HttpRequest, addPutData)
1475 {
1476         char *put_data;
1477         int data_len;
1478
1479         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &put_data, &data_len)) {
1480                 RETURN_FALSE;
1481         }
1482
1483         if (data_len) {
1484                 zval *data = zend_read_property(THIS_CE, getThis(), ZEND_STRS("putData")-1, 0 TSRMLS_CC);
1485
1486                 if (Z_STRLEN_P(data)) {
1487                         Z_STRVAL_P(data) = erealloc(Z_STRVAL_P(data), (Z_STRLEN_P(data) += data_len) + 1);
1488                         Z_STRVAL_P(data)[Z_STRLEN_P(data)] = '\0';
1489                         memcpy(Z_STRVAL_P(data) + Z_STRLEN_P(data) - data_len, put_data, data_len);
1490                 } else {
1491                         zend_update_property_stringl(THIS_CE, getThis(), ZEND_STRS("putData")-1, put_data, data_len TSRMLS_CC);
1492                 }
1493         }
1494
1495         RETURN_TRUE;
1496 }
1497 /* }}} */
1498
1499 /* {{{ proto string HttpRequest::getPutData()
1500         Get previously set PUT data. */
1501 PHP_METHOD(HttpRequest, getPutData)
1502 {
1503         NO_ARGS;
1504
1505         if (return_value_used) {
1506                 RETURN_PROP(putData);
1507         }
1508 }
1509 /* }}} */
1510
1511 /* {{{ proto array HttpRequest::getResponseData()
1512         Get all response data after the request has been sent. */
1513 PHP_METHOD(HttpRequest, getResponseData)
1514 {
1515         NO_ARGS;
1516
1517         if (return_value_used) {
1518                 char *body;
1519                 size_t body_len;
1520                 zval *headers, *message = zend_read_property(THIS_CE, getThis(), ZEND_STRS("responseMessage")-1, 0 TSRMLS_CC);
1521
1522                 if (Z_TYPE_P(message) == IS_OBJECT) {
1523                         getObjectEx(http_message_object, msg, message);
1524
1525                         array_init(return_value);
1526
1527                         MAKE_STD_ZVAL(headers);
1528                         array_init(headers);
1529                         zend_hash_copy(Z_ARRVAL_P(headers), &msg->message->hdrs, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
1530                         add_assoc_zval(return_value, "headers", headers);
1531
1532                         phpstr_data(PHPSTR(msg->message), &body, &body_len);
1533                         add_assoc_stringl(return_value, "body", body, body_len, 0);
1534                 }
1535         }
1536 }
1537 /* }}} */
1538
1539 /* {{{ proto mixed HttpRequest::getResponseHeader([string name])
1540         Get response header(s) after the request has been sent. */
1541 PHP_METHOD(HttpRequest, getResponseHeader)
1542 {
1543         if (return_value_used) {
1544                 zval *header;
1545                 char *header_name = NULL;
1546                 int header_len = 0;
1547
1548                 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &header_name, &header_len)) {
1549                         zval *message = zend_read_property(THIS_CE, getThis(), ZEND_STRS("responseMessage")-1, 0 TSRMLS_CC);
1550
1551                         if (Z_TYPE_P(message) == IS_OBJECT) {
1552                                 getObjectEx(http_message_object, msg, message);
1553
1554                                 if (header_len) {
1555                                         if ((header = http_message_header_ex(msg->message, pretty_key(header_name, header_len, 1, 1), header_len + 1, 0))) {
1556                                                 RETURN_ZVAL(header, 1, 1);
1557                                         }
1558                                 } else {
1559                                         array_init(return_value);
1560                                         zend_hash_copy(Z_ARRVAL_P(return_value), &msg->message->hdrs, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
1561                                         return;
1562                                 }
1563                         }
1564                 }
1565                 RETURN_FALSE;
1566         }
1567 }
1568 /* }}} */
1569
1570 /* {{{ proto array HttpRequest::getResponseCookies([int flags[, array allowed_extras]])
1571         Get response cookie(s) after the request has been sent. */
1572 PHP_METHOD(HttpRequest, getResponseCookies)
1573 {
1574         if (return_value_used) {
1575                 long flags = 0;
1576                 zval *allowed_extras_array = NULL;
1577
1578                 if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|la!", &flags, &allowed_extras_array)) {
1579                         int i = 0;
1580                         HashKey key = initHashKey(0);
1581                         char **allowed_extras = NULL;
1582                         zval **header = NULL, **entry = NULL, *message = zend_read_property(THIS_CE, getThis(), ZEND_STRS("responseMessage")-1, 0 TSRMLS_CC);
1583                         HashPosition pos, pos1, pos2;
1584
1585                         if (Z_TYPE_P(message) == IS_OBJECT) {
1586                                 getObjectEx(http_message_object, msg, message);
1587
1588                                 array_init(return_value);
1589
1590                                 if (allowed_extras_array) {
1591                                         allowed_extras = ecalloc(zend_hash_num_elements(Z_ARRVAL_P(allowed_extras_array)) + 1, sizeof(char *));
1592                                         FOREACH_VAL(pos, allowed_extras_array, entry) {
1593                                                 zval *data = http_zsep(IS_STRING, *entry);
1594                                                 allowed_extras[i++] = estrndup(Z_STRVAL_P(data), Z_STRLEN_P(data));
1595                                                 zval_ptr_dtor(&data);
1596                                         }
1597                                 }
1598
1599                                 FOREACH_HASH_KEYVAL(pos1, &msg->message->hdrs, key, header) {
1600                                         if (key.type == HASH_KEY_IS_STRING && !strcasecmp(key.str, "Set-Cookie")) {
1601                                                 http_cookie_list list;
1602
1603                                                 if (Z_TYPE_PP(header) == IS_ARRAY) {
1604                                                         zval **single_header;
1605
1606                                                         FOREACH_VAL(pos2, *header, single_header) {
1607                                                                 zval *data = http_zsep(IS_STRING, *single_header);
1608
1609                                                                 if (http_parse_cookie_ex(&list, Z_STRVAL_P(data), flags, allowed_extras)) {
1610                                                                         zval *cookie;
1611
1612                                                                         MAKE_STD_ZVAL(cookie);
1613                                                                         object_init(cookie);
1614                                                                         http_cookie_list_tostruct(&list, cookie);
1615                                                                         add_next_index_zval(return_value, cookie);
1616                                                                         http_cookie_list_dtor(&list);
1617                                                                 }
1618                                                                 zval_ptr_dtor(&data);
1619                                                         }
1620                                                 } else {
1621                                                         zval *data = http_zsep(IS_STRING, *header);
1622                                                         if (http_parse_cookie_ex(&list, Z_STRVAL_P(data), flags, allowed_extras)) {
1623                                                                 zval *cookie;
1624
1625                                                                 MAKE_STD_ZVAL(cookie);
1626                                                                 object_init(cookie);
1627                                                                 http_cookie_list_tostruct(&list, cookie);
1628                                                                 add_next_index_zval(return_value, cookie);
1629                                                                 http_cookie_list_dtor(&list);
1630                                                         }
1631                                                         zval_ptr_dtor(&data);
1632                                                 }
1633                                         }
1634                                 }
1635
1636                                 if (allowed_extras) {
1637                                         for (i = 0; allowed_extras[i]; ++i) {
1638                                                 efree(allowed_extras[i]);
1639                                         }
1640                                         efree(allowed_extras);
1641                                 }
1642
1643                                 return;
1644                         }
1645                 }
1646                 RETURN_FALSE;
1647         }
1648 }
1649 /* }}} */
1650
1651 /* {{{ proto string HttpRequest::getResponseBody()
1652         Get the response body after the request has been sent. */
1653 PHP_METHOD(HttpRequest, getResponseBody)
1654 {
1655         NO_ARGS;
1656
1657         if (return_value_used) {
1658                 zval *message = zend_read_property(THIS_CE, getThis(), ZEND_STRS("responseMessage")-1, 0 TSRMLS_CC);
1659
1660                 if (Z_TYPE_P(message) == IS_OBJECT) {
1661                         getObjectEx(http_message_object, msg, message);
1662                         RETURN_PHPSTR_DUP(&msg->message->body);
1663                 } else {
1664                         RETURN_FALSE;
1665                 }
1666         }
1667 }
1668 /* }}} */
1669
1670 /* {{{ proto int HttpRequest::getResponseCode()
1671         Get the response code after the request has been sent. */
1672 PHP_METHOD(HttpRequest, getResponseCode)
1673 {
1674         NO_ARGS;
1675
1676         if (return_value_used) {
1677                 RETURN_PROP(responseCode);
1678         }
1679 }
1680 /* }}} */
1681
1682 /* {{{ proto string HttpRequest::getResponseStatus()
1683         Get the response status (i.e. the string after the response code) after the message has been sent. */
1684 PHP_METHOD(HttpRequest, getResponseStatus)
1685 {
1686         NO_ARGS;
1687
1688         if (return_value_used) {
1689                 RETURN_PROP(responseStatus);
1690         }
1691 }
1692 /* }}} */
1693
1694 /* {{{ proto mixed HttpRequest::getResponseInfo([string name])
1695         Get response info after the request has been sent. */
1696 PHP_METHOD(HttpRequest, getResponseInfo)
1697 {
1698         if (return_value_used) {
1699                 zval *info, **infop;
1700                 char *info_name = NULL;
1701                 int info_len = 0;
1702
1703                 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &info_name, &info_len)) {
1704                         RETURN_FALSE;
1705                 }
1706
1707                 info = zend_read_property(THIS_CE, getThis(), ZEND_STRS("responseInfo")-1, 0 TSRMLS_CC);
1708
1709                 if (Z_TYPE_P(info) != IS_ARRAY) {
1710                         RETURN_FALSE;
1711                 }
1712
1713                 if (info_len && info_name) {
1714                         if (SUCCESS == zend_hash_find(Z_ARRVAL_P(info), pretty_key(info_name, info_len, 0, 0), info_len + 1, (void *) &infop)) {
1715                                 RETURN_ZVAL(*infop, 1, 0);
1716                         } else {
1717                                 http_error_ex(HE_NOTICE, HTTP_E_INVALID_PARAM, "Could not find response info named %s", info_name);
1718                                 RETURN_FALSE;
1719                         }
1720                 } else {
1721                         RETURN_ZVAL(info, 1, 0);
1722                 }
1723         }
1724 }
1725 /* }}}*/
1726
1727 /* {{{ proto HttpMessage HttpRequest::getResponseMessage()
1728         Get the full response as HttpMessage object after the request has been sent. */
1729 PHP_METHOD(HttpRequest, getResponseMessage)
1730 {
1731         NO_ARGS {
1732                 zval *message;
1733
1734                 SET_EH_THROW_HTTP();
1735                 message = zend_read_property(THIS_CE, getThis(), ZEND_STRS("responseMessage")-1, 0 TSRMLS_CC);
1736                 if (Z_TYPE_P(message) == IS_OBJECT) {
1737                         RETVAL_OBJECT(message, 1);
1738                 } else {
1739                         http_error(HE_WARNING, HTTP_E_RUNTIME, "HttpRequest does not contain a response message");
1740                 }
1741                 SET_EH_NORMAL();
1742         }
1743 }
1744 /* }}} */
1745
1746 /* {{{ proto HttpMessage HttpRequest::getRequestMessage()
1747         Get sent HTTP message. */
1748 PHP_METHOD(HttpRequest, getRequestMessage)
1749 {
1750         NO_ARGS;
1751
1752         if (return_value_used) {
1753                 http_message *msg;
1754                 getObject(http_request_object, obj);
1755
1756                 SET_EH_THROW_HTTP();
1757                 if ((msg = http_message_parse(PHPSTR_VAL(&obj->request->conv.request), PHPSTR_LEN(&obj->request->conv.request)))) {
1758                         RETVAL_OBJVAL(http_message_object_new_ex(http_message_object_ce, msg, NULL), 0);
1759                 }
1760                 SET_EH_NORMAL();
1761         }
1762 }
1763 /* }}} */
1764
1765 /* {{{ proto string HttpRequest::getRawRequestMessage()
1766         Get sent HTTP message. */
1767 PHP_METHOD(HttpRequest, getRawRequestMessage)
1768 {
1769         NO_ARGS;
1770
1771         if (return_value_used) {
1772                 getObject(http_request_object, obj);
1773
1774                 RETURN_PHPSTR_DUP(&obj->request->conv.request);
1775         }
1776 }
1777 /* }}} */
1778
1779 /* {{{ proto string HttpRequest::getRawResponseMessage()
1780         Get the entire HTTP response. */
1781 PHP_METHOD(HttpRequest, getRawResponseMessage)
1782 {
1783         NO_ARGS;
1784
1785         if (return_value_used) {
1786                 getObject(http_request_object, obj);
1787
1788                 RETURN_PHPSTR_DUP(&obj->request->conv.response);
1789         }
1790 }
1791 /* }}} */
1792
1793 /* {{{ proto HttpMessage HttpRequest::getHistory()
1794         Get all sent requests and received responses as an HttpMessage object. */
1795 PHP_METHOD(HttpRequest, getHistory)
1796 {
1797         NO_ARGS;
1798
1799         if (return_value_used) {
1800                 zval *hist;
1801
1802                 SET_EH_THROW_HTTP();
1803                 hist = zend_read_property(THIS_CE, getThis(), ZEND_STRS("history")-1, 0 TSRMLS_CC);
1804                 if (Z_TYPE_P(hist) == IS_OBJECT) {
1805                         RETVAL_OBJECT(hist, 1);
1806                 } else {
1807                         http_error(HE_WARNING, HTTP_E_RUNTIME, "The history is empty");
1808                 }
1809                 SET_EH_NORMAL();
1810         }
1811 }
1812 /* }}} */
1813
1814 /* {{{ proto void HttpRequest::clearHistory()
1815         Clear the history. */
1816 PHP_METHOD(HttpRequest, clearHistory)
1817 {
1818         NO_ARGS {
1819                 zval *hist;
1820
1821                 MAKE_STD_ZVAL(hist);
1822                 ZVAL_NULL(hist);
1823                 zend_update_property(THIS_CE, getThis(), ZEND_STRS("history")-1, hist TSRMLS_CC);
1824                 zval_ptr_dtor(&hist);
1825         }
1826 }
1827 /* }}} */
1828
1829 /* {{{ proto HttpMessage HttpRequest::send()
1830         Send the HTTP request. */
1831 PHP_METHOD(HttpRequest, send)
1832 {
1833         getObject(http_request_object, obj);
1834
1835         NO_ARGS;
1836
1837         SET_EH_THROW_HTTP();
1838
1839         RETVAL_FALSE;
1840
1841         if (obj->pool) {
1842                 http_error(HE_WARNING, HTTP_E_RUNTIME, "Cannot perform HttpRequest::send() while attached to an HttpRequestPool");
1843         } else if (SUCCESS == http_request_object_requesthandler(obj, getThis())) {
1844                 http_request_exec(obj->request);
1845                 if (SUCCESS == http_request_object_responsehandler(obj, getThis())) {
1846                         RETVAL_OBJECT(zend_read_property(THIS_CE, getThis(), ZEND_STRS("responseMessage")-1, 0 TSRMLS_CC), 1);
1847                 }
1848         }
1849
1850         SET_EH_NORMAL();
1851 }
1852 /* }}} */
1853
1854 #endif /* ZEND_ENGINE_2 && HTTP_HAVE_CURL */
1855
1856 /*
1857  * Local variables:
1858  * tab-width: 4
1859  * c-basic-offset: 4
1860  * End:
1861  * vim600: noet sw=4 ts=4 fdm=marker
1862  * vim<600: noet sw=4 ts=4
1863  */
1864