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

   1 /*
   2    +----------------------------------------------------------------------+
   3    | PECL :: http                                                         |
   4    +----------------------------------------------------------------------+
   5    | This source file is subject to version 3.0 of the PHP license, that  |
   6    | is bundled with this package in the file LICENSE, and is available   |
   7    | through the world-wide-web at http://www.php.net/license/3_0.txt.    |
   8    | If you did not receive a copy of the PHP license and are unable to   |
   9    | obtain it through the world-wide-web, please send a note to          |
  10    | license@php.net so we can mail you a copy immediately.               |
  11    +----------------------------------------------------------------------+
  12    | Copyright (c) 2004-2005 Michael Wallner <mike@php.net>               |
  13    +----------------------------------------------------------------------+
  14 */
  15
  16 /* $Id$ */
  17
  18 #ifdef HAVE_CONFIG_H
  19 #       include "config.h"
  20 #endif
  21
  22 #include "php.h"
  23 #include "php_http.h"
  24 #include "php_http_std_defs.h"
  25 #include "php_http_api.h"
  26 #include "php_http_cache_api.h"
  27 #include "php_http_curl_api.h"
  28 #include "php_http_date_api.h"
  29 #include "php_http_headers_api.h"
  30 #include "php_http_send_api.h"
  31 #include "php_http_url_api.h"
  32
  33 #include "php_http_message_object.h"
  34 #include "php_http_response_object.h"
  35 #include "php_http_request_object.h"
  36 #include "php_http_exception_object.h"
  37
  38 #ifdef ZEND_ENGINE_2
  39
  40 /* {{{ HttpResponse */
  41
  42 /* {{{ proto void HttpResponse::__construct(bool cache, bool gzip)
  43  *
  44  * Instantiates a new HttpResponse object, which can be used to send
  45  * any data/resource/file to an HTTP client with caching and multiple
  46  * ranges/resuming support.
  47  *
  48  * NOTE: GZIPping is not implemented yet.
  49  */
  50 PHP_METHOD(HttpResponse, __construct)
  51 {
  52         zend_bool do_cache = 0, do_gzip = 0;
  53         getObject(http_response_object, obj);
  54
  55         SET_EH_THROW_HTTP();
  56         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|bb", &do_cache, &do_gzip)) {
  57                 UPD_PROP(obj, long, cache, do_cache);
  58                 UPD_PROP(obj, long, gzip, do_gzip);
  59         }
  60         SET_EH_NORMAL();
  61 }
  62 /* }}} */
  63
  64 /* {{{ proto bool HttpResponse::setCache(bool cache)
  65  *
  66  * Whether it sould be attempted to cache the entitity.
  67  * This will result in necessary caching headers and checks of clients
  68  * "If-Modified-Since" and "If-None-Match" headers.  If one of those headers
  69  * matches a "304 Not Modified" status code will be issued.
  70  *
  71  * NOTE: If you're using sessions, be shure that you set session.cache_limiter
  72  * to something more appropriate than "no-cache"!
  73  */
  74 PHP_METHOD(HttpResponse, setCache)
  75 {
  76         zend_bool do_cache = 0;
  77         getObject(http_response_object, obj);
  78
  79         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "b", &do_cache)) {
  80                 RETURN_FALSE;
  81         }
  82
  83         UPD_PROP(obj, long, cache, do_cache);
  84         RETURN_TRUE;
  85 }
  86 /* }}} */
  87
  88 /* {{{ proto bool HttpResponse::getCache()
  89  *
  90  * Get current caching setting.
  91  */
  92 PHP_METHOD(HttpResponse, getCache)
  93 {
  94         zval *do_cache = NULL;
  95         getObject(http_response_object, obj);
  96
  97         NO_ARGS;
  98
  99         do_cache = GET_PROP(obj, cache);
 100         RETURN_BOOL(Z_LVAL_P(do_cache));
 101 }
 102 /* }}}*/
 103
 104 /* {{{ proto bool HttpResponse::setGzip(bool gzip)
 105  *
 106  * Enable on-thy-fly gzipping of the sent entity. NOT IMPLEMENTED YET.
 107  */
 108 PHP_METHOD(HttpResponse, setGzip)
 109 {
 110         zend_bool do_gzip = 0;
 111         getObject(http_response_object, obj);
 112
 113         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "b", &do_gzip)) {
 114                 RETURN_FALSE;
 115         }
 116
 117         UPD_PROP(obj, long, gzip, do_gzip);
 118         RETURN_TRUE;
 119 }
 120 /* }}} */
 121
 122 /* {{{ proto bool HttpResponse::getGzip()
 123  *
 124  * Get current gzipping setting.
 125  */
 126 PHP_METHOD(HttpResponse, getGzip)
 127 {
 128         zval *do_gzip = NULL;
 129         getObject(http_response_object, obj);
 130
 131         NO_ARGS;
 132
 133         do_gzip = GET_PROP(obj, gzip);
 134         RETURN_BOOL(Z_LVAL_P(do_gzip));
 135 }
 136 /* }}} */
 137
 138 /* {{{ proto bool HttpResponse::setCacheControl(string control[, bool raw = false])
 139  *
 140  * Set a custom cache-control header, usually being "private" or "public";  if
 141  * $raw is set to true the header will be sent as-is.
 142  */
 143 PHP_METHOD(HttpResponse, setCacheControl)
 144 {
 145         char *ccontrol;
 146         int cc_len;
 147         zend_bool raw = 0;
 148         getObject(http_response_object, obj);
 149
 150         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &ccontrol, &cc_len, &raw)) {
 151                 RETURN_FALSE;
 152         }
 153
 154         if ((!raw) && (strcmp(ccontrol, "public") && strcmp(ccontrol, "private") && strcmp(ccontrol, "no-cache"))) {
 155                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cache-Control '%s' doesn't match public, private or no-cache", ccontrol);
 156                 RETURN_FALSE;
 157         }
 158
 159         UPD_PROP(obj, long, raw_cache_header, raw);
 160         UPD_PROP(obj, string, cacheControl, ccontrol);
 161         RETURN_TRUE;
 162 }
 163 /* }}} */
 164
 165 /* {{{ proto string HttpResponse::getCacheControl()
 166  *
 167  * Get current Cache-Control header setting.
 168  */
 169 PHP_METHOD(HttpResponse, getCacheControl)
 170 {
 171         zval *ccontrol;
 172         getObject(http_response_object, obj);
 173
 174         NO_ARGS;
 175
 176         ccontrol = GET_PROP(obj, cacheControl);
 177         RETURN_STRINGL(Z_STRVAL_P(ccontrol), Z_STRLEN_P(ccontrol), 1);
 178 }
 179 /* }}} */
 180
 181 /* {{{ proto bool HttpResponse::setContentType(string content_type)
 182  *
 183  * Set the content-type of the sent entity.
 184  */
 185 PHP_METHOD(HttpResponse, setContentType)
 186 {
 187         char *ctype;
 188         int ctype_len;
 189         getObject(http_response_object, obj);
 190
 191         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &ctype, &ctype_len)) {
 192                 RETURN_FALSE;
 193         }
 194
 195         if (!strchr(ctype, '/')) {
 196                 php_error_docref(NULL TSRMLS_CC, E_WARNING,
 197                         "Content type '%s' doesn't seem to contain a primary and a secondary part", ctype);
 198                 RETURN_FALSE;
 199         }
 200
 201         UPD_PROP(obj, string, contentType, ctype);
 202
 203         RETURN_TRUE;
 204 }
 205 /* }}} */
 206
 207 /* {{{ proto string HttpResponse::getContentType()
 208  *
 209  * Get current Content-Type header setting.
 210  */
 211 PHP_METHOD(HttpResponse, getContentType)
 212 {
 213         zval *ctype;
 214         getObject(http_response_object, obj);
 215
 216         NO_ARGS;
 217
 218         ctype = GET_PROP(obj, contentType);
 219         RETURN_STRINGL(Z_STRVAL_P(ctype), Z_STRLEN_P(ctype), 1);
 220 }
 221 /* }}} */
 222
 223 /* {{{ proto bool HttpResponse::setContentDisposition(string filename[, bool inline = false])
 224  *
 225  * Set the Content-Disposition of the sent entity.  This setting aims to suggest
 226  * the receiveing user agent how to handle the sent entity;  usually the client
 227  * will show the user a "Save As..." popup.
 228  */
 229 PHP_METHOD(HttpResponse, setContentDisposition)
 230 {
 231         char *file;
 232         int file_len;
 233         zend_bool is_inline = 0;
 234         getObject(http_response_object, obj);
 235
 236         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &file, &file_len, &is_inline)) {
 237                 RETURN_FALSE;
 238         }
 239
 240         UPD_PROP(obj, string, dispoFile, file);
 241         UPD_PROP(obj, long, dispoInline, is_inline);
 242         RETURN_TRUE;
 243 }
 244 /* }}} */
 245
 246 /* {{{ proto array HttpResponse::getContentDisposition()
 247  *
 248  * Get current Content-Disposition setting.
 249  * Will return an associative array like:
 250  * <pre>
 251  * array(
 252  *     'filename' => 'foo.bar',
 253  *     'inline'   => false
 254  * )
 255  * </pre>
 256  */
 257 PHP_METHOD(HttpResponse, getContentDisposition)
 258 {
 259         zval *file;
 260         zval *is_inline;
 261         getObject(http_response_object, obj);
 262
 263         if (ZEND_NUM_ARGS()) {
 264                 WRONG_PARAM_COUNT;
 265         }
 266
 267         file = GET_PROP(obj, dispoFile);
 268         is_inline = GET_PROP(obj, dispoInline);
 269
 270         array_init(return_value);
 271         add_assoc_stringl(return_value, "filename", Z_STRVAL_P(file), Z_STRLEN_P(file), 1);
 272         add_assoc_bool(return_value, "inline", Z_LVAL_P(is_inline));
 273 }
 274 /* }}} */
 275
 276 /* {{{ proto bool HttpResponse::setETag(string etag)
 277  *
 278  * Set a custom ETag.  Use this only if you know what you're doing.
 279  */
 280 PHP_METHOD(HttpResponse, setETag)
 281 {
 282         char *etag;
 283         int etag_len;
 284         getObject(http_response_object, obj);
 285
 286         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &etag, &etag_len)) {
 287                 RETURN_FALSE;
 288         }
 289
 290         UPD_PROP(obj, string, eTag, etag);
 291         RETURN_TRUE;
 292 }
 293 /* }}} */
 294
 295 /* {{{ proto string HttpResponse::getETag()
 296  *
 297  * Get the previously set custom ETag.
 298  */
 299 PHP_METHOD(HttpResponse, getETag)
 300 {
 301         zval *etag;
 302         getObject(http_response_object, obj);
 303
 304         NO_ARGS;
 305
 306         etag = GET_PROP(obj, eTag);
 307         RETURN_STRINGL(Z_STRVAL_P(etag), Z_STRLEN_P(etag), 1);
 308 }
 309 /* }}} */
 310
 311 /* {{{ proto bool HttpResponse::setData(string data)
 312  *
 313  * Set the data to be sent.
 314  */
 315 PHP_METHOD(HttpResponse, setData)
 316 {
 317         zval *the_data;
 318         getObject(http_response_object, obj);
 319
 320         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &the_data)) {
 321                 RETURN_FALSE;
 322         }
 323
 324         convert_to_string_ex(&the_data);
 325         SET_PROP(obj, data, the_data);
 326         UPD_PROP(obj, long, lastModified, http_lmod(the_data, SEND_DATA));
 327         UPD_PROP(obj, long, send_mode, SEND_DATA);
 328         RETURN_TRUE;
 329 }
 330 /* }}} */
 331
 332 /* {{{ proto string HttpResponse::getData()
 333  *
 334  * Get the previously set data to be sent.
 335  */
 336 PHP_METHOD(HttpResponse, getData)
 337 {
 338         zval *the_data;
 339         getObject(http_response_object, obj);
 340
 341         NO_ARGS;
 342
 343         the_data = GET_PROP(obj, data);
 344         RETURN_STRINGL(Z_STRVAL_P(the_data), Z_STRLEN_P(the_data), 1);
 345 }
 346 /* }}} */
 347
 348 /* {{{ proto bool HttpResponse::setStream(resource stream)
 349  *
 350  * Set the resource to be sent.
 351  */
 352 PHP_METHOD(HttpResponse, setStream)
 353 {
 354         zval *the_stream;
 355         php_stream *the_real_stream;
 356         getObject(http_response_object, obj);
 357
 358         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &the_stream)) {
 359                 RETURN_FALSE;
 360         }
 361
 362         php_stream_from_zval(the_real_stream, &the_stream);
 363
 364         SET_PROP(obj, stream, the_stream);
 365         UPD_PROP(obj, long, lastModified, http_lmod(the_real_stream, SEND_RSRC));
 366         UPD_PROP(obj, long, send_mode, SEND_RSRC);
 367         RETURN_TRUE;
 368 }
 369 /* }}} */
 370
 371 /* {{{ proto resource HttpResponse::getStream()
 372  *
 373  * Get the previously set resource to be sent.
 374  */
 375 PHP_METHOD(HttpResponse, getStream)
 376 {
 377         zval *the_stream;
 378         getObject(http_response_object, obj);
 379
 380         NO_ARGS;
 381
 382         the_stream = GET_PROP(obj, stream);
 383         RETURN_RESOURCE(Z_LVAL_P(the_stream));
 384 }
 385 /* }}} */
 386
 387 /* {{{ proto bool HttpResponse::setFile(string file)
 388  *
 389  * Set the file to be sent.
 390  */
 391 PHP_METHOD(HttpResponse, setFile)
 392 {
 393         zval *the_file;
 394         getObject(http_response_object, obj);
 395
 396         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &the_file)) {
 397                 RETURN_FALSE;
 398         }
 399
 400         convert_to_string_ex(&the_file);
 401
 402         UPD_PROP(obj, string, file, Z_STRVAL_P(the_file));
 403         UPD_PROP(obj, long, lastModified, http_lmod(the_file, -1));
 404         UPD_PROP(obj, long, send_mode, -1);
 405         RETURN_TRUE;
 406 }
 407 /* }}} */
 408
 409 /* {{{ proto string HttpResponse::getFile()
 410  *
 411  * Get the previously set file to be sent.
 412  */
 413 PHP_METHOD(HttpResponse, getFile)
 414 {
 415         zval *the_file;
 416         getObject(http_response_object, obj);
 417
 418         NO_ARGS;
 419
 420         the_file = GET_PROP(obj, file);
 421         RETURN_STRINGL(Z_STRVAL_P(the_file), Z_STRLEN_P(the_file), 1);
 422 }
 423 /* }}} */
 424
 425 /* {{{ proto bool HttpResponse::send()
 426  *
 427  * Finally send the entity.
 428  *
 429  * Example:
 430  * <pre>
 431  * <?php
 432  * $r = new HttpResponse(true);
 433  * $r->setFile('../hidden/contract.pdf');
 434  * $r->setContentType('application/pdf');
 435  * $r->send();
 436  * ?>
 437  * </pre>
 438  *
 439  */
 440 PHP_METHOD(HttpResponse, send)
 441 {
 442         zval *do_cache, *do_gzip;
 443         getObject(http_response_object, obj);
 444
 445         NO_ARGS;
 446
 447         do_cache = GET_PROP(obj, cache);
 448         do_gzip  = GET_PROP(obj, gzip);
 449
 450         /* gzip */
 451         if (Z_LVAL_P(do_gzip)) {
 452                 php_start_ob_buffer_named("ob_gzhandler", 0, 1 TSRMLS_CC);
 453         }
 454
 455         /* caching */
 456         if (Z_LVAL_P(do_cache)) {
 457                 zval *cctrl, *etag, *lmod, *ccraw;
 458
 459                 etag  = GET_PROP(obj, eTag);
 460                 lmod  = GET_PROP(obj, lastModified);
 461                 cctrl = GET_PROP(obj, cacheControl);
 462                 ccraw = GET_PROP(obj, raw_cache_header);
 463
 464                 if (Z_LVAL_P(ccraw)) {
 465                         http_cache_etag(Z_STRVAL_P(etag), Z_STRLEN_P(etag), Z_STRVAL_P(cctrl), Z_STRLEN_P(cctrl));
 466                         http_cache_last_modified(Z_LVAL_P(lmod), Z_LVAL_P(lmod) ? Z_LVAL_P(lmod) : time(NULL), Z_STRVAL_P(cctrl), Z_STRLEN_P(cctrl));
 467                 } else {
 468                         char cc_header[42] = {0};
 469                         sprintf(cc_header, "%s, must-revalidate, max-age=0", Z_STRVAL_P(cctrl));
 470                         http_cache_etag(Z_STRVAL_P(etag), Z_STRLEN_P(etag), cc_header, strlen(cc_header));
 471                         http_cache_last_modified(Z_LVAL_P(lmod), Z_LVAL_P(lmod) ? Z_LVAL_P(lmod) : time(NULL), cc_header, strlen(cc_header));
 472                 }
 473         }
 474
 475         /* content type */
 476         {
 477                 zval *ctype = GET_PROP(obj, contentType);
 478                 if (Z_STRLEN_P(ctype)) {
 479                         http_send_content_type(Z_STRVAL_P(ctype), Z_STRLEN_P(ctype));
 480                 } else {
 481                         http_send_content_type("application/x-octetstream", sizeof("application/x-octetstream") - 1);
 482                 }
 483         }
 484
 485         /* content disposition */
 486         {
 487                 zval *dispo_file = GET_PROP(obj, dispoFile);
 488                 if (Z_STRLEN_P(dispo_file)) {
 489                         zval *dispo_inline = GET_PROP(obj, dispoInline);
 490                         http_send_content_disposition(Z_STRVAL_P(dispo_file), Z_STRLEN_P(dispo_file), (zend_bool) Z_LVAL_P(dispo_inline));
 491                 }
 492         }
 493
 494         /* send */
 495         {
 496                 zval *send_mode = GET_PROP(obj, send_mode);
 497                 switch (Z_LVAL_P(send_mode))
 498                 {
 499                         case SEND_DATA:
 500                         {
 501                                 zval *zdata = GET_PROP(obj, data);
 502                                 RETURN_SUCCESS(http_send_data(Z_STRVAL_P(zdata), Z_STRLEN_P(zdata)));
 503                         }
 504
 505                         case SEND_RSRC:
 506                         {
 507                                 php_stream *the_real_stream;
 508                                 zval *the_stream = GET_PROP(obj, stream);
 509                                 php_stream_from_zval(the_real_stream, &the_stream);
 510                                 RETURN_SUCCESS(http_send_stream(the_real_stream));
 511                         }
 512
 513                         default:
 514                         {
 515                                 zval *zfile = GET_PROP(obj, file);
 516                                 RETURN_SUCCESS(http_send_file(Z_STRVAL_P(zfile)));
 517                         }
 518                 }
 519         }
 520 }
 521 /* }}} */
 522 /* }}} */
 523
 524 /* {{{ HttpMessage */
 525
 526 /* {{{ static HttpMessage HttpMessage::fromString(string raw_message)
 527  *
 528  * Create an HttpMessage object from a string.
 529  */
 530 PHP_METHOD(HttpMessage, fromString)
 531 {
 532         char *string = NULL;
 533         int length = 0;
 534         http_message *msg = NULL;
 535
 536         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &string, &length)) {
 537                 RETURN_NULL();
 538         }
 539
 540         if (!(msg = http_message_parse(string, length))) {
 541                 RETURN_NULL();
 542         }
 543
 544         Z_TYPE_P(return_value) = IS_OBJECT;
 545         return_value->value.obj = http_message_object_from_msg(msg);
 546 }
 547 /* }}} */
 548
 549 /* {{{ void HttpMessage::__construct([string raw_message])
 550  *
 551  * Instantiate a new HttpMessage object based on the optionally provided
 552  * raw message.  An HTTP Message can be either a response or a request.
 553  */
 554 PHP_METHOD(HttpMessage, __construct)
 555 {
 556         zval *message = NULL;
 557         getObject(http_message_object, obj);
 558
 559         SET_EH_THROW_HTTP();
 560         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z/", &message)) {
 561                 if (message) {
 562                         convert_to_string(message);
 563                         SET_PROP(obj, raw, message);
 564                 }
 565         }
 566         SET_EH_NORMAL();
 567 }
 568 /* }}} */
 569
 570 /* {{{ void HttpMessage::setRaw(string raw_message)
 571  *
 572  * Parse a new raw message.
 573  */
 574 PHP_METHOD(HttpMessage, setRaw)
 575 {
 576         zval *message;
 577         getObject(http_message_object, obj);
 578
 579         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/", &message)) {
 580                 return;
 581         }
 582
 583         convert_to_string(message);
 584         SET_PROP(obj, raw, message);
 585 }
 586 /* }}} */
 587
 588 /* {{{ string HttpMessage::getBody()
 589  *
 590  * Get the body of the parsed Message.
 591  */
 592 PHP_METHOD(HttpMessage, getBody)
 593 {
 594         zval *body;
 595         getObject(http_message_object, obj);
 596
 597         NO_ARGS;
 598
 599         body = GET_PROP(obj, body);
 600         RETURN_STRINGL(Z_STRVAL_P(body), Z_STRLEN_P(body), 1);
 601 }
 602 /* }}} */
 603
 604 /* {{{ array HttpMessage::getHeaders()
 605  *
 606  * Get Message Headers.
 607  */
 608 PHP_METHOD(HttpMessage, getHeaders)
 609 {
 610         zval *headers;
 611         getObject(http_message_object, obj);
 612
 613         NO_ARGS;
 614
 615         headers = GET_PROP(obj, headers);
 616         array_init(return_value);
 617         array_copy(headers, return_value);
 618 }
 619 /* }}} */
 620
 621 /* {{{ long HttpMessage::getType()
 622  *
 623  * Get Message Type. (HTTP_MSG_NONE|HTTP_MSG_REQUEST|HTTP_MSG_RESPONSE)
 624  */
 625 PHP_METHOD(HttpMessage, getType)
 626 {
 627         zval *type;
 628         getObject(http_message_object, obj);
 629
 630         NO_ARGS;
 631
 632         type = GET_PROP(obj, type);
 633         RETURN_LONG(Z_LVAL_P(type));
 634 }
 635 /* }}} */
 636
 637 /* {{{ int HttpMessage::getResponseCode()
 638  *
 639  * Get the Response Code of the Message.
 640  */
 641 PHP_METHOD(HttpMessage, getResponseCode)
 642 {
 643         zval *status;
 644         getObject(http_message_object, obj);
 645
 646         NO_ARGS;
 647
 648         if (obj->message->type != HTTP_MSG_RESPONSE) {
 649                 RETURN_NULL();
 650         }
 651
 652         status = GET_PROP(obj, responseCode);
 653         RETURN_LONG(Z_LVAL_P(status));
 654 }
 655 /* }}} */
 656
 657 /* {{{ string HttpMessage::getRequestMethod()
 658  *
 659  * Get the Request Method of the Message.
 660  */
 661 PHP_METHOD(HttpMessage, getRequestMethod)
 662 {
 663         zval *method;
 664         getObject(http_message_object, obj);
 665
 666         NO_ARGS;
 667
 668         if (obj->message->type != HTTP_MSG_REQUEST) {
 669                 RETURN_NULL();
 670         }
 671
 672         method = GET_PROP(obj, requestMethod);
 673         RETURN_STRINGL(Z_STRVAL_P(method), Z_STRLEN_P(method), 1);
 674 }
 675 /* }}} */
 676
 677 /* {{{ string HttpMessage::getRequestUri()
 678  *
 679  * Get the Request URI of the Message.
 680  */
 681 PHP_METHOD(HttpMessage, getRequestUri)
 682 {
 683         zval *uri;
 684         getObject(http_message_object, obj);
 685
 686         NO_ARGS;
 687
 688         if (obj->message->type != HTTP_MSG_REQUEST) {
 689                 RETURN_NULL();
 690         }
 691
 692         uri = GET_PROP(obj, requestUri);
 693         RETURN_STRINGL(Z_STRVAL_P(uri), Z_STRLEN_P(uri), 1);
 694 }
 695 /* }}} */
 696
 697 /* {{{ string HttpMessage::getHttpVersion()
 698  *
 699  * Get the HTTP Protocol Version of the Message.
 700  */
 701 PHP_METHOD(HttpMessage, getHttpVersion)
 702 {
 703         zval *version;
 704         char ver[4] = {0};
 705         getObject(http_message_object, obj);
 706
 707         NO_ARGS;
 708
 709         version = GET_PROP(obj, httpVersion);
 710
 711         if (Z_TYPE_P(version) == IS_NULL) {
 712                 RETURN_NULL();
 713         }
 714
 715         sprintf(ver, "1.1f", Z_DVAL_P(version));
 716         RETURN_STRINGL(ver, 3, 1);
 717 }
 718 /* }}} */
 719
 720 /* {{{ string HttpMessage::toString()
 721  *
 722  * Get the string representation of the Message.
 723  */
 724 PHP_METHOD(HttpMessage, toString)
 725 {
 726         char *string;
 727         size_t length;
 728         getObject(http_message_object, obj);
 729
 730         NO_ARGS;
 731
 732         http_message_tostring(obj->message, &string, &length);
 733         RETURN_STRINGL(string, length, 0);
 734 }
 735 /* }}} */
 736
 737 /* }}} */
 738
 739 #ifdef HTTP_HAVE_CURL
 740 /* {{{ HttpRequest */
 741
 742 /* {{{ proto void HttpRequest::__construct([string url[, long request_method = HTTP_GET]])
 743  *
 744  * Instantiate a new HttpRequest object which can be used to issue HEAD, GET
 745  * and POST (including posting files) HTTP requests.
 746  */
 747 PHP_METHOD(HttpRequest, __construct)
 748 {
 749         char *URL = NULL;
 750         int URL_len;
 751         long meth = -1;
 752         getObject(http_request_object, obj);
 753
 754         SET_EH_THROW_HTTP();
 755         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sl", &URL, &URL_len, &meth)) {
 756                 INIT_PARR(obj, options);
 757                 INIT_PARR(obj, responseInfo);
 758                 INIT_PARR(obj, responseData);
 759                 INIT_PARR(obj, postData);
 760                 INIT_PARR(obj, postFiles);
 761
 762                 if (URL) {
 763                         UPD_PROP(obj, string, url, URL);
 764                 }
 765                 if (meth > -1) {
 766                         UPD_PROP(obj, long, method, meth);
 767                 }
 768         }
 769         SET_EH_NORMAL();
 770 }
 771 /* }}} */
 772
 773 /* {{{ proto void HttpRequest::__destruct()
 774  *
 775  * Destroys the HttpRequest object.
 776  */
 777 PHP_METHOD(HttpRequest, __destruct)
 778 {
 779         getObject(http_request_object, obj);
 780
 781         NO_ARGS;
 782
 783         FREE_PARR(obj, options);
 784         FREE_PARR(obj, responseInfo);
 785         FREE_PARR(obj, responseData);
 786         FREE_PARR(obj, postData);
 787         FREE_PARR(obj, postFiles);
 788 }
 789 /* }}} */
 790
 791 /* {{{ proto bool HttpRequest::setOptions(array options)
 792  *
 793  * Set the request options to use.  See http_get() for a full list of available options.
 794  */
 795 PHP_METHOD(HttpRequest, setOptions)
 796 {
 797         char *key = NULL;
 798         long idx = 0;
 799         zval *opts, *old_opts, **opt;
 800         getObject(http_request_object, obj);
 801
 802         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/", &opts)) {
 803                 RETURN_FALSE;
 804         }
 805
 806         old_opts = GET_PROP(obj, options);
 807
 808         /* headers and cookies need extra attention -- thus cannot use array_merge() directly */
 809         FOREACH_KEYVAL(opts, key, idx, opt) {
 810                 if (key) {
 811                         if (!strcmp(key, "headers")) {
 812                                 zval **headers;
 813                                 if (SUCCESS == zend_hash_find(Z_ARRVAL_P(old_opts), "headers", sizeof("headers"), (void **) &headers)) {
 814                                         array_merge(*opt, *headers);
 815                                         continue;
 816                                 }
 817                         } else if (!strcmp(key, "cookies")) {
 818                                 zval **cookies;
 819                                 if (SUCCESS == zend_hash_find(Z_ARRVAL_P(old_opts), "cookies", sizeof("cookies"), (void **) &cookies)) {
 820                                         array_merge(*opt, *cookies);
 821                                         continue;
 822                                 }
 823                         }
 824                         zval_add_ref(opt);
 825                         add_assoc_zval(old_opts, key, *opt);
 826
 827                         /* reset */
 828                         key = NULL;
 829                 }
 830         }
 831
 832         RETURN_TRUE;
 833 }
 834 /* }}} */
 835
 836 /* {{{ proto array HttpRequest::getOptions()
 837  *
 838  * Get current set options.
 839  */
 840 PHP_METHOD(HttpRequest, getOptions)
 841 {
 842         zval *opts;
 843         getObject(http_request_object, obj);
 844
 845         NO_ARGS;
 846
 847         opts = GET_PROP(obj, options);
 848         array_init(return_value);
 849         array_copy(opts, return_value);
 850 }
 851 /* }}} */
 852
 853 /* {{{ proto void HttpRequest::unsetOptions()
 854  *
 855  * Unset all options/headers/cookies.
 856  */
 857 PHP_METHOD(HttpRequest, unsetOptions)
 858 {
 859         getObject(http_request_object, obj);
 860
 861         NO_ARGS;
 862
 863         FREE_PARR(obj, options);
 864         INIT_PARR(obj, options);
 865 }
 866 /* }}} */
 867
 868 /* {{{ proto bool HttpRequest::setSslOptions(array options)
 869  *
 870  * Set additional SSL options.
 871  */
 872 PHP_METHOD(HttpRequest, setSslOptions)
 873 {
 874         zval *opts, *old_opts, **ssl_options;
 875         getObject(http_request_object, obj);
 876
 877         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/", &opts)) {
 878                 RETURN_FALSE;
 879         }
 880
 881         old_opts = GET_PROP(obj, options);
 882
 883         if (SUCCESS == zend_hash_find(Z_ARRVAL_P(old_opts), "ssl", sizeof("ssl"), (void **) &ssl_options)) {
 884                 array_merge(opts, *ssl_options);
 885         } else {
 886                 zval_add_ref(&opts);
 887                 add_assoc_zval(old_opts, "ssl", opts);
 888         }
 889
 890         RETURN_TRUE;
 891 }
 892 /* }}} */
 893
 894 /* {{{ proto array HttpRequest::getSslOtpions()
 895  *
 896  * Get previously set SSL options.
 897  */
 898 PHP_METHOD(HttpRequest, getSslOptions)
 899 {
 900         zval *opts, **ssl_options;
 901         getObject(http_request_object, obj);
 902
 903         NO_ARGS;
 904
 905         opts = GET_PROP(obj, options);
 906
 907         array_init(return_value);
 908
 909         if (SUCCESS == zend_hash_find(Z_ARRVAL_P(opts), "ssl", sizeof("ssl"), (void **) &ssl_options)) {
 910                 array_copy(*ssl_options, return_value);
 911         }
 912 }
 913 /* }}} */
 914
 915 /* {{{ proto void HttpRequest::unsetSslOptions()
 916  *
 917  * Unset previously set SSL options.
 918  */
 919 PHP_METHOD(HttpRequest, unsetSslOptions)
 920 {
 921         zval *opts;
 922         getObject(http_request_object, obj);
 923
 924         NO_ARGS;
 925
 926         opts = GET_PROP(obj, options);
 927         zend_hash_del(Z_ARRVAL_P(opts), "ssl", sizeof("ssl"));
 928 }
 929 /* }}} */
 930
 931 /* {{{ proto bool HttpRequest::addHeaders(array headers)
 932  *
 933  * Add request header name/value pairs.
 934  */
 935 PHP_METHOD(HttpRequest, addHeaders)
 936 {
 937         zval *opts, **headers, *new_headers;
 938         getObject(http_request_object, obj);
 939
 940         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/", &new_headers)) {
 941                 RETURN_FALSE;
 942         }
 943
 944         opts = GET_PROP(obj, options);
 945
 946         if (SUCCESS == zend_hash_find(Z_ARRVAL_P(opts), "headers", sizeof("headers"), (void **) &headers)) {
 947                 array_merge(new_headers, *headers);
 948         } else {
 949                 zval_add_ref(&new_headers);
 950                 add_assoc_zval(opts, "headers", new_headers);
 951         }
 952
 953         RETURN_TRUE;
 954 }
 955 /* }}} */
 956
 957 /* {{{ proto array HttpRequest::getHeaders()
 958  *
 959  * Get previously set request headers.
 960  */
 961 PHP_METHOD(HttpRequest, getHeaders)
 962 {
 963         zval *opts, **headers;
 964         getObject(http_request_object, obj);
 965
 966         NO_ARGS;
 967
 968         opts = GET_PROP(obj, options);
 969
 970         array_init(return_value);
 971
 972         if (SUCCESS == zend_hash_find(Z_ARRVAL_P(opts), "headers", sizeof("headers"), (void **) &headers)) {
 973                 array_copy(*headers, return_value);
 974         }
 975 }
 976 /* }}} */
 977
 978 /* {{{ proto void HttpRequest::unsetHeaders()
 979  *
 980  * Unset previously set request headers.
 981  */
 982 PHP_METHOD(HttpRequest, unsetHeaders)
 983 {
 984         zval *opts;
 985         getObject(http_request_object, obj);
 986
 987         NO_ARGS;
 988
 989         opts = GET_PROP(obj, options);
 990         zend_hash_del(Z_ARRVAL_P(opts), "headers", sizeof("headers"));
 991 }
 992 /* }}} */
 993
 994 /* {{{ proto bool HttpRequest::addCookies(array cookies)
 995  *
 996  * Add cookies.
 997  */
 998 PHP_METHOD(HttpRequest, addCookies)
 999 {
1000         zval *opts, **cookies, *new_cookies;
1001         getObject(http_request_object, obj);
1002
1003         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/", &new_cookies)) {
1004                 RETURN_FALSE;
1005         }
1006
1007         opts = GET_PROP(obj, options);
1008
1009         if (SUCCESS == zend_hash_find(Z_ARRVAL_P(opts), "cookies", sizeof("cookies"), (void **) &cookies)) {
1010                 array_merge(new_cookies, *cookies);
1011         } else {
1012                 zval_add_ref(&new_cookies);
1013                 add_assoc_zval(opts, "cookies", new_cookies);
1014         }
1015
1016         RETURN_TRUE;
1017 }
1018 /* }}} */
1019
1020 /* {{{ proto array HttpRequest::getCookies()
1021  *
1022  * Get previously set cookies.
1023  */
1024 PHP_METHOD(HttpRequest, getCookies)
1025 {
1026         zval *opts, **cookies;
1027         getObject(http_request_object, obj);
1028
1029         NO_ARGS;
1030
1031         opts = GET_PROP(obj, options);
1032
1033         array_init(return_value);
1034
1035         if (SUCCESS == zend_hash_find(Z_ARRVAL_P(opts), "cookies", sizeof("cookies"), (void **) &cookies)) {
1036                 array_copy(*cookies, return_value);
1037         }
1038 }
1039 /* }}} */
1040
1041 /* {{{ proto void HttpRequest::unsetCookies()
1042  *
1043  */
1044 PHP_METHOD(HttpRequest, unsetCookies)
1045 {
1046         zval *opts;
1047         getObject(http_request_object, obj);
1048
1049         NO_ARGS;
1050
1051         opts = GET_PROP(obj, options);
1052         zend_hash_del(Z_ARRVAL_P(opts), "cookies", sizeof("cookies"));
1053 }
1054 /* }}} */
1055
1056 /* {{{ proto bool HttpRequest::setURL(string url)
1057  *
1058  * Set the request URL.
1059  */
1060 PHP_METHOD(HttpRequest, setURL)
1061 {
1062         char *URL = NULL;
1063         int URL_len;
1064         getObject(http_request_object, obj);
1065
1066         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &URL, &URL_len)) {
1067                 RETURN_FALSE;
1068         }
1069
1070         UPD_PROP(obj, string, url, URL);
1071         RETURN_TRUE;
1072 }
1073 /* }}} */
1074
1075 /* {{{ proto string HttpRequest::getUrl()
1076  *
1077  * Get the previously set request URL.
1078  */
1079 PHP_METHOD(HttpRequest, getURL)
1080 {
1081         zval *URL;
1082         getObject(http_request_object, obj);
1083
1084         NO_ARGS;
1085
1086         URL = GET_PROP(obj, url);
1087         RETURN_STRINGL(Z_STRVAL_P(URL), Z_STRLEN_P(URL), 1);
1088 }
1089 /* }}} */
1090
1091 /* {{{ proto bool HttpRequest::setMethod(long request_method)
1092  *
1093  * Set the request methods; one of the <tt>HTTP_HEAD</tt>, <tt>HTTP_GET</tt> or
1094  * <tt>HTTP_POST</tt> constants.
1095  */
1096 PHP_METHOD(HttpRequest, setMethod)
1097 {
1098         long meth;
1099         getObject(http_request_object, obj);
1100
1101         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &meth)) {
1102                 RETURN_FALSE;
1103         }
1104
1105         UPD_PROP(obj, long, method, meth);
1106         RETURN_TRUE;
1107 }
1108 /* }}} */
1109
1110 /* {{{ proto long HttpRequest::getMethod()
1111  *
1112  * Get the previously set request method.
1113  */
1114 PHP_METHOD(HttpRequest, getMethod)
1115 {
1116         zval *meth;
1117         getObject(http_request_object, obj);
1118
1119         NO_ARGS;
1120
1121         meth = GET_PROP(obj, method);
1122         RETURN_LONG(Z_LVAL_P(meth));
1123 }
1124 /* }}} */
1125
1126 /* {{{ proto bool HttpRequest::setContentType(string content_type)
1127  *
1128  * Set the content type the post request should have.
1129  * Use this only if you know what you're doing.
1130  */
1131 PHP_METHOD(HttpRequest, setContentType)
1132 {
1133         char *ctype;
1134         int ct_len;
1135         getObject(http_request_object, obj);
1136
1137         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &ctype, &ct_len)) {
1138                 RETURN_FALSE;
1139         }
1140
1141         if (!strchr(ctype, '/')) {
1142                 php_error_docref(NULL TSRMLS_CC, E_WARNING,
1143                         "Content-Type '%s' doesn't seem to contain a primary and a secondary part",
1144                         ctype);
1145                 RETURN_FALSE;
1146         }
1147
1148         UPD_PROP(obj, string, contentType, ctype);
1149         RETURN_TRUE;
1150 }
1151 /* }}} */
1152
1153 /* {{{ proto string HttpRequest::getContentType()
1154  *
1155  * Get the previously content type.
1156  */
1157 PHP_METHOD(HttpRequest, getContentType)
1158 {
1159         zval *ctype;
1160         getObject(http_request_object, obj);
1161
1162         NO_ARGS;
1163
1164         ctype = GET_PROP(obj, contentType);
1165         RETURN_STRINGL(Z_STRVAL_P(ctype), Z_STRLEN_P(ctype), 1);
1166 }
1167 /* }}} */
1168
1169 /* {{{ proto bool HttpRequest::setQueryData(mixed query_data)
1170  *
1171  * Set the URL query parameters to use.
1172  * Overwrites previously set query parameters.
1173  * Affects any request types.
1174  */
1175 PHP_METHOD(HttpRequest, setQueryData)
1176 {
1177         zval *qdata;
1178         char *query_data = NULL;
1179         getObject(http_request_object, obj);
1180
1181         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &qdata)) {
1182                 RETURN_FALSE;
1183         }
1184
1185         if ((Z_TYPE_P(qdata) == IS_ARRAY) || (Z_TYPE_P(qdata) == IS_OBJECT)) {
1186                 if (SUCCESS != http_urlencode_hash(HASH_OF(qdata), &query_data)) {
1187                         RETURN_FALSE;
1188                 }
1189                 UPD_PROP(obj, string, queryData, query_data);
1190                 efree(query_data);
1191                 RETURN_TRUE;
1192         }
1193
1194         convert_to_string(qdata);
1195         UPD_PROP(obj, string, queryData, Z_STRVAL_P(qdata));
1196         RETURN_TRUE;
1197 }
1198 /* }}} */
1199
1200 /* {{{ proto string HttpRequest::getQueryData()
1201  *
1202  * Get the current query data in form of an urlencoded query string.
1203  */
1204 PHP_METHOD(HttpRequest, getQueryData)
1205 {
1206         zval *qdata;
1207         getObject(http_request_object, obj);
1208
1209         NO_ARGS;
1210
1211         qdata = GET_PROP(obj, queryData);
1212         RETURN_STRINGL(Z_STRVAL_P(qdata), Z_STRLEN_P(qdata), 1);
1213 }
1214 /* }}} */
1215
1216 /* {{{ proto bool HttpRequest::addQueryData(array query_params)
1217  *
1218  * Add parameters to the query parameter list.
1219  * Affects any request type.
1220  */
1221 PHP_METHOD(HttpRequest, addQueryData)
1222 {
1223         zval *qdata, *old_qdata;
1224         char *query_data = NULL;
1225         getObject(http_request_object, obj);
1226
1227         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &qdata)) {
1228                 RETURN_FALSE;
1229         }
1230
1231         old_qdata = GET_PROP(obj, queryData);
1232
1233         if (SUCCESS != http_urlencode_hash_ex(HASH_OF(qdata), 1, Z_STRVAL_P(old_qdata), Z_STRLEN_P(old_qdata), &query_data, NULL)) {
1234                 RETURN_FALSE;
1235         }
1236
1237         UPD_PROP(obj, string, queryData, query_data);
1238         efree(query_data);
1239
1240         RETURN_TRUE;
1241 }
1242 /* }}} */
1243
1244 /* {{{ proto void HttpRequest::unsetQueryData()
1245  *
1246  * Clean the query parameters.
1247  * Affects any request type.
1248  */
1249 PHP_METHOD(HttpRequest, unsetQueryData)
1250 {
1251         getObject(http_request_object, obj);
1252
1253         NO_ARGS;
1254
1255         UPD_PROP(obj, string, queryData, "");
1256 }
1257 /* }}} */
1258
1259 /* {{{ proto bool HttpRequest::addPostData(array post_data)
1260  *
1261  * Adds POST data entries.
1262  * Affects only POST requests.
1263  */
1264 PHP_METHOD(HttpRequest, addPostData)
1265 {
1266         zval *post, *post_data;
1267         getObject(http_request_object, obj);
1268
1269         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &post_data)) {
1270                 RETURN_FALSE;
1271         }
1272
1273         post = GET_PROP(obj, postData);
1274         array_merge(post_data, post);
1275
1276         RETURN_TRUE;
1277 }
1278 /* }}} */
1279
1280 /* {{{ proto bool HttpRequest::setPostData(array post_data)
1281  *
1282  * Set the POST data entries.
1283  * Overwrites previously set POST data.
1284  * Affects only POST requests.
1285  */
1286 PHP_METHOD(HttpRequest, setPostData)
1287 {
1288         zval *post, *post_data;
1289         getObject(http_request_object, obj);
1290
1291         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &post_data)) {
1292                 RETURN_FALSE;
1293         }
1294
1295         post = GET_PROP(obj, postData);
1296         zend_hash_clean(Z_ARRVAL_P(post));
1297         array_copy(post_data, post);
1298
1299         RETURN_TRUE;
1300 }
1301 /* }}}*/
1302
1303 /* {{{ proto array HttpRequest::getPostData()
1304  *
1305  * Get previously set POST data.
1306  */
1307 PHP_METHOD(HttpRequest, getPostData)
1308 {
1309         zval *post_data;
1310         getObject(http_request_object, obj);
1311
1312         NO_ARGS;
1313
1314         post_data = GET_PROP(obj, postData);
1315         array_init(return_value);
1316         array_copy(post_data, return_value);
1317 }
1318 /* }}} */
1319
1320 /* {{{ proto void HttpRequest::unsetPostData()
1321  *
1322  * Clean POST data entires.
1323  * Affects only POST requests.
1324  */
1325 PHP_METHOD(HttpRequest, unsetPostData)
1326 {
1327         zval *post_data;
1328         getObject(http_request_object, obj);
1329
1330         NO_ARGS;
1331
1332         post_data = GET_PROP(obj, postData);
1333         zend_hash_clean(Z_ARRVAL_P(post_data));
1334 }
1335 /* }}} */
1336
1337 /* {{{ proto bool HttpRequest::addPostFile(string name, string file[, string content_type = "application/x-octetstream"])
1338  *
1339  * Add a file to the POST request.
1340  * Affects only POST requests.
1341  */
1342 PHP_METHOD(HttpRequest, addPostFile)
1343 {
1344         zval *files, *entry;
1345         char *name, *file, *type = NULL;
1346         int name_len, file_len, type_len = 0;
1347         getObject(http_request_object, obj);
1348
1349         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|s", &name, &name_len, &file, &file_len, &type, &type_len)) {
1350                 RETURN_FALSE;
1351         }
1352
1353         if (type_len) {
1354                 if (!strchr(type, '/')) {
1355                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Content-Type '%s' doesn't seem to contain a primary and a secondary part", type);
1356                         RETURN_FALSE;
1357                 }
1358         } else {
1359                 type = "application/x-octetstream";
1360                 type_len = sizeof("application/x-octetstream") - 1;
1361         }
1362
1363         MAKE_STD_ZVAL(entry);
1364         array_init(entry);
1365
1366         add_assoc_stringl(entry, "name", name, name_len, 1);
1367         add_assoc_stringl(entry, "type", type, type_len, 1);
1368         add_assoc_stringl(entry, "file", file, file_len, 1);
1369
1370         files  = GET_PROP(obj, postFiles);
1371         add_next_index_zval(files, entry);
1372
1373         RETURN_TRUE;
1374 }
1375 /* }}} */
1376
1377 /* {{{ proto array HttpRequest::getPostFiles()
1378  *
1379  * Get all previously added POST files.
1380  */
1381 PHP_METHOD(HttpRequest, getPostFiles)
1382 {
1383         zval *files;
1384         getObject(http_request_object, obj);
1385
1386         NO_ARGS;
1387
1388         files = GET_PROP(obj, postFiles);
1389
1390         array_init(return_value);
1391         array_copy(files, return_value);
1392 }
1393 /* }}} */
1394
1395 /* {{{ proto void HttpRequest::unsetPostFiles()
1396  *
1397  * Unset the POST files list.
1398  * Affects only POST requests.
1399  */
1400 PHP_METHOD(HttpRequest, unsetPostFiles)
1401 {
1402         zval *files;
1403         getObject(http_request_object, obj);
1404
1405         NO_ARGS;
1406
1407         files = GET_PROP(obj, postFiles);
1408         zend_hash_clean(Z_ARRVAL_P(files));
1409 }
1410 /* }}} */
1411
1412 /* {{{ proto array HttpRequest::getResponseData()
1413  *
1414  * Get all response data after the request has been sent.
1415  */
1416 PHP_METHOD(HttpRequest, getResponseData)
1417 {
1418         zval *data;
1419         getObject(http_request_object, obj);
1420
1421         NO_ARGS;
1422
1423         data = GET_PROP(obj, responseData);
1424         array_init(return_value);
1425         array_copy(data, return_value);
1426 }
1427 /* }}} */
1428
1429 /* {{{ proto mixed HttpRequest::getResponseHeader([string name])
1430  *
1431  * Get response header(s) after the request has been sent.
1432  */
1433 PHP_METHOD(HttpRequest, getResponseHeader)
1434 {
1435         zval *data, **headers, **header;
1436         char *header_name = NULL;
1437         int header_len = 0;
1438         getObject(http_response_object, obj);
1439
1440         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &header_name, &header_len)) {
1441                 RETURN_FALSE;
1442         }
1443
1444         data = GET_PROP(obj, responseData);
1445         if (SUCCESS != zend_hash_find(Z_ARRVAL_P(data), "headers", sizeof("headers"), (void **) &headers)) {
1446                 RETURN_FALSE;
1447         }
1448
1449         if (!header_len || !header_name) {
1450                 array_init(return_value);
1451                 array_copy(*headers, return_value);
1452         } else if (SUCCESS == zend_hash_find(Z_ARRVAL_PP(headers), pretty_key(header_name, header_len, 1, 1), header_len + 1, (void **) &header)) {
1453                 RETURN_STRINGL(Z_STRVAL_PP(header), Z_STRLEN_PP(header), 1);
1454         } else {
1455                 RETURN_FALSE;
1456         }
1457 }
1458 /* }}} */
1459
1460 /* {{{ proto array HttpRequest::getResponseCookie([string name])
1461  *
1462  * Get response cookie(s) after the request has been sent.
1463  */
1464 PHP_METHOD(HttpRequest, getResponseCookie)
1465 {
1466         zval *data, **headers;
1467         char *cookie_name = NULL;
1468         int cookie_len = 0;
1469         getObject(http_request_object, obj);
1470
1471         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &cookie_name, &cookie_len)) {
1472                 RETURN_FALSE;
1473         }
1474
1475         array_init(return_value);
1476
1477         data = GET_PROP(obj, responseData);
1478         if (SUCCESS == zend_hash_find(Z_ARRVAL_P(data), "headers", sizeof("headers"), (void **) &headers)) {
1479                 ulong idx = 0;
1480                 char *key = NULL;
1481                 zval **header = NULL;
1482
1483                 FOREACH_HASH_KEYVAL(Z_ARRVAL_PP(headers), key, idx, header) {
1484                         if (key && !strcasecmp(key, "Set-Cookie")) {
1485                                 /* several cookies? */
1486                                 if (Z_TYPE_PP(header) == IS_ARRAY) {
1487                                         zval **cookie;
1488
1489                                         FOREACH_HASH_VAL(Z_ARRVAL_PP(header), cookie) {
1490                                                 zval *cookie_hash;
1491                                                 MAKE_STD_ZVAL(cookie_hash);
1492                                                 array_init(cookie_hash);
1493
1494                                                 if (SUCCESS == http_parse_cookie(Z_STRVAL_PP(cookie), Z_ARRVAL_P(cookie_hash))) {
1495                                                         if (!cookie_len) {
1496                                                                 add_next_index_zval(return_value, cookie_hash);
1497                                                         } else {
1498                                                                 zval **name;
1499
1500                                                                 if (    (SUCCESS == zend_hash_find(Z_ARRVAL_P(cookie_hash), "name", sizeof("name"), (void **) &name)) &&
1501                                                                                 (!strcmp(Z_STRVAL_PP(name), cookie_name))) {
1502                                                                         add_next_index_zval(return_value, cookie_hash);
1503                                                                         return; /* <<< FOUND >>> */
1504                                                                 } else {
1505                                                                         zval_dtor(cookie_hash);
1506                                                                         efree(cookie_hash);
1507                                                                 }
1508                                                         }
1509                                                 } else {
1510                                                         zval_dtor(cookie_hash);
1511                                                         efree(cookie_hash);
1512                                                 }
1513                                         }
1514                                 } else {
1515                                         zval *cookie_hash;
1516                                         MAKE_STD_ZVAL(cookie_hash);
1517                                         array_init(cookie_hash);
1518
1519                                         if (SUCCESS == http_parse_cookie(Z_STRVAL_PP(header), Z_ARRVAL_P(cookie_hash))) {
1520                                                 if (!cookie_len) {
1521                                                         add_next_index_zval(return_value, cookie_hash);
1522                                                 } else {
1523                                                         zval **name;
1524
1525                                                         if (    (SUCCESS == zend_hash_find(Z_ARRVAL_P(cookie_hash), "name", sizeof("name"), (void **) &name)) &&
1526                                                                         (!strcmp(Z_STRVAL_PP(name), cookie_name))) {
1527                                                                 add_next_index_zval(return_value, cookie_hash);
1528                                                         } else {
1529                                                                 zval_dtor(cookie_hash);
1530                                                                 efree(cookie_hash);
1531                                                         }
1532                                                 }
1533                                         } else {
1534                                                 zval_dtor(cookie_hash);
1535                                                 efree(cookie_hash);
1536                                         }
1537                                 }
1538                                 break;
1539                         }
1540                         /* reset key */
1541                         key = NULL;
1542                 }
1543         }
1544 }
1545 /* }}} */
1546
1547 /* {{{ proto string HttpRequest::getResponseBody()
1548  *
1549  * Get the response body after the request has been sent.
1550  */
1551 PHP_METHOD(HttpRequest, getResponseBody)
1552 {
1553         zval *data, **body;
1554         getObject(http_request_object, obj);
1555
1556         NO_ARGS;
1557
1558         data = GET_PROP(obj, responseData);
1559         if (SUCCESS == zend_hash_find(Z_ARRVAL_P(data), "body", sizeof("body"), (void **) &body)) {
1560                 RETURN_STRINGL(Z_STRVAL_PP(body), Z_STRLEN_PP(body), 1);
1561         } else {
1562                 RETURN_FALSE;
1563         }
1564 }
1565 /* }}} */
1566
1567 /* {{{ proto int HttpRequest::getResponseCode()
1568  *
1569  * Get the response code after the request has been sent.
1570  */
1571 PHP_METHOD(HttpRequest, getResponseCode)
1572 {
1573         zval **code, **hdrs, *data;
1574         getObject(http_request_object, obj);
1575
1576         NO_ARGS;
1577
1578         data = GET_PROP(obj, responseData);
1579         if (    (SUCCESS == zend_hash_find(Z_ARRVAL_P(data), "headers", sizeof("headers"), (void **) &hdrs)) &&
1580                         (SUCCESS == zend_hash_find(Z_ARRVAL_PP(hdrs), "Response Status", sizeof("Response Status"), (void **) &code))) {
1581                 RETVAL_STRINGL(Z_STRVAL_PP(code), Z_STRLEN_PP(code), 1);
1582                 convert_to_long(return_value);
1583         } else {
1584                 RETURN_FALSE;
1585         }
1586 }
1587 /* }}} */
1588
1589 /* {{{ proto array HttpRequest::getResponseInfo([string name])
1590  *
1591  * Get response info after the request has been sent.
1592  * See http_get() for a full list of returned info.
1593  */
1594 PHP_METHOD(HttpRequest, getResponseInfo)
1595 {
1596         zval *info, **infop;
1597         char *info_name = NULL;
1598         int info_len = 0;
1599         getObject(http_request_object, obj);
1600
1601         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &info_name, &info_len)) {
1602                 RETURN_FALSE;
1603         }
1604
1605         info = GET_PROP(obj, responseInfo);
1606
1607         if (info_len && info_name) {
1608                 if (SUCCESS == zend_hash_find(Z_ARRVAL_P(info), pretty_key(info_name, info_len, 0, 0), info_len + 1, (void **) &infop)) {
1609                         RETURN_ZVAL(*infop, 1, ZVAL_PTR_DTOR);
1610                 } else {
1611                         php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Could not find response info named %s", info_name);
1612                         RETURN_FALSE;
1613                 }
1614         } else {
1615                 array_init(return_value);
1616                 array_copy(info, return_value);
1617         }
1618 }
1619 /* }}}*/
1620
1621 /* {{{ proto bool HttpRequest::send()
1622  *
1623  * Send the HTTP request.
1624  *
1625  * GET example:
1626  * <pre>
1627  * <?php
1628  * $r = new HttpRequest('http://example.com/feed.rss', HTTP_GET);
1629  * $r->setOptions(array('lastmodified' => filemtime('local.rss')));
1630  * $r->addQueryData(array('category' => 3));
1631  * if ($r->send() && $r->getResponseCode() == 200) {
1632  *     file_put_contents('local.rss', $r->getResponseBody());
1633  * }
1634  * ?>
1635  * </pre>
1636  *
1637  * POST example:
1638  * <pre>
1639  * <?php
1640  * $r = new HttpRequest('http://example.com/form.php', HTTP_POST);
1641  * $r->setOptions(array('cookies' => array('lang' => 'de')));
1642  * $r->addPostData(array('user' => 'mike', 'pass' => 's3c|r3t'));
1643  * $r->addPostFile('image', 'profile.jpg', 'image/jpeg');
1644  * if ($r->send()) {
1645  *     echo $r->getResponseBody();
1646  * }
1647  * ?>
1648  * </pre>
1649  */
1650 PHP_METHOD(HttpRequest, send)
1651 {
1652         STATUS status = FAILURE;
1653         zval *meth, *URL, *qdata, *opts, *info, *resp;
1654         char *response_data, *request_uri;
1655         size_t response_len;
1656         getObject(http_request_object, obj);
1657
1658         NO_ARGS;
1659
1660         SET_EH_THROW_HTTP();
1661
1662         if ((!obj->ch) && (!(obj->ch = curl_easy_init()))) {
1663                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not initilaize cURL");
1664                 RETURN_FALSE;
1665         }
1666
1667         meth  = GET_PROP(obj, method);
1668         URL   = GET_PROP(obj, url);
1669         qdata = GET_PROP(obj, queryData);
1670         opts  = GET_PROP(obj, options);
1671         info  = GET_PROP(obj, responseInfo);
1672         resp  = GET_PROP(obj, responseData);
1673
1674         // HTTP_URI_MAXLEN+1 long char *
1675         request_uri = http_absolute_uri_ex(Z_STRVAL_P(URL), Z_STRLEN_P(URL), NULL, 0, NULL, 0, 0);
1676
1677         if (Z_STRLEN_P(qdata) && (strlen(request_uri) < HTTP_URI_MAXLEN)) {
1678                 if (!strchr(request_uri, '?')) {
1679                         strcat(request_uri, "?");
1680                 } else {
1681                         strcat(request_uri, "&");
1682                 }
1683                 strncat(request_uri, Z_STRVAL_P(qdata), HTTP_URI_MAXLEN - strlen(request_uri));
1684         }
1685
1686         switch (Z_LVAL_P(meth))
1687         {
1688                 case HTTP_GET:
1689                         status = http_get_ex(obj->ch, request_uri, Z_ARRVAL_P(opts), Z_ARRVAL_P(info), &response_data, &response_len);
1690                 break;
1691
1692                 case HTTP_HEAD:
1693                         status = http_head_ex(obj->ch, request_uri, Z_ARRVAL_P(opts), Z_ARRVAL_P(info), &response_data, &response_len);
1694                 break;
1695
1696                 case HTTP_POST:
1697                         {
1698                                 zval *post_files, *post_data;
1699
1700                                 post_files = GET_PROP(obj, postFiles);
1701                                 post_data  = GET_PROP(obj, postData);
1702
1703                                 if (!zend_hash_num_elements(Z_ARRVAL_P(post_files))) {
1704
1705                                         /* urlencoded post */
1706                                         status = http_post_array_ex(obj->ch, request_uri, Z_ARRVAL_P(post_data), Z_ARRVAL_P(opts), Z_ARRVAL_P(info), &response_data, &response_len);
1707
1708                                 } else {
1709
1710                                         /*
1711                                          * multipart post
1712                                          */
1713                                         char *key = NULL;
1714                                         long idx;
1715                                         zval **data;
1716                                         struct curl_httppost *http_post_data[2] = {NULL, NULL};
1717
1718                                         /* normal data */
1719                                         FOREACH_KEYVAL(post_data, key, idx, data) {
1720                                                 if (key) {
1721                                                         convert_to_string_ex(data);
1722                                                         curl_formadd(&http_post_data[0], &http_post_data[1],
1723                                                                 CURLFORM_COPYNAME,                      key,
1724                                                                 CURLFORM_COPYCONTENTS,          Z_STRVAL_PP(data),
1725                                                                 CURLFORM_CONTENTSLENGTH,        Z_STRLEN_PP(data),
1726                                                                 CURLFORM_END
1727                                                         );
1728
1729                                                         /* reset */
1730                                                         key = NULL;
1731                                                 }
1732                                         }
1733
1734                                         /* file data */
1735                                         FOREACH_VAL(post_files, data) {
1736                                                 zval **file, **type, **name;
1737
1738                                                 if (    SUCCESS == zend_hash_find(Z_ARRVAL_PP(data), "name", sizeof("name"), (void **) &name) &&
1739                                                                 SUCCESS == zend_hash_find(Z_ARRVAL_PP(data), "type", sizeof("type"), (void **) &type) &&
1740                                                                 SUCCESS == zend_hash_find(Z_ARRVAL_PP(data), "file", sizeof("file"), (void **) &file)) {
1741
1742                                                         curl_formadd(&http_post_data[0], &http_post_data[1],
1743                                                                 CURLFORM_COPYNAME,              Z_STRVAL_PP(name),
1744                                                                 CURLFORM_FILE,                  Z_STRVAL_PP(file),
1745                                                                 CURLFORM_CONTENTTYPE,   Z_STRVAL_PP(type),
1746                                                                 CURLFORM_END
1747                                                         );
1748                                                 }
1749                                         }
1750
1751                                         status = http_post_curldata_ex(obj->ch, request_uri, http_post_data[0], Z_ARRVAL_P(opts), Z_ARRVAL_P(info), &response_data, &response_len);
1752                                         curl_formfree(http_post_data[0]);
1753                                 }
1754                         }
1755                 break;
1756
1757                 default:
1758                 break;
1759         }
1760
1761         efree(request_uri);
1762
1763         /* final data handling */
1764         if (status == SUCCESS) {
1765                 char *body = NULL;
1766                 size_t body_len = 0;
1767                 zval *zheaders;
1768
1769                 MAKE_STD_ZVAL(zheaders)
1770                 array_init(zheaders);
1771
1772                 if (SUCCESS != http_split_response_ex(response_data, response_len, Z_ARRVAL_P(zheaders), &body, &body_len)) {
1773                         zval_dtor(zheaders);
1774                         efree(zheaders),
1775                         efree(response_data);
1776                         RETURN_FALSE;
1777                 }
1778
1779                 add_assoc_zval(resp, "headers", zheaders);
1780                 add_assoc_stringl(resp, "body", body, body_len, 0);
1781
1782                 efree(response_data);
1783
1784                 RETURN_TRUE;
1785         }
1786
1787         SET_EH_NORMAL();
1788         RETURN_SUCCESS(status);
1789 }
1790 /* }}} */
1791 /* }}} */
1792 #endif /* HTTP_HAVE_CURL */
1793
1794 #endif /* ZEND_ENGINE_2 */
1795
1796 /*
1797  * Local variables:
1798  * tab-width: 4
1799  * c-basic-offset: 4
1800  * End:
1801  * vim600: noet sw=4 ts=4 fdm=marker
1802  * vim<600: noet sw=4 ts=4
1803  */
1804