git.m6w6.name Git - m6w6/ext-http/blob - http.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 "snprintf.h"
  24 #include "ext/standard/info.h"
  25 #include "ext/session/php_session.h"
  26 #include "ext/standard/php_string.h"
  27 #include "ext/standard/php_smart_str.h"
  28
  29 #include "php_http.h"
  30 #include "php_http_api.h"
  31
  32 #if defined(HAVE_CURL) && HAVE_CURL
  33 #include <curl/curl.h>
  34 #endif
  35
  36 ZEND_DECLARE_MODULE_GLOBALS(http)
  37
  38 #ifdef COMPILE_DL_HTTP
  39 ZEND_GET_MODULE(http)
  40 #endif
  41
  42 /* {{{ http_functions[] */
  43 function_entry http_functions[] = {
  44         PHP_FE(http_date, NULL)
  45         PHP_FE(http_absolute_uri, NULL)
  46         PHP_FE(http_negotiate_language, NULL)
  47         PHP_FE(http_negotiate_charset, NULL)
  48         PHP_FE(http_redirect, NULL)
  49         PHP_FE(http_send_status, NULL)
  50         PHP_FE(http_send_last_modified, NULL)
  51         PHP_FE(http_match_modified, NULL)
  52         PHP_FE(http_match_etag, NULL)
  53         PHP_FE(http_cache_last_modified, NULL)
  54         PHP_FE(http_cache_etag, NULL)
  55         PHP_FE(http_content_type, NULL)
  56         PHP_FE(http_content_disposition, NULL)
  57         PHP_FE(http_send_data, NULL)
  58         PHP_FE(http_send_file, NULL)
  59         PHP_FE(http_send_stream, NULL)
  60         PHP_FE(http_chunked_decode, NULL)
  61         PHP_FE(http_split_response, NULL)
  62 #if defined(HAVE_CURL) && HAVE_CURL
  63         PHP_FE(http_get, NULL)
  64         PHP_FE(http_head, NULL)
  65         PHP_FE(http_post_data, NULL)
  66         PHP_FE(http_post_array, NULL)
  67 #endif
  68         PHP_FE(http_auth_basic, NULL)
  69         PHP_FE(http_auth_basic_cb, NULL)
  70         {NULL, NULL, NULL}
  71 };
  72 /* }}} */
  73
  74 /* {{{ http_module_entry */
  75 zend_module_entry http_module_entry = {
  76 #if ZEND_MODULE_API_NO >= 20010901
  77         STANDARD_MODULE_HEADER,
  78 #endif
  79         "http",
  80         http_functions,
  81         PHP_MINIT(http),
  82         NULL,
  83         NULL,
  84         PHP_RSHUTDOWN(http),
  85         PHP_MINFO(http),
  86 #if ZEND_MODULE_API_NO >= 20010901
  87         PHP_EXT_HTTP_VERSION,
  88 #endif
  89         STANDARD_MODULE_PROPERTIES
  90 };
  91 /* }}} */
  92
  93 #define RETURN_SUCCESS(v) RETURN_BOOL(SUCCESS == (v))
  94 #define HASH_ORNULL(z) ((z) ? Z_ARRVAL_P(z) : NULL)
  95
  96 /* {{{ proto string http_date([int timestamp])
  97  *
  98  * This function returns a valid HTTP date regarding RFC 822/1123
  99  * looking like: "Wed, 22 Dec 2004 11:34:47 GMT"
 100  *
 101  */
 102 PHP_FUNCTION(http_date)
 103 {
 104         long t = -1;
 105
 106         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &t) != SUCCESS) {
 107                 RETURN_FALSE;
 108         }
 109
 110         if (t == -1) {
 111                 t = (long) time(NULL);
 112         }
 113
 114         RETURN_STRING(http_date(t), 0);
 115 }
 116 /* }}} */
 117
 118 /* {{{ proto string http_absolute_uri(string url[, string proto])
 119  *
 120  * This function returns an absolute URI constructed from url.
 121  * If the url is already abolute but a different proto was supplied,
 122  * only the proto part of the URI will be updated.  If url has no
 123  * path specified, the path of the current REQUEST_URI will be taken.
 124  * The host will be taken either from the Host HTTP header of the client
 125  * the SERVER_NAME or just localhost if prior are not available.
 126  *
 127  * Some examples:
 128  * <pre>
 129  *  url = "page.php"                    => http://www.example.com/current/path/page.php
 130  *  url = "/page.php"                   => http://www.example.com/page.php
 131  *  url = "/page.php", proto = "https"  => https://www.example.com/page.php
 132  * </pre>
 133  *
 134  */
 135 PHP_FUNCTION(http_absolute_uri)
 136 {
 137         char *url = NULL, *proto = NULL;
 138         int url_len = 0, proto_len = 0;
 139
 140         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &url, &url_len, &proto, &proto_len) != SUCCESS) {
 141                 RETURN_FALSE;
 142         }
 143
 144         RETURN_STRING(http_absolute_uri(url, proto), 0);
 145 }
 146 /* }}} */
 147
 148 /* {{{ proto string http_negotiate_language(array supported[, string default = 'en-US'])
 149  *
 150  * This function negotiates the clients preferred language based on its
 151  * Accept-Language HTTP header.  It returns the negotiated language or
 152  * the default language if none match.
 153  *
 154  * The qualifier is recognized and languages without qualifier are rated highest.
 155  *
 156  * The supported parameter is expected to be an array having
 157  * the supported languages as array values.
 158  *
 159  * Example:
 160  * <pre>
 161  * <?php
 162  * $langs = array(
 163  *              'en-US',// default
 164  *              'fr',
 165  *              'fr-FR',
 166  *              'de',
 167  *              'de-DE',
 168  *              'de-AT',
 169  *              'de-CH',
 170  * );
 171  * include './langs/'. http_negotiate_language($langs) .'.php';
 172  * ?>
 173  * </pre>
 174  *
 175  */
 176 PHP_FUNCTION(http_negotiate_language)
 177 {
 178         zval *supported;
 179         char *def = NULL;
 180         int def_len = 0;
 181
 182         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|s", &supported, &def, &def_len) != SUCCESS) {
 183                 RETURN_FALSE;
 184         }
 185
 186         if (!def) {
 187                 def = "en-US";
 188         }
 189
 190         RETURN_STRING(http_negotiate_language(supported, def), 0);
 191 }
 192 /* }}} */
 193
 194 /* {{{ proto string http_negotiate_charset(array supported[, string default = 'iso-8859-1'])
 195  *
 196  * This function negotiates the clients preferred charset based on its
 197  * Accept-Charset HTTP header.  It returns the negotiated charset or
 198  * the default charset if none match.
 199  *
 200  * The qualifier is recognized and charset without qualifier are rated highest.
 201  *
 202  * The supported parameter is expected to be an array having
 203  * the supported charsets as array values.
 204  *
 205  * Example:
 206  * <pre>
 207  * <?php
 208  * $charsets = array(
 209  *              'iso-8859-1', // default
 210  *              'iso-8859-2',
 211  *              'iso-8859-15',
 212  *              'utf-8'
 213  * );
 214  * $pref = http_negotiate_charset($charsets);
 215  * if (!strcmp($pref, 'iso-8859-1')) {
 216  *              iconv_set_encoding('internal_encoding', 'iso-8859-1');
 217  *              iconv_set_encoding('output_encoding', $pref);
 218  *              ob_start('ob_iconv_handler');
 219  * }
 220  * ?>
 221  * </pre>
 222  */
 223 PHP_FUNCTION(http_negotiate_charset)
 224 {
 225         zval *supported;
 226         char *def = NULL;
 227         int def_len = 0;
 228
 229         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|s", &supported, &def, &def_len) != SUCCESS) {
 230                 RETURN_FALSE;
 231         }
 232
 233         if (!def) {
 234                 def = "iso-8859-1";
 235         }
 236
 237         RETURN_STRING(http_negotiate_charset(supported, def), 0);
 238 }
 239 /* }}} */
 240
 241 /* {{{ proto bool http_send_status(int status)
 242  *
 243  * Send HTTP status code.
 244  *
 245  */
 246 PHP_FUNCTION(http_send_status)
 247 {
 248         int status = 0;
 249
 250         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &status) != SUCCESS) {
 251                 RETURN_FALSE;
 252         }
 253         if (status < 100 || status > 510) {
 254                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid HTTP status code (100-510): %d", status);
 255                 RETURN_FALSE;
 256         }
 257
 258         RETURN_SUCCESS(http_send_status(status));
 259 }
 260 /* }}} */
 261
 262 /* {{{ proto bool http_send_last_modified([int timestamp])
 263  *
 264  * This converts the given timestamp to a valid HTTP date and
 265  * sends it as "Last-Modified" HTTP header.  If timestamp is
 266  * omitted, current time is sent.
 267  *
 268  */
 269 PHP_FUNCTION(http_send_last_modified)
 270 {
 271         long t = -1;
 272
 273         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &t) != SUCCESS) {
 274                 RETURN_FALSE;
 275         }
 276
 277         if (t == -1) {
 278                 t = (long) time(NULL);
 279         }
 280
 281         RETURN_SUCCESS(http_send_last_modified(t));
 282 }
 283 /* }}} */
 284
 285 /* {{{ proto bool http_match_modified([int timestamp])
 286  *
 287  * Matches the given timestamp against the clients "If-Modified-Since" resp.
 288  * "If-Unmodified-Since" HTTP headers.
 289  *
 290  */
 291 PHP_FUNCTION(http_match_modified)
 292 {
 293         long t = -1;
 294
 295         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &t) != SUCCESS) {
 296                 RETURN_FALSE;
 297         }
 298
 299         // current time if not supplied (senseless though)
 300         if (t == -1) {
 301                 t = (long) time(NULL);
 302         }
 303
 304         RETURN_BOOL(http_modified_match("HTTP_IF_MODIFIED_SINCE", t) || http_modified_match("HTTP_IF_UNMODIFIED_SINCE", t));
 305 }
 306 /* }}} */
 307
 308 /* {{{ proto bool http_match_etag(string etag)
 309  *
 310  * This matches the given ETag against the clients
 311  * "If-Match" resp. "If-None-Match" HTTP headers.
 312  *
 313  */
 314 PHP_FUNCTION(http_match_etag)
 315 {
 316         int etag_len;
 317         char *etag;
 318
 319         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &etag, &etag_len) != SUCCESS) {
 320                 RETURN_FALSE;
 321         }
 322
 323         RETURN_BOOL(http_etag_match("HTTP_IF_NONE_MATCH", etag) || http_etag_match("HTTP_IF_MATCH", etag));
 324 }
 325 /* }}} */
 326
 327 /* {{{ proto bool http_cache_last_modified([int timestamp_or_expires]])
 328  *
 329  * If timestamp_or_exires is greater than 0, it is handled as timestamp
 330  * and will be sent as date of last modification.  If it is 0 or omitted,
 331  * the current time will be sent as Last-Modified date.  If it's negative,
 332  * it is handled as expiration time in seconds, which means that if the
 333  * requested last modification date is not between the calculated timespan,
 334  * the Last-Modified header is updated and the actual body will be sent.
 335  *
 336  */
 337 PHP_FUNCTION(http_cache_last_modified)
 338 {
 339         long last_modified = 0, send_modified = 0, t;
 340         zval *zlm;
 341
 342         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &last_modified) != SUCCESS) {
 343                 RETURN_FALSE;
 344         }
 345
 346         t = (long) time(NULL);
 347
 348         /* 0 or omitted */
 349         if (!last_modified) {
 350                 /* does the client have? */
 351                 if (zlm = http_get_server_var("HTTP_IF_MODIFIED_SINCE")) {
 352                         last_modified = send_modified = http_parse_date(Z_STRVAL_P(zlm));
 353                 /* use current time */
 354                 } else {
 355                         last_modified = send_modified = t;
 356                 }
 357         /* negative value is supposed to be expiration time */
 358         } else if (last_modified < 0) {
 359                 last_modified += t;
 360                 send_modified  = t;
 361         /* send supplied time explicitly */
 362         } else {
 363                 send_modified = last_modified;
 364         }
 365
 366         http_send_header("Cache-Control: private, must-revalidate, max-age=0");
 367
 368         if (http_modified_match("HTTP_IF_MODIFIED_SINCE", last_modified)) {
 369                 if (SUCCESS == http_send_status(304)) {
 370                         zend_bailout();
 371                 } else {
 372                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not send 304 Not Modified");
 373                         RETURN_FALSE;
 374                 }
 375         }
 376         RETURN_SUCCESS(http_send_last_modified(send_modified));
 377 }
 378 /* }}} */
 379
 380 /* {{{ proto bool http_cache_etag([string etag])
 381  *
 382  * This function attempts to cache the HTTP body based on an ETag,
 383  * either supplied or generated through calculation of the MD5
 384  * checksum of the output (uses output buffering).
 385  *
 386  * If clients "If-None-Match" header matches the supplied/calculated
 387  * ETag, the body is considered cached on the clients side and
 388  * a "304 Not Modified" status code is issued.
 389  *
 390  */
 391 PHP_FUNCTION(http_cache_etag)
 392 {
 393         char *etag;
 394         int etag_len = 0;
 395
 396         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &etag, &etag_len) != SUCCESS) {
 397                 RETURN_FALSE;
 398         }
 399
 400         /* send remaining data to nirvana */
 401         http_send_header("Connection: close");
 402         http_send_header("Cache-Control: private, must-revalidate, max-age=0");
 403
 404         /* if no etag is given and we didn't already
 405          * start ob_etaghandler -- start it
 406          */
 407         if (!HTTP_G(etag_started) && !etag_len) {
 408                 php_ob_set_internal_handler(_http_ob_etaghandler, (uint) 4096, "etag output handler", 0 TSRMLS_CC);
 409                 HTTP_G(etag_started) = 1;
 410                 RETURN_BOOL(php_start_ob_buffer_named("etag output handler", (uint) 4096, 0 TSRMLS_CC));
 411         }
 412
 413         if (http_etag_match("HTTP_IF_NONE_MATCH", etag)) {
 414                 if (SUCCESS == http_send_status(304)) {
 415                         zend_bailout();
 416                 } else {
 417                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not send 304 Not Modified");
 418                         RETURN_FALSE;
 419                 }
 420         }
 421
 422         RETURN_SUCCESS(http_send_etag(etag, etag_len));
 423 }
 424 /* }}} */
 425
 426 /* {{{ proto void http_redirect([string url[, array params[, bool session,[ bool permanent]]]])
 427  *
 428  * Redirect to a given url.
 429  * The supplied url will be expanded with http_absolute_uri(), the params array will
 430  * be treated with http_build_query() and the session identification will be appended
 431  * if session is true.
 432  *
 433  * Depending on permanent the redirection will be issued with a permanent
 434  * ("301 Moved Permanently") or a temporary ("302 Found") redirection
 435  * status code.
 436  *
 437  */
 438 PHP_FUNCTION(http_redirect)
 439 {
 440         int url_len;
 441         zend_bool session = 0, permanent = 0;
 442         zval *params = NULL;
 443         smart_str qstr = {0};
 444         char *url, *URI, LOC[HTTP_URI_MAXLEN + 9];
 445
 446         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sa!bb", &url, &url_len, &params, &session, &permanent) != SUCCESS) {
 447                 RETURN_FALSE;
 448         }
 449
 450         /* append session info */
 451         if (session && (PS(session_status) == php_session_active)) {
 452                 if (!params) {
 453                         MAKE_STD_ZVAL(params);
 454                         array_init(params);
 455                 }
 456                 if (add_assoc_string(params, PS(session_name), PS(id), 1) != SUCCESS) {
 457                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not append session information");
 458                 }
 459         }
 460
 461         /* treat params array with http_build_query() */
 462         if (params) {
 463                 if (php_url_encode_hash_ex(Z_ARRVAL_P(params), &qstr, NULL,0,NULL,0,NULL,0,NULL TSRMLS_CC) != SUCCESS) {
 464                         if (qstr.c) {
 465                                 efree(qstr.c);
 466                         }
 467                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not encode query parameters");
 468                         RETURN_FALSE;
 469                 }
 470                 smart_str_0(&qstr);
 471         }
 472
 473         URI = http_absolute_uri(url, NULL);
 474         if (qstr.c) {
 475                 snprintf(LOC, HTTP_URI_MAXLEN + strlen("Location: "), "Location: %s?%s", URI, qstr.c);
 476                 efree(qstr.c);
 477         } else {
 478                 snprintf(LOC, HTTP_URI_MAXLEN + strlen("Location: "), "Location: %s", URI);
 479         }
 480         efree(URI);
 481
 482         RETVAL_BOOL((SUCCESS == http_send_header(LOC)) && (SUCCESS == http_send_status((permanent ? 301 : 302))));
 483 }
 484 /* }}} */
 485
 486 /* {{{ proto bool http_send_data(string data)
 487  *
 488  * Sends raw data with support for (multiple) range requests.
 489  *
 490  */
 491 PHP_FUNCTION(http_send_data)
 492 {
 493         zval *zdata;
 494
 495         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zdata) != SUCCESS) {
 496                 RETURN_FALSE;
 497         }
 498
 499         convert_to_string_ex(&zdata);
 500         http_send_header("Accept-Ranges: bytes");
 501         RETURN_SUCCESS(http_send_data(zdata));
 502 }
 503 /* }}} */
 504
 505 /* {{{ proto bool http_send_file(string file)
 506  *
 507  * Sends a file with support for (multiple) range requests.
 508  *
 509  */
 510 PHP_FUNCTION(http_send_file)
 511 {
 512         zval *zfile;
 513
 514         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zfile) != SUCCESS) {
 515                 RETURN_FALSE;
 516         }
 517
 518         convert_to_string_ex(&zfile);
 519         http_send_header("Accept-Ranges: bytes");
 520         RETURN_SUCCESS(http_send_file(zfile));
 521 }
 522 /* }}} */
 523
 524 /* {{{ proto bool http_send_stream(resource stream)
 525  *
 526  * Sends an already opened stream with support for (multiple) range requests.
 527  *
 528  */
 529 PHP_FUNCTION(http_send_stream)
 530 {
 531         zval *zstream;
 532         php_stream *file;
 533
 534         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zstream) != SUCCESS) {
 535                 RETURN_FALSE;
 536         }
 537
 538         php_stream_from_zval(file, &zstream);
 539         http_send_header("Accept-Ranges: bytes");
 540         RETURN_SUCCESS(http_send_stream(file));
 541 }
 542 /* }}} */
 543
 544 /* {{{ proto bool http_content_type([string content_type = 'application/x-octetstream'])
 545  *
 546  * Sets the content type.
 547  *
 548  */
 549 PHP_FUNCTION(http_content_type)
 550 {
 551         char *ct, *content_type;
 552         int ct_len = 0;
 553
 554         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &ct, &ct_len) != SUCCESS) {
 555                 RETURN_FALSE;
 556         }
 557
 558         if (!ct_len) {
 559                 RETURN_SUCCESS(http_send_header("Content-Type: application/x-octetstream"));
 560         }
 561
 562         /* remember for multiple ranges */
 563         if (HTTP_G(ctype)) {
 564                 efree(HTTP_G(ctype));
 565         }
 566         HTTP_G(ctype) = estrndup(ct, ct_len);
 567
 568         content_type = (char *) emalloc(strlen("Content-Type: ") + ct_len + 1);
 569         sprintf(content_type, "Content-Type: %s", ct);
 570
 571         RETVAL_BOOL(SUCCESS == http_send_header(content_type));
 572         efree(content_type);
 573 }
 574 /* }}} */
 575
 576 /* {{{ proto bool http_content_disposition(string filename[, bool inline = false])
 577  *
 578  * Set the Content Disposition.  The Content-Disposition header is very useful
 579  * if the data actually sent came from a file or something similar, that should
 580  * be "saved" by the client/user (i.e. by browsers "Save as..." popup window).
 581  *
 582  */
 583 PHP_FUNCTION(http_content_disposition)
 584 {
 585         char *filename, *header;
 586         int f_len;
 587         zend_bool send_inline = 0;
 588
 589         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &filename, &f_len, &send_inline) != SUCCESS) {
 590                 RETURN_FALSE;
 591         }
 592
 593         if (send_inline) {
 594                 header = (char *) emalloc(strlen("Content-Disposition: inline; filename=\"\"") + f_len + 1);
 595                 sprintf(header, "Content-Disposition: inline; filename=\"%s\"", filename);
 596         } else {
 597                 header = (char *) emalloc(strlen("Content-Disposition: attachment; filename=\"\"") + f_len + 1);
 598                 sprintf(header, "Content-Disposition: attachment; filename=\"%s\"", filename);
 599         }
 600
 601         RETVAL_BOOL(SUCCESS == http_send_header(header));
 602         efree(header);
 603 }
 604 /* }}} */
 605
 606 /* {{{ proto string http_chunked_decode(string encoded)
 607  *
 608  * This function decodes a string that was HTTP-chunked encoded.
 609  * Returns false on failure.
 610  */
 611 PHP_FUNCTION(http_chunked_decode)
 612 {
 613         char *encoded = NULL, *decoded = NULL;
 614         int encoded_len = 0, decoded_len = 0;
 615
 616         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &encoded, &encoded_len) != SUCCESS) {
 617                 RETURN_FALSE;
 618         }
 619
 620         if (SUCCESS == http_chunked_decode(encoded, encoded_len, &decoded, &decoded_len)) {
 621                 RETURN_STRINGL(decoded, decoded_len, 0);
 622         } else {
 623                 RETURN_FALSE;
 624         }
 625 }
 626 /* }}} */
 627
 628 /* {{{ proto array http_split_response(string http_response)
 629  *
 630  * This function splits an HTTP response into an array with headers and the
 631  * content body. The returned array may look simliar to the following example:
 632  *
 633  * <pre>
 634  * array(
 635  *     0 => array(
 636  *         'Status' => '200 Ok',
 637  *         'Content-Type' => 'text/plain',
 638  *         'Content-Language' => 'en-US'
 639  *     ),
 640  *     1 => "Hello World!"
 641  * );
 642  * </pre>
 643  */
 644 PHP_FUNCTION(http_split_response)
 645 {
 646         zval *zresponse, *zbody, *zheaders;
 647
 648         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zresponse) != SUCCESS) {
 649                 RETURN_FALSE;
 650         }
 651
 652         convert_to_string_ex(&zresponse);
 653
 654         MAKE_STD_ZVAL(zbody);
 655         MAKE_STD_ZVAL(zheaders);
 656         array_init(zheaders);
 657
 658         http_split_response(zresponse, zheaders, zbody);
 659
 660         array_init(return_value);
 661         add_index_zval(return_value, 0, zheaders);
 662         add_index_zval(return_value, 1, zbody);
 663 }
 664 /* }}} */
 665
 666 /* {{{ HAVE_CURL */
 667 #if defined(HAVE_CURL) && HAVE_CURL
 668
 669 /* {{{ proto string http_get(string url[, array options[, array &info]])
 670  *
 671  * Performs an HTTP GET request on the supplied url.
 672  *
 673  * The second parameter is expected to be an associative
 674  * array where the following keys will be recognized:
 675  * <pre>
 676  *  - redirect:         int, whether and how many redirects to follow
 677  *  - unrestrictedauth: bool, whether to continue sending credentials on
 678  *                      redirects to a different host
 679  *  - proxyhost:        string, proxy host in "host[:port]" format
 680  *  - proxyport:        int, use another proxy port as specified in proxyhost
 681  *  - proxyauth:        string, proxy credentials in "user:pass" format
 682  *  - proxyauthtype:    int, HTTP_AUTH_BASIC and/or HTTP_AUTH_NTLM
 683  *  - httpauth:         string, http credentials in "user:pass" format
 684  *  - httpauthtype:     int, HTTP_AUTH_BASIC, DIGEST and/or NTLM
 685  *  - compress:         bool, whether to allow gzip/deflate content encoding
 686  *                      (defaults to true)
 687  *  - port:             int, use another port as specified in the url
 688  *  - referer:          string, the referer to sends
 689  *  - useragent:        string, the user agent to send
 690  *                      (defaults to PECL::HTTP/version (PHP/version)))
 691  *  - headers:          array, list of custom headers as associative array
 692  *                      like array("header" => "value")
 693  *  - cookies:          array, list of cookies as associative array
 694  *                      like array("cookie" => "value")
 695  *  - cookiestore:      string, path to a file where cookies are/will be stored
 696  * </pre>
 697  *
 698  * The optional third parameter will be filled with some additional information
 699  * in form af an associative array, if supplied (don't forget to initialize it
 700  * with NULL or array()).
 701  */
 702 PHP_FUNCTION(http_get)
 703 {
 704         char *URL, *data = NULL;
 705         size_t data_len = 0;
 706         int URL_len;
 707         zval *options = NULL, *info = NULL;
 708
 709         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|a/!z", &URL, &URL_len, &options, &info) != SUCCESS) {
 710                 RETURN_FALSE;
 711         }
 712
 713         if (info) {
 714                 zval_dtor(info);
 715                 array_init(info);
 716         }
 717
 718         if (SUCCESS == http_get(URL, HASH_ORNULL(options), HASH_ORNULL(info), &data, &data_len)) {
 719                 RETURN_STRINGL(data, data_len, 0);
 720         } else {
 721                 RETURN_FALSE;
 722         }
 723 }
 724 /* }}} */
 725
 726 /* {{{ proto string http_head(string url[, array options[, array &info]])
 727  *
 728  * Performs an HTTP HEAD request on the suppied url.
 729  * Returns the HTTP response as string.
 730  * See http_get() for a full list of available options.
 731  */
 732 PHP_FUNCTION(http_head)
 733 {
 734         char *URL, *data = NULL;
 735         size_t data_len = 0;
 736         int URL_len;
 737         zval *options = NULL, *info = NULL;
 738
 739         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|a/!z", &URL, &URL_len, &options, &info) != SUCCESS) {
 740                 RETURN_FALSE;
 741         }
 742
 743         if (info) {
 744                 zval_dtor(info);
 745                 array_init(info);
 746         }
 747
 748         if (SUCCESS == http_head(URL, HASH_ORNULL(options), HASH_ORNULL(info), &data, &data_len)) {
 749                 RETURN_STRINGL(data, data_len, 0);
 750         } else {
 751                 RETURN_FALSE;
 752         }
 753 }
 754 /* }}} */
 755
 756 /* {{{ proto string http_post_data(string url, string data[, array options[, &info]])
 757  *
 758  * Performs an HTTP POST request, posting data.
 759  * Returns the HTTP response as string.
 760  * See http_get() for a full list of available options.
 761  */
 762 PHP_FUNCTION(http_post_data)
 763 {
 764         char *URL, *postdata, *data = NULL;
 765         size_t data_len = 0;
 766         int postdata_len, URL_len;
 767         zval *options = NULL, *info = NULL;
 768
 769         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|a/!z", &URL, &URL_len, &postdata, &postdata_len, &options, &info) != SUCCESS) {
 770                 RETURN_FALSE;
 771         }
 772
 773         if (info) {
 774                 zval_dtor(info);
 775                 array_init(info);
 776         }
 777
 778         if (SUCCESS == http_post_data(URL, postdata, (size_t) postdata_len, HASH_ORNULL(options), HASH_ORNULL(info), &data, &data_len)) {
 779                 RETURN_STRINGL(data, data_len, 0);
 780         } else {
 781                 RETURN_FALSE;
 782         }
 783 }
 784 /* }}} */
 785
 786 /* {{{ proto string http_post_array(string url, array data[, array options[, array &info]])
 787  *
 788  * Performs an HTTP POST request, posting www-form-urlencoded array data.
 789  * Returns the HTTP response as string.
 790  * See http_get() for a full list of available options.
 791  */
 792 PHP_FUNCTION(http_post_array)
 793 {
 794         char *URL, *data = NULL;
 795         size_t data_len = 0;
 796         int URL_len;
 797         zval *options = NULL, *info = NULL, *postdata;
 798
 799         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa|a/!z", &URL, &URL_len, &postdata, &options, &info) != SUCCESS) {
 800                 RETURN_FALSE;
 801         }
 802
 803         if (info) {
 804                 zval_dtor(info);
 805                 array_init(info);
 806         }
 807
 808         if (SUCCESS == http_post_array(URL, Z_ARRVAL_P(postdata), HASH_ORNULL(options), HASH_ORNULL(info), &data, &data_len)) {
 809                 RETURN_STRINGL(data, data_len, 0);
 810         } else {
 811                 RETURN_FALSE;
 812         }
 813 }
 814 /* }}} */
 815
 816 #endif
 817 /* }}} HAVE_CURL */
 818
 819
 820 /* {{{ proto bool http_auth_basic(string user, string pass[, string realm = "Restricted"])
 821  *
 822  * Example:
 823  * <pre>
 824  * <?php
 825  * if (!http_auth_basic('mike', 's3c|r3t')) {
 826  *     die('<h1>Authorization failed!</h1>');
 827  * }
 828  * ?>
 829  * </pre>
 830  */
 831 PHP_FUNCTION(http_auth_basic)
 832 {
 833         char *realm = NULL, *user, *pass, *suser, *spass;
 834         int r_len, u_len, p_len;
 835
 836         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|s", &user, &u_len, &pass, &p_len, &realm, &r_len) != SUCCESS) {
 837                 RETURN_FALSE;
 838         }
 839
 840         if (!realm) {
 841                 realm = "Restricted";
 842         }
 843
 844         if (SUCCESS != http_auth_credentials(&suser, &spass)) {
 845                 http_auth_header("Basic", realm);
 846                 RETURN_FALSE;
 847         }
 848
 849         if (strcasecmp(suser, user)) {
 850                 http_auth_header("Basic", realm);
 851                 RETURN_FALSE;
 852         }
 853
 854         if (strcmp(spass, pass)) {
 855                 http_auth_header("Basic", realm);
 856                 RETURN_FALSE;
 857         }
 858
 859         RETURN_TRUE;
 860 }
 861 /* }}} */
 862
 863 /* {{{ proto bool http_auth_basic_cb(mixed callback[, string realm = "Restricted"])
 864  *
 865  * Example:
 866  * <pre>
 867  * <?php
 868  * function auth_cb($user, $pass)
 869  * {
 870  *     global $db;
 871  *     $query = 'SELECT pass FROM users WHERE user='. $db->quoteSmart($user);
 872  *     if (strlen($realpass = $db->getOne($query)) {
 873  *         return $pass === $realpass;
 874  *     }
 875  *     return false;
 876  * }
 877  *
 878  * if (!http_auth_basic_cb('auth_cb')) {
 879  *     die('<h1>Authorization failed</h1>');
 880  * }
 881  * ?>
 882  * </pre>
 883  */
 884 PHP_FUNCTION(http_auth_basic_cb)
 885 {
 886         zval *cb;
 887         char *realm = NULL, *user, *pass;
 888         int r_len;
 889
 890         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|s", &cb, &realm, &r_len) != SUCCESS) {
 891                 RETURN_FALSE;
 892         }
 893
 894         if (!realm) {
 895                 realm = "Restricted";
 896         }
 897
 898         if (SUCCESS != http_auth_credentials(&user, &pass)) {
 899                 http_auth_header("Basic", realm);
 900                 RETURN_FALSE;
 901         }
 902         {
 903                 zval *zparams[2] = {NULL, NULL}, retval;
 904                 int result = 0;
 905
 906                 MAKE_STD_ZVAL(zparams[0]);
 907                 MAKE_STD_ZVAL(zparams[1]);
 908                 ZVAL_STRING(zparams[0], user, 0);
 909                 ZVAL_STRING(zparams[1], pass, 0);
 910
 911                 if (SUCCESS == call_user_function(EG(function_table), NULL, cb,
 912                                 &retval, 2, zparams TSRMLS_CC)) {
 913                         result = Z_LVAL(retval);
 914                 }
 915
 916                 efree(user);
 917                 efree(pass);
 918                 efree(zparams[0]);
 919                 efree(zparams[1]);
 920
 921                 if (!result) {
 922                         http_auth_header("Basic", realm);
 923                 }
 924
 925                 RETURN_BOOL(result);
 926         }
 927 }
 928 /* }}}*/
 929
 930
 931 /* {{{ php_http_init_globals(zend_http_globals *) */
 932 static void php_http_init_globals(zend_http_globals *http_globals)
 933 {
 934         http_globals->etag_started = 0;
 935         http_globals->ctype = NULL;
 936 #if defined(HAVE_CURL) && HAVE_CURL
 937         http_globals->curlbuf.body.data = NULL;
 938         http_globals->curlbuf.body.used = 0;
 939         http_globals->curlbuf.body.free = 0;
 940         http_globals->curlbuf.hdrs.data = NULL;
 941         http_globals->curlbuf.hdrs.used = 0;
 942         http_globals->curlbuf.hdrs.free = 0;
 943 #endif
 944 }
 945 /* }}} */
 946
 947 /* {{{ PHP_MINIT_FUNCTION */
 948 PHP_MINIT_FUNCTION(http)
 949 {
 950         ZEND_INIT_MODULE_GLOBALS(http, php_http_init_globals, NULL);
 951 #if defined(HAVE_CURL) && HAVE_CURL
 952         REGISTER_LONG_CONSTANT("HTTP_AUTH_BASIC", CURLAUTH_BASIC, CONST_CS | CONST_PERSISTENT);
 953         REGISTER_LONG_CONSTANT("HTTP_AUTH_DIGEST", CURLAUTH_DIGEST, CONST_CS | CONST_PERSISTENT);
 954         REGISTER_LONG_CONSTANT("HTTP_AUTH_NTLM", CURLAUTH_NTLM, CONST_CS | CONST_PERSISTENT);
 955 #endif
 956         return SUCCESS;
 957 }
 958 /* }}} */
 959
 960 /* {{{ PHP_RSHUTDOWN_FUNCTION */
 961 PHP_RSHUTDOWN_FUNCTION(http)
 962 {
 963         if (HTTP_G(ctype)) {
 964                 efree(HTTP_G(ctype));
 965         }
 966 #if defined(HAVE_CURL) && HAVE_CURL
 967         if (HTTP_G(curlbuf).body.data) {
 968                 efree(HTTP_G(curlbuf).body.data);
 969         }
 970         if (HTTP_G(curlbuf).hdrs.data) {
 971                 efree(HTTP_G(curlbuf).hdrs.data);
 972         }
 973 #endif
 974         return SUCCESS;
 975 }
 976 /* }}} */
 977
 978 /* {{{ PHP_MINFO_FUNCTION */
 979 PHP_MINFO_FUNCTION(http)
 980 {
 981         php_info_print_table_start();
 982         php_info_print_table_header(2, "Extended HTTP support", "enabled");
 983         php_info_print_table_row(2, "Version:", PHP_EXT_HTTP_VERSION);
 984         php_info_print_table_row(2, "cURL convenience functions:",
 985 #if defined(HAVE_CURL) && HAVE_CURL
 986                         "enabled"
 987 #else
 988                         "disabled"
 989 #endif
 990         );
 991         php_info_print_table_end();
 992 }
 993 /* }}} */
 994
 995 /*
 996  * Local variables:
 997  * tab-width: 4
 998  * c-basic-offset: 4
 999  * End:
1000  * vim600: noet sw=4 ts=4 fdm=marker
1001  * vim<600: noet sw=4 ts=4
1002  */