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