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