git.m6w6.name Git - m6w6/ext-http/blob - http_request_api.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 #include "php.h"
  22
  23 #ifdef HTTP_HAVE_CURL
  24
  25 #if defined(ZTS) && defined(HTTP_HAVE_SSL)
  26 #       if !defined(HAVE_OPENSSL_CRYPTO_H)
  27 #               error "libcurl was compiled with OpenSSL support, but we have no openssl/crypto.h"
  28 #       else
  29 #               define HTTP_NEED_SSL
  30 #               include <openssl/crypto.h>
  31 #       endif
  32 #endif
  33
  34 #include "php_http.h"
  35 #include "php_http_std_defs.h"
  36 #include "php_http_api.h"
  37 #include "php_http_request_api.h"
  38 #include "php_http_request_method_api.h"
  39 #include "php_http_url_api.h"
  40 #ifdef ZEND_ENGINE_2
  41 #       include "php_http_request_object.h"
  42 #endif
  43
  44 #include "phpstr/phpstr.h"
  45
  46 #ifdef PHP_WIN32
  47 #       include <winsock2.h>
  48 #endif
  49
  50 #include <curl/curl.h>
  51
  52 ZEND_EXTERN_MODULE_GLOBALS(http);
  53
  54 #ifdef HTTP_NEED_SSL
  55 static inline zend_bool http_ssl_init(void);
  56 static inline void http_ssl_cleanup(void);
  57 #endif
  58
  59 STATUS _http_request_global_init(INIT_FUNC_ARGS)
  60 {
  61         if (CURLE_OK != curl_global_init(CURL_GLOBAL_ALL)) {
  62                 return FAILURE;
  63         }
  64
  65 #ifdef HTTP_NEED_SSL
  66         http_ssl_init();
  67 #endif
  68
  69 #if LIBCURL_VERSION_NUM >= 0x070a05
  70         HTTP_LONG_CONSTANT("HTTP_AUTH_BASIC", CURLAUTH_BASIC);
  71         HTTP_LONG_CONSTANT("HTTP_AUTH_DIGEST", CURLAUTH_DIGEST);
  72         HTTP_LONG_CONSTANT("HTTP_AUTH_NTLM", CURLAUTH_NTLM);
  73         HTTP_LONG_CONSTANT("HTTP_AUTH_ANY", CURLAUTH_ANY);
  74 #endif /* LIBCURL_VERSION_NUM */
  75
  76         return SUCCESS;
  77 }
  78
  79 void _http_request_global_cleanup(TSRMLS_D)
  80 {
  81         curl_global_cleanup();
  82 #ifdef HTTP_NEED_SSL
  83         http_ssl_cleanup();
  84 #endif
  85 }
  86
  87 #ifndef HAVE_CURL_EASY_STRERROR
  88 #       define curl_easy_strerror(code) HTTP_G(request).error
  89 #endif
  90
  91 #define HTTP_CURL_INFO(I) HTTP_CURL_INFO_EX(I, I)
  92 #define HTTP_CURL_INFO_EX(I, X) \
  93         switch (CURLINFO_ ##I & ~CURLINFO_MASK) \
  94         { \
  95                 case CURLINFO_STRING: \
  96                 { \
  97                         char *c; \
  98                         if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_ ##I, &c)) { \
  99                                 add_assoc_string(&array, pretty_key(http_request_data_copy(COPY_STRING, #X), sizeof(#X)-1, 0, 0), c ? c : "", 1); \
 100                         } \
 101                 } \
 102                 break; \
 103 \
 104                 case CURLINFO_DOUBLE: \
 105                 { \
 106                         double d; \
 107                         if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_ ##I, &d)) { \
 108                                 add_assoc_double(&array, pretty_key(http_request_data_copy(COPY_STRING, #X), sizeof(#X)-1, 0, 0), d); \
 109                         } \
 110                 } \
 111                 break; \
 112 \
 113                 case CURLINFO_LONG: \
 114                 { \
 115                         long l; \
 116                         if (CURLE_OK == curl_easy_getinfo(ch, CURLINFO_ ##I, &l)) { \
 117                                 add_assoc_long(&array, pretty_key(http_request_data_copy(COPY_STRING, #X), sizeof(#X)-1, 0, 0), l); \
 118                         } \
 119                 } \
 120                 break; \
 121         }
 122
 123 #define HTTP_CURL_OPT(OPTION, p) curl_easy_setopt(ch, CURLOPT_##OPTION, (p))
 124 #define HTTP_CURL_OPT_STRING(keyname) HTTP_CURL_OPT_STRING_EX(keyname, keyname)
 125 #define HTTP_CURL_OPT_SSL_STRING(keyname) HTTP_CURL_OPT_STRING_EX(keyname, SSL##keyname)
 126 #define HTTP_CURL_OPT_SSL_STRING_(keyname) HTTP_CURL_OPT_STRING_EX(keyname, SSL_##keyname)
 127 #define HTTP_CURL_OPT_STRING_EX(keyname, optname) \
 128         if (!strcasecmp(key, #keyname)) { \
 129                 convert_to_string_ex(param); \
 130                 HTTP_CURL_OPT(optname, http_request_data_copy(COPY_STRING, Z_STRVAL_PP(param))); \
 131                 key = NULL; \
 132                 continue; \
 133         }
 134 #define HTTP_CURL_OPT_LONG(keyname) HTTP_OPT_SSL_LONG_EX(keyname, keyname)
 135 #define HTTP_CURL_OPT_SSL_LONG(keyname) HTTP_CURL_OPT_LONG_EX(keyname, SSL##keyname)
 136 #define HTTP_CURL_OPT_SSL_LONG_(keyname) HTTP_CURL_OPT_LONG_EX(keyname, SSL_##keyname)
 137 #define HTTP_CURL_OPT_LONG_EX(keyname, optname) \
 138         if (!strcasecmp(key, #keyname)) { \
 139                 convert_to_long_ex(param); \
 140                 HTTP_CURL_OPT(optname, Z_LVAL_PP(param)); \
 141                 key = NULL; \
 142                 continue; \
 143         }
 144
 145 #define http_curl_getopt(o, k, t) _http_curl_getopt_ex((o), (k), sizeof(k), (t) TSRMLS_CC)
 146 #define http_curl_getopt_ex(o, k, l, t) _http_curl_getopt_ex((o), (k), (l), (t) TSRMLS_CC)
 147 static inline zval *_http_curl_getopt_ex(HashTable *options, char *key, size_t keylen, int type TSRMLS_DC);
 148 #define http_curl_defaults(ch) _http_curl_defaults((ch))
 149 static inline void _http_curl_defaults(CURL *ch);
 150 static size_t http_curl_read_callback(void *, size_t, size_t, void *);
 151 static int http_curl_progress_callback(void *, double, double, double, double);
 152 static int http_curl_raw_callback(CURL *, curl_infotype, char *, size_t, void *);
 153 static int http_curl_dummy_callback(char *data, size_t n, size_t l, void *s) { return n*l; }
 154
 155 /* {{{ http_request_callback_ctx http_request_callback_data(void *) */
 156 http_request_callback_ctx *_http_request_callback_data_ex(void *data, zend_bool cpy TSRMLS_DC)
 157 {
 158         http_request_callback_ctx *ctx = emalloc(sizeof(http_request_callback_ctx));
 159
 160         TSRMLS_SET_CTX(ctx->tsrm_ctx);
 161         ctx->data = data;
 162
 163         if (cpy) {
 164                 return http_request_data_copy(COPY_CONTEXT, ctx);
 165         } else {
 166                 return ctx;
 167         }
 168 }
 169 /* }}} */
 170
 171 /* {{{ void *http_request_data_copy(int, void *) */
 172 void *_http_request_data_copy(int type, void *data TSRMLS_DC)
 173 {
 174         switch (type)
 175         {
 176                 case COPY_STRING:
 177                 {
 178                         char *new_str = estrdup(data);
 179                         zend_llist_add_element(&HTTP_G(request).copies.strings, &new_str);
 180                         return new_str;
 181                 }
 182
 183                 case COPY_SLIST:
 184                 {
 185                         zend_llist_add_element(&HTTP_G(request).copies.slists, &data);
 186                         return data;
 187                 }
 188
 189                 case COPY_CONTEXT:
 190                 {
 191                         zend_llist_add_element(&HTTP_G(request).copies.contexts, &data);
 192                         return data;
 193                 }
 194
 195                 case COPY_CONV:
 196                 {
 197                         zend_llist_add_element(&HTTP_G(request).copies.convs, &data);
 198                         return data;
 199                 }
 200
 201                 default:
 202                 {
 203                         return data;
 204                 }
 205         }
 206 }
 207 /* }}} */
 208
 209 /* {{{ void http_request_data_free_string(char **) */
 210 void _http_request_data_free_string(void *string)
 211 {
 212         efree(*((char **)string));
 213 }
 214 /* }}} */
 215
 216 /* {{{ void http_request_data_free_slist(struct curl_slist **) */
 217 void _http_request_data_free_slist(void *list)
 218 {
 219         curl_slist_free_all(*((struct curl_slist **) list));
 220 }
 221 /* }}} */
 222
 223 /* {{{ _http_request_data_free_context(http_request_callback_ctx **) */
 224 void _http_request_data_free_context(void *context)
 225 {
 226         efree(*((http_request_callback_ctx **) context));
 227 }
 228 /* }}} */
 229
 230 /* {{{ _http_request_data_free_conv(http_request_conv **) */
 231 void _http_request_data_free_conv(void *conv)
 232 {
 233         efree(*((http_request_conv **) conv));
 234 }
 235 /* }}} */
 236
 237 /* {{{ http_request_body *http_request_body_new() */
 238 PHP_HTTP_API http_request_body *_http_request_body_new(TSRMLS_D)
 239 {
 240         http_request_body *body = ecalloc(1, sizeof(http_request_body));
 241         return body;
 242 }
 243 /* }}} */
 244
 245 /* {{{ STATUS http_request_body_fill(http_request_body *body, HashTable *, HashTable *) */
 246 PHP_HTTP_API STATUS _http_request_body_fill(http_request_body *body, HashTable *fields, HashTable *files TSRMLS_DC)
 247 {
 248         if (files && (zend_hash_num_elements(files) > 0)) {
 249                 char *key = NULL;
 250                 ulong idx;
 251                 zval **data;
 252                 struct curl_httppost *http_post_data[2] = {NULL, NULL};
 253
 254                 /* normal data */
 255                 FOREACH_HASH_KEYVAL(fields, key, idx, data) {
 256                         CURLcode err;
 257                         if (key) {
 258                                 convert_to_string_ex(data);
 259                                 err = curl_formadd(&http_post_data[0], &http_post_data[1],
 260                                         CURLFORM_COPYNAME,                      key,
 261                                         CURLFORM_COPYCONTENTS,          Z_STRVAL_PP(data),
 262                                         CURLFORM_CONTENTSLENGTH,        (long) Z_STRLEN_PP(data),
 263                                         CURLFORM_END
 264                                 );
 265                                 if (CURLE_OK != err) {
 266                                         http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not encode post fields: %s", curl_easy_strerror(err));
 267                                         curl_formfree(http_post_data[0]);
 268                                         return FAILURE;
 269                                 }
 270
 271                                 /* reset */
 272                                 key = NULL;
 273                         }
 274                 }
 275
 276                 /* file data */
 277                 FOREACH_HASH_VAL(files, data) {
 278                         zval **file, **type, **name;
 279
 280                         if (    SUCCESS != zend_hash_find(Z_ARRVAL_PP(data), "name", sizeof("name"), (void **) &name) ||
 281                                         SUCCESS != zend_hash_find(Z_ARRVAL_PP(data), "type", sizeof("type"), (void **) &type) ||
 282                                         SUCCESS != zend_hash_find(Z_ARRVAL_PP(data), "file", sizeof("file"), (void **) &file)) {
 283                                 http_error(HE_NOTICE, HTTP_E_INVALID_PARAM, "Post file array entry misses either 'name', 'type' or 'file' entry");
 284                         } else {
 285                                 CURLcode err = curl_formadd(&http_post_data[0], &http_post_data[1],
 286                                         CURLFORM_COPYNAME,              Z_STRVAL_PP(name),
 287                                         CURLFORM_FILE,                  Z_STRVAL_PP(file),
 288                                         CURLFORM_CONTENTTYPE,   Z_STRVAL_PP(type),
 289                                         CURLFORM_END
 290                                 );
 291                                 if (CURLE_OK != err) {
 292                                         http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not encode post files: %s", curl_easy_strerror(err));
 293                                         curl_formfree(http_post_data[0]);
 294                                         return FAILURE;
 295                                 }
 296                         }
 297                 }
 298
 299                 body->type = HTTP_REQUEST_BODY_CURLPOST;
 300                 body->data = http_post_data[0];
 301                 body->size = 0;
 302
 303         } else {
 304                 char *encoded;
 305                 size_t encoded_len;
 306
 307                 if (SUCCESS != http_urlencode_hash_ex(fields, 1, NULL, 0, &encoded, &encoded_len)) {
 308                         http_error(HE_WARNING, HTTP_E_ENCODING, "Could not encode post data");
 309                         return FAILURE;
 310                 }
 311
 312                 body->type = HTTP_REQUEST_BODY_CSTRING;
 313                 body->data = encoded;
 314                 body->size = encoded_len;
 315         }
 316
 317         return SUCCESS;
 318 }
 319 /* }}} */
 320
 321 /* {{{ void http_request_body_dtor(http_request_body *) */
 322 PHP_HTTP_API void _http_request_body_dtor(http_request_body *body TSRMLS_DC)
 323 {
 324         if (body) {
 325                 switch (body->type)
 326                 {
 327                         case HTTP_REQUEST_BODY_CSTRING:
 328                                 if (body->data) {
 329                                         efree(body->data);
 330                                 }
 331                         break;
 332
 333                         case HTTP_REQUEST_BODY_CURLPOST:
 334                                 curl_formfree(body->data);
 335                         break;
 336
 337                         case HTTP_REQUEST_BODY_UPLOADFILE:
 338                                 php_stream_close(body->data);
 339                         break;
 340                 }
 341         }
 342 }
 343 /* }}} */
 344
 345 /* {{{ void http_request_body_free(http_request_body *) */
 346 PHP_HTTP_API void _http_request_body_free(http_request_body *body TSRMLS_DC)
 347 {
 348         if (body) {
 349                 http_request_body_dtor(body);
 350                 efree(body);
 351         }
 352 }
 353 /* }}} */
 354
 355 /* {{{ STATUS http_request_init(CURL *, http_request_method, char *, http_request_body *, HashTable *) */
 356 PHP_HTTP_API STATUS _http_request_init(CURL *ch, http_request_method meth, char *url, http_request_body *body, HashTable *options TSRMLS_DC)
 357 {
 358         zval *zoption;
 359         zend_bool range_req = 0;
 360
 361         /* reset CURL handle */
 362 #ifdef HAVE_CURL_EASY_RESET
 363         curl_easy_reset(ch);
 364 #endif
 365         http_curl_defaults(ch);
 366
 367         /* set options */
 368         if (url) {
 369                 HTTP_CURL_OPT(URL, http_request_data_copy(COPY_STRING, url));
 370         }
 371
 372         HTTP_CURL_OPT(HEADER, 0);
 373         HTTP_CURL_OPT(FILETIME, 1);
 374         HTTP_CURL_OPT(AUTOREFERER, 1);
 375         HTTP_CURL_OPT(READFUNCTION, http_curl_read_callback);
 376         /* we'll get all data through the debug function */
 377         HTTP_CURL_OPT(WRITEFUNCTION, http_curl_dummy_callback);
 378         HTTP_CURL_OPT(HEADERFUNCTION, NULL);
 379
 380         HTTP_CURL_OPT(VERBOSE, 1);
 381         HTTP_CURL_OPT(DEBUGFUNCTION, http_curl_raw_callback);
 382
 383 #if defined(ZTS) && (LIBCURL_VERSION_NUM >= 0x070a00)
 384         HTTP_CURL_OPT(NOSIGNAL, 1);
 385 #endif
 386 #if LIBCURL_VERSION_NUM < 0x070c00
 387         HTTP_CURL_OPT(ERRORBUFFER, HTTP_G(request).error);
 388 #endif
 389
 390         /* progress callback */
 391         if (zoption = http_curl_getopt(options, "onprogress", 0)) {
 392                 HTTP_CURL_OPT(NOPROGRESS, 0);
 393                 HTTP_CURL_OPT(PROGRESSFUNCTION, http_curl_progress_callback);
 394                 HTTP_CURL_OPT(PROGRESSDATA,  http_request_callback_data(zoption));
 395         }
 396
 397         /* proxy */
 398         if (zoption = http_curl_getopt(options, "proxyhost", IS_STRING)) {
 399                 HTTP_CURL_OPT(PROXY, http_request_data_copy(COPY_STRING, Z_STRVAL_P(zoption)));
 400                 /* port */
 401                 if (zoption = http_curl_getopt(options, "proxyport", IS_LONG)) {
 402                         HTTP_CURL_OPT(PROXYPORT, Z_LVAL_P(zoption));
 403                 }
 404                 /* user:pass */
 405                 if (zoption = http_curl_getopt(options, "proxyauth", IS_STRING)) {
 406                         HTTP_CURL_OPT(PROXYUSERPWD, http_request_data_copy(COPY_STRING, Z_STRVAL_P(zoption)));
 407                 }
 408 #if LIBCURL_VERSION_NUM >= 0x070a07
 409                 /* auth method */
 410                 if (zoption = http_curl_getopt(options, "proxyauthtype", IS_LONG)) {
 411                         HTTP_CURL_OPT(PROXYAUTH, Z_LVAL_P(zoption));
 412                 }
 413 #endif
 414         }
 415
 416         /* outgoing interface */
 417         if (zoption = http_curl_getopt(options, "interface", IS_STRING)) {
 418                 HTTP_CURL_OPT(INTERFACE, http_request_data_copy(COPY_STRING, Z_STRVAL_P(zoption)));
 419         }
 420
 421         /* another port */
 422         if (zoption = http_curl_getopt(options, "port", IS_LONG)) {
 423                 HTTP_CURL_OPT(PORT, Z_LVAL_P(zoption));
 424         }
 425
 426         /* auth */
 427         if (zoption = http_curl_getopt(options, "httpauth", IS_STRING)) {
 428                 HTTP_CURL_OPT(USERPWD, http_request_data_copy(COPY_STRING, Z_STRVAL_P(zoption)));
 429         }
 430 #if LIBCURL_VERSION_NUM >= 0x070a06
 431         if (zoption = http_curl_getopt(options, "httpauthtype", IS_LONG)) {
 432                 HTTP_CURL_OPT(HTTPAUTH, Z_LVAL_P(zoption));
 433         }
 434 #endif
 435
 436         /* compress, empty string enables deflate and gzip */
 437         if ((zoption = http_curl_getopt(options, "compress", IS_BOOL)) && Z_LVAL_P(zoption)) {
 438                 HTTP_CURL_OPT(ENCODING, "");
 439         }
 440
 441         /* redirects, defaults to 0 */
 442         if (zoption = http_curl_getopt(options, "redirect", IS_LONG)) {
 443                 HTTP_CURL_OPT(FOLLOWLOCATION, Z_LVAL_P(zoption) ? 1 : 0);
 444                 HTTP_CURL_OPT(MAXREDIRS, Z_LVAL_P(zoption));
 445                 if (zoption = http_curl_getopt(options, "unrestrictedauth", IS_BOOL)) {
 446                         HTTP_CURL_OPT(UNRESTRICTED_AUTH, Z_LVAL_P(zoption));
 447                 }
 448         }
 449
 450         /* referer */
 451         if (zoption = http_curl_getopt(options, "referer", IS_STRING)) {
 452                 HTTP_CURL_OPT(REFERER, http_request_data_copy(COPY_STRING, Z_STRVAL_P(zoption)));
 453         }
 454
 455         /* useragent, default "PECL::HTTP/version (PHP/version)" */
 456         if (zoption = http_curl_getopt(options, "useragent", IS_STRING)) {
 457                 HTTP_CURL_OPT(USERAGENT, http_request_data_copy(COPY_STRING, Z_STRVAL_P(zoption)));
 458         }
 459
 460         /* additional headers, array('name' => 'value') */
 461         if (zoption = http_curl_getopt(options, "headers", IS_ARRAY)) {
 462                 char *header_key;
 463                 ulong header_idx;
 464                 struct curl_slist *headers = NULL;
 465
 466                 FOREACH_KEY(zoption, header_key, header_idx) {
 467                         if (header_key) {
 468                                 zval **header_val;
 469                                 if (SUCCESS == zend_hash_get_current_data(Z_ARRVAL_P(zoption), (void **) &header_val)) {
 470                                         char header[1024] = {0};
 471                                         snprintf(header, 1023, "%s: %s", header_key, Z_STRVAL_PP(header_val));
 472                                         headers = curl_slist_append(headers, http_request_data_copy(COPY_STRING, header));
 473                                 }
 474
 475                                 /* reset */
 476                                 header_key = NULL;
 477                         }
 478                 }
 479
 480                 if (headers) {
 481                         HTTP_CURL_OPT(HTTPHEADER, http_request_data_copy(COPY_SLIST, headers));
 482                 }
 483         }
 484
 485         /* cookies, array('name' => 'value') */
 486         if (zoption = http_curl_getopt(options, "cookies", IS_ARRAY)) {
 487                 char *cookie_key = NULL;
 488                 ulong cookie_idx = 0;
 489                 phpstr *qstr = phpstr_new();
 490
 491                 FOREACH_KEY(zoption, cookie_key, cookie_idx) {
 492                         if (cookie_key) {
 493                                 zval **cookie_val;
 494                                 if (SUCCESS == zend_hash_get_current_data(Z_ARRVAL_P(zoption), (void **) &cookie_val)) {
 495                                         phpstr_appendf(qstr, "%s=%s; ", cookie_key, Z_STRVAL_PP(cookie_val));
 496                                 }
 497
 498                                 /* reset */
 499                                 cookie_key = NULL;
 500                         }
 501                 }
 502
 503                 if (qstr->used) {
 504                         phpstr_fix(qstr);
 505                         HTTP_CURL_OPT(COOKIE, http_request_data_copy(COPY_STRING, qstr->data));
 506                 }
 507                 phpstr_free(&qstr);
 508         }
 509
 510         /* session cookies */
 511         if (zoption = http_curl_getopt(options, "cookiesession", IS_BOOL)) {
 512                 if (Z_LVAL_P(zoption)) {
 513                         /* accept cookies for this session */
 514                         HTTP_CURL_OPT(COOKIEFILE, "");
 515                 } else {
 516                         /* reset session cookies */
 517                         HTTP_CURL_OPT(COOKIESESSION, 1);
 518                 }
 519         }
 520
 521         /* cookiestore, read initial cookies from that file and store cookies back into that file */
 522         if ((zoption = http_curl_getopt(options, "cookiestore", IS_STRING)) && Z_STRLEN_P(zoption)) {
 523                 HTTP_CURL_OPT(COOKIEFILE, http_request_data_copy(COPY_STRING, Z_STRVAL_P(zoption)));
 524                 HTTP_CURL_OPT(COOKIEJAR, http_request_data_copy(COPY_STRING, Z_STRVAL_P(zoption)));
 525         }
 526
 527         /* resume */
 528         if ((zoption = http_curl_getopt(options, "resume", IS_LONG)) && (Z_LVAL_P(zoption) != 0)) {
 529                 range_req = 1;
 530                 HTTP_CURL_OPT(RESUME_FROM, Z_LVAL_P(zoption));
 531         }
 532
 533         /* maxfilesize */
 534         if (zoption = http_curl_getopt(options, "maxfilesize", IS_LONG)) {
 535                 HTTP_CURL_OPT(MAXFILESIZE, Z_LVAL_P(zoption));
 536         }
 537
 538         /* lastmodified */
 539         if (zoption = http_curl_getopt(options, "lastmodified", IS_LONG)) {
 540                 HTTP_CURL_OPT(TIMECONDITION, range_req ? CURL_TIMECOND_IFUNMODSINCE : CURL_TIMECOND_IFMODSINCE);
 541                 HTTP_CURL_OPT(TIMEVALUE, Z_LVAL_P(zoption));
 542         }
 543
 544         /* timeout, defaults to 0 */
 545         if (zoption = http_curl_getopt(options, "timeout", IS_LONG)) {
 546                 HTTP_CURL_OPT(TIMEOUT, Z_LVAL_P(zoption));
 547         }
 548
 549         /* connecttimeout, defaults to 3 */
 550         if (zoption = http_curl_getopt(options, "connecttimeout", IS_LONG)) {
 551                 HTTP_CURL_OPT(CONNECTTIMEOUT, Z_LVAL_P(zoption));
 552         }
 553
 554         /* ssl */
 555         if (zoption = http_curl_getopt(options, "ssl", IS_ARRAY)) {
 556                 ulong idx;
 557                 char *key = NULL;
 558                 zval **param;
 559
 560                 FOREACH_KEYVAL(zoption, key, idx, param) {
 561                         if (key) {
 562                                 HTTP_CURL_OPT_SSL_STRING(CERT);
 563 #if LIBCURL_VERSION_NUM >= 0x070903
 564                                 HTTP_CURL_OPT_SSL_STRING(CERTTYPE);
 565 #endif
 566                                 HTTP_CURL_OPT_SSL_STRING(CERTPASSWD);
 567
 568                                 HTTP_CURL_OPT_SSL_STRING(KEY);
 569                                 HTTP_CURL_OPT_SSL_STRING(KEYTYPE);
 570                                 HTTP_CURL_OPT_SSL_STRING(KEYPASSWD);
 571
 572                                 HTTP_CURL_OPT_SSL_STRING(ENGINE);
 573                                 HTTP_CURL_OPT_SSL_LONG(VERSION);
 574
 575                                 HTTP_CURL_OPT_SSL_LONG_(VERIFYPEER);
 576                                 HTTP_CURL_OPT_SSL_LONG_(VERIFYHOST);
 577                                 HTTP_CURL_OPT_SSL_STRING_(CIPHER_LIST);
 578
 579
 580                                 HTTP_CURL_OPT_STRING(CAINFO);
 581 #if LIBCURL_VERSION_NUM >= 0x070908
 582                                 HTTP_CURL_OPT_STRING(CAPATH);
 583 #endif
 584                                 HTTP_CURL_OPT_STRING(RANDOM_FILE);
 585                                 HTTP_CURL_OPT_STRING(EGDSOCKET);
 586
 587                                 /* reset key */
 588                                 key = NULL;
 589                         }
 590                 }
 591         }
 592
 593         /* request method */
 594         switch (meth)
 595         {
 596                 case HTTP_GET:
 597                         curl_easy_setopt(ch, CURLOPT_HTTPGET, 1);
 598                 break;
 599
 600                 case HTTP_HEAD:
 601                         curl_easy_setopt(ch, CURLOPT_NOBODY, 1);
 602                 break;
 603
 604                 case HTTP_POST:
 605                         curl_easy_setopt(ch, CURLOPT_POST, 1);
 606                 break;
 607
 608                 case HTTP_PUT:
 609                         curl_easy_setopt(ch, CURLOPT_UPLOAD, 1);
 610                 break;
 611
 612                 default:
 613                         if (http_request_method_exists(0, meth, NULL)) {
 614                                 curl_easy_setopt(ch, CURLOPT_CUSTOMREQUEST, http_request_method_name(meth));
 615                         } else {
 616                                 http_error_ex(HE_WARNING, HTTP_E_REQUEST_METHOD, "Unsupported request method: %d", meth);
 617                                 return FAILURE;
 618                         }
 619                 break;
 620         }
 621
 622         /* attach request body */
 623         if (body && (meth != HTTP_GET) && (meth != HTTP_HEAD)) {
 624                 switch (body->type)
 625                 {
 626                         case HTTP_REQUEST_BODY_CSTRING:
 627                                 curl_easy_setopt(ch, CURLOPT_POSTFIELDS, body->data);
 628                                 curl_easy_setopt(ch, CURLOPT_POSTFIELDSIZE, body->size);
 629                         break;
 630
 631                         case HTTP_REQUEST_BODY_CURLPOST:
 632                                 curl_easy_setopt(ch, CURLOPT_HTTPPOST, (struct curl_httppost *) body->data);
 633                         break;
 634
 635                         case HTTP_REQUEST_BODY_UPLOADFILE:
 636                                 curl_easy_setopt(ch, CURLOPT_READDATA, http_request_callback_data(body));
 637                                 curl_easy_setopt(ch, CURLOPT_INFILESIZE, body->size);
 638                         break;
 639
 640                         default:
 641                                 /* shouldn't ever happen */
 642                                 http_error_ex(HE_ERROR, 0, "Unknown request body type: %d", body->type);
 643                                 return FAILURE;
 644                         break;
 645                 }
 646         }
 647
 648         return SUCCESS;
 649 }
 650 /* }}} */
 651
 652 /* {{{ void http_request_conv(CURL *, phpstr *, phpstr *) */
 653 void _http_request_conv(CURL *ch, phpstr* response, phpstr *request TSRMLS_DC)
 654 {
 655         http_request_conv *conv = emalloc(sizeof(http_request_conv));
 656         conv->response = response;
 657         conv->request = request;
 658         conv->last_info = -1;
 659         HTTP_CURL_OPT(DEBUGDATA, http_request_callback_data(http_request_data_copy(COPY_CONV, conv)));
 660 }
 661 /* }}} */
 662
 663 /* {{{ STATUS http_request_exec(CURL *, HashTable *) */
 664 PHP_HTTP_API STATUS _http_request_exec(CURL *ch, HashTable *info, phpstr *response, phpstr *request TSRMLS_DC)
 665 {
 666         CURLcode result;
 667
 668         http_request_conv(ch, response, request);
 669
 670         /* perform request */
 671         if (CURLE_OK != (result = curl_easy_perform(ch))) {
 672                 http_error_ex(HE_WARNING, HTTP_E_REQUEST, "Could not perform request: %s", curl_easy_strerror(result));
 673                 return FAILURE;
 674         } else {
 675                 /* get curl info */
 676                 if (info) {
 677                         http_request_info(ch, info);
 678                 }
 679                 return SUCCESS;
 680         }
 681 }
 682 /* }}} */
 683
 684 /* {{{ void http_request_info(CURL *, HashTable *) */
 685 PHP_HTTP_API void _http_request_info(CURL *ch, HashTable *info TSRMLS_DC)
 686 {
 687         zval array;
 688         INIT_ZARR(array, info);
 689
 690         HTTP_CURL_INFO(EFFECTIVE_URL);
 691 #if LIBCURL_VERSION_NUM >= 0x070a07
 692         HTTP_CURL_INFO(RESPONSE_CODE);
 693 #else
 694         HTTP_CURL_INFO_EX(HTTP_CODE, RESPONSE_CODE);
 695 #endif
 696         HTTP_CURL_INFO(HTTP_CONNECTCODE);
 697 #if LIBCURL_VERSION_NUM >= 0x070500
 698         HTTP_CURL_INFO(FILETIME);
 699 #endif
 700         HTTP_CURL_INFO(TOTAL_TIME);
 701         HTTP_CURL_INFO(NAMELOOKUP_TIME);
 702         HTTP_CURL_INFO(CONNECT_TIME);
 703         HTTP_CURL_INFO(PRETRANSFER_TIME);
 704         HTTP_CURL_INFO(STARTTRANSFER_TIME);
 705 #if LIBCURL_VERSION_NUM >= 0x070907
 706         HTTP_CURL_INFO(REDIRECT_TIME);
 707         HTTP_CURL_INFO(REDIRECT_COUNT);
 708 #endif
 709         HTTP_CURL_INFO(SIZE_UPLOAD);
 710         HTTP_CURL_INFO(SIZE_DOWNLOAD);
 711         HTTP_CURL_INFO(SPEED_DOWNLOAD);
 712         HTTP_CURL_INFO(SPEED_UPLOAD);
 713         HTTP_CURL_INFO(HEADER_SIZE);
 714         HTTP_CURL_INFO(REQUEST_SIZE);
 715         HTTP_CURL_INFO(SSL_VERIFYRESULT);
 716 #if LIBCURL_VERSION_NUM >= 0x070c03
 717         /*HTTP_CURL_INFO(SSL_ENGINES); todo: CURLINFO_SLIST */
 718 #endif
 719         HTTP_CURL_INFO(CONTENT_LENGTH_DOWNLOAD);
 720         HTTP_CURL_INFO(CONTENT_LENGTH_UPLOAD);
 721         HTTP_CURL_INFO(CONTENT_TYPE);
 722 #if LIBCURL_VERSION_NUM >= 0x070a03
 723         /*HTTP_CURL_INFO(PRIVATE);*/
 724 #endif
 725 #if LIBCURL_VERSION_NUM >= 0x070a08
 726         HTTP_CURL_INFO(HTTPAUTH_AVAIL);
 727         HTTP_CURL_INFO(PROXYAUTH_AVAIL);
 728 #endif
 729 #if LIBCURL_VERSION_NUM >= 0x070c02
 730         /*HTTP_CURL_INFO(OS_ERRNO);*/
 731 #endif
 732 #if LIBCURL_VERSION_NUM >= 0x070c03
 733         HTTP_CURL_INFO(NUM_CONNECTS);
 734 #endif
 735 }
 736 /* }}} */
 737
 738 /* {{{ STATUS http_request_ex(CURL *, http_request_method, char *, http_request_body, HashTable, HashTable, phpstr *) */
 739 PHP_HTTP_API STATUS _http_request_ex(CURL *ch, http_request_method meth, char *url, http_request_body *body, HashTable *options, HashTable *info, phpstr *response TSRMLS_DC)
 740 {
 741         STATUS status;
 742         zend_bool clean_curl;
 743
 744         if ((clean_curl = (!ch))) {
 745                 if (!(ch = curl_easy_init())) {
 746                         http_error(HE_WARNING, HTTP_E_REQUEST, "Could not initialize curl.");
 747                         return FAILURE;
 748                 }
 749         }
 750
 751         status =        ((SUCCESS == http_request_init(ch, meth, url, body, options)) &&
 752                                 (SUCCESS == http_request_exec(ch, info, response, NULL))) ? SUCCESS : FAILURE;
 753
 754         if (clean_curl) {
 755                 curl_easy_cleanup(ch);
 756         }
 757         return status;
 758 }
 759 /* }}} */
 760
 761 /* {{{ static size_t http_curl_read_callback(void *, size_t, size_t, void *) */
 762 static size_t http_curl_read_callback(void *data, size_t len, size_t n, void *s)
 763 {
 764         HTTP_REQUEST_CALLBACK_DATA(s, http_request_body *, body);
 765
 766         if (body->type != HTTP_REQUEST_BODY_UPLOADFILE) {
 767                 return 0;
 768         }
 769         return php_stream_read((php_stream *) body->data, data, len * n);
 770 }
 771 /* }}} */
 772
 773 /* {{{ static int http_curl_progress_callback(void *, double, double, double, double) */
 774 static int http_curl_progress_callback(void *data, double dltotal, double dlnow, double ultotal, double ulnow)
 775 {
 776         zval *params_pass[4], params_local[4], retval;
 777         HTTP_REQUEST_CALLBACK_DATA(data, zval *, func);
 778
 779         params_pass[0] = &params_local[0];
 780         params_pass[1] = &params_local[1];
 781         params_pass[2] = &params_local[2];
 782         params_pass[3] = &params_local[3];
 783
 784         INIT_PZVAL(params_pass[0]);
 785         INIT_PZVAL(params_pass[1]);
 786         INIT_PZVAL(params_pass[2]);
 787         INIT_PZVAL(params_pass[3]);
 788         ZVAL_DOUBLE(params_pass[0], dltotal);
 789         ZVAL_DOUBLE(params_pass[1], dlnow);
 790         ZVAL_DOUBLE(params_pass[2], ultotal);
 791         ZVAL_DOUBLE(params_pass[3], ulnow);
 792
 793         return call_user_function(EG(function_table), NULL, func, &retval, 4, params_pass TSRMLS_CC);
 794 }
 795 /* }}} */
 796
 797 /* {{{ static int http_curl_raw_callback(CURL *, curl_infotype, char *, size_t, void *) */
 798 static int http_curl_raw_callback(CURL *ch, curl_infotype type, char *data, size_t length, void *ctx)
 799 {
 800         HTTP_REQUEST_CALLBACK_DATA(ctx, http_request_conv *, conv);
 801
 802 #if 0
 803         fprintf(stderr, "DEBUG: %s\n", data);
 804 #endif
 805
 806         switch (type)
 807         {
 808                 case CURLINFO_DATA_IN:
 809                         if (conv->response && conv->last_info == CURLINFO_HEADER_IN) {
 810                                 phpstr_appends(conv->response, HTTP_CRLF);
 811                         }
 812                 case CURLINFO_HEADER_IN:
 813                         if (conv->response) {
 814                                 phpstr_append(conv->response, data, length);
 815                         }
 816                 break;
 817                 case CURLINFO_DATA_OUT:
 818                         if (conv->request && conv->last_info == CURLINFO_HEADER_OUT) {
 819                                 phpstr_appends(conv->request, HTTP_CRLF);
 820                         }
 821                 case CURLINFO_HEADER_OUT:
 822                         if (conv->request) {
 823                                 phpstr_append(conv->request, data, length);
 824                         }
 825                 break;
 826         }
 827
 828         if (type) {
 829                 conv->last_info = type;
 830         }
 831         return 0;
 832 }
 833 /* }}} */
 834
 835 /* {{{ static inline zval *http_curl_getopt(HashTable *, char *, size_t, int) */
 836 static inline zval *_http_curl_getopt_ex(HashTable *options, char *key, size_t keylen, int type TSRMLS_DC)
 837 {
 838         zval **zoption;
 839
 840         if (!options || (SUCCESS != zend_hash_find(options, key, keylen, (void **) &zoption))) {
 841                 return NULL;
 842         }
 843
 844         if (Z_TYPE_PP(zoption) != type) {
 845                 switch (type)
 846                 {
 847                         case IS_BOOL:   convert_to_boolean_ex(zoption); break;
 848                         case IS_LONG:   convert_to_long_ex(zoption);    break;
 849                         case IS_DOUBLE: convert_to_double_ex(zoption);  break;
 850                         case IS_STRING: convert_to_string_ex(zoption);  break;
 851                         case IS_ARRAY:  convert_to_array_ex(zoption);   break;
 852                         case IS_OBJECT: convert_to_object_ex(zoption);  break;
 853                         default:
 854                         break;
 855                 }
 856         }
 857
 858         return *zoption;
 859 }
 860 /* }}} */
 861
 862 #ifdef HTTP_NEED_SSL
 863
 864 static MUTEX_T *http_ssl_mutex = NULL;
 865
 866 static void http_ssl_lock(int mode, int n, const char * file, int line)
 867 {
 868         if (mode & CRYPTO_LOCK) {
 869                 tsrm_mutex_lock(http_ssl_mutex[n]);
 870         } else {
 871                 tsrm_mutex_unlock(http_ssl_mutex[n]);
 872         }
 873 }
 874
 875 static unsigned long http_ssl_id(void)
 876 {
 877         return (unsigned long) tsrm_thread_id();
 878 }
 879
 880 static inline zend_bool http_ssl_init(void)
 881 {
 882         curl_version_info_data *cvid = curl_version_info(CURLVERSION_NOW);
 883
 884         if (cvid && (cvid->features & CURL_VERSION_SSL)) {
 885                 int i, c = CRYPTO_num_locks();
 886
 887                 http_ssl_mutex = malloc(c * sizeof(MUTEX_T));
 888
 889                 for (i = 0; i < c; ++i) {
 890                         http_ssl_mutex[i] = tsrm_mutex_alloc();
 891                 }
 892
 893                 CRYPTO_set_id_callback(http_ssl_id);
 894                 CRYPTO_set_locking_callback(http_ssl_lock);
 895
 896                 return 1;
 897         }
 898
 899         return 0;
 900 }
 901
 902 static inline void http_ssl_cleanup(void)
 903 {
 904         if (http_ssl_mutex) {
 905                 int i, c = CRYPTO_num_locks();
 906
 907                 CRYPTO_set_id_callback(NULL);
 908                 CRYPTO_set_locking_callback(NULL);
 909
 910                 for (i = 0; i < c; ++i) {
 911                         tsrm_mutex_free(http_ssl_mutex[i]);
 912                 }
 913
 914                 free(http_ssl_mutex);
 915                 http_ssl_mutex = NULL;
 916         }
 917 }
 918 #endif /* HTTP_NEED_SSL */
 919
 920 static inline void _http_curl_defaults(CURL *ch)
 921 {
 922         HTTP_CURL_OPT(URL, NULL);
 923         HTTP_CURL_OPT(NOPROGRESS, 1);
 924         HTTP_CURL_OPT(PROXY, NULL);
 925         HTTP_CURL_OPT(PROXYPORT, 0);
 926         HTTP_CURL_OPT(PROXYUSERPWD, NULL);
 927 #if LIBCURL_VERSION_NUM >= 0x070a07
 928         HTTP_CURL_OPT(PROXYAUTH, 0);
 929 #endif
 930         HTTP_CURL_OPT(INTERFACE, NULL);
 931         HTTP_CURL_OPT(PORT, 0);
 932         HTTP_CURL_OPT(USERPWD, NULL);
 933 #if LIBCURL_VERSION_NUM >= 0x070a06
 934         HTTP_CURL_OPT(HTTPAUTH, 0);
 935 #endif
 936         HTTP_CURL_OPT(ENCODING, 0);
 937         HTTP_CURL_OPT(FOLLOWLOCATION, 0);
 938         HTTP_CURL_OPT(UNRESTRICTED_AUTH, 0);
 939         HTTP_CURL_OPT(REFERER, NULL);
 940         HTTP_CURL_OPT(USERAGENT, "PECL::HTTP/" HTTP_PEXT_VERSION " (PHP/" PHP_VERSION ")");
 941         HTTP_CURL_OPT(HTTPHEADER, NULL);
 942         HTTP_CURL_OPT(COOKIE, NULL);
 943         HTTP_CURL_OPT(COOKIEFILE, NULL);
 944         HTTP_CURL_OPT(COOKIEJAR, NULL);
 945         HTTP_CURL_OPT(RESUME_FROM, 0);
 946         HTTP_CURL_OPT(MAXFILESIZE, 0);
 947         HTTP_CURL_OPT(TIMEVALUE, 0);
 948         HTTP_CURL_OPT(TIMEOUT, 0);
 949         HTTP_CURL_OPT(CONNECTTIMEOUT, 3);
 950         HTTP_CURL_OPT(SSLCERT, NULL);
 951 #if LIBCURL_VERSION_NUM >= 0x070903
 952         HTTP_CURL_OPT(SSLCERTTYPE, NULL);
 953 #endif
 954         HTTP_CURL_OPT(SSLCERTPASSWD, NULL);
 955         HTTP_CURL_OPT(SSLKEY, NULL);
 956         HTTP_CURL_OPT(SSLKEYTYPE, NULL);
 957         HTTP_CURL_OPT(SSLKEYPASSWD, NULL);
 958         HTTP_CURL_OPT(SSLENGINE, NULL);
 959         HTTP_CURL_OPT(SSLVERSION, 0);
 960         HTTP_CURL_OPT(SSL_VERIFYPEER, 0);
 961         HTTP_CURL_OPT(SSL_VERIFYHOST, 0);
 962         HTTP_CURL_OPT(SSL_CIPHER_LIST, NULL);
 963         HTTP_CURL_OPT(CAINFO, NULL);
 964 #if LIBCURL_VERSION_NUM >= 0x070908
 965         HTTP_CURL_OPT(CAPATH, NULL);
 966 #endif
 967         HTTP_CURL_OPT(RANDOM_FILE, NULL);
 968         HTTP_CURL_OPT(EGDSOCKET, NULL);
 969         HTTP_CURL_OPT(POSTFIELDS, NULL);
 970         HTTP_CURL_OPT(POSTFIELDSIZE, 0);
 971         HTTP_CURL_OPT(HTTPPOST, NULL);
 972         HTTP_CURL_OPT(READDATA, NULL);
 973         HTTP_CURL_OPT(INFILESIZE, 0);
 974 }
 975
 976 #endif /* HTTP_HAVE_CURL */
 977
 978 /*
 979  * Local variables:
 980  * tab-width: 4
 981  * c-basic-offset: 4
 982  * End:
 983  * vim600: noet sw=4 ts=4 fdm=marker
 984  * vim<600: noet sw=4 ts=4
 985  */
 986