projects / m6w6 / ext-http / blob
? search:


d6a370481dbe2da6cb0c90cbb9e276f7f8f50d6d
[m6w6/ext-http] / http_request_api.c
1 /*
2 +--------------------------------------------------------------------+
3 | PECL :: http |
4 +--------------------------------------------------------------------+
5 | Redistribution and use in source and binary forms, with or without |
6 | modification, are permitted provided that the conditions mentioned |
7 | in the accompanying LICENSE file are met. |
8 +--------------------------------------------------------------------+
9 | Copyright (c) 2004-2006, Michael Wallner <mike@php.net> |
10 +--------------------------------------------------------------------+
11 */
12
13 /* $Id$ */
14
15 #define HTTP_WANT_SAPI
16 #define HTTP_WANT_CURL
17 #include "php_http.h"
18
19 #ifdef HTTP_HAVE_CURL
20
21 #include "php_http_api.h"
22 #include "php_http_request_api.h"
23 #include "php_http_url_api.h"
24
25 #ifdef ZEND_ENGINE_2
26 # include "php_http_request_object.h"
27 #endif
28
29 /* {{{ cruft for thread safe SSL crypto locks */
30 #if defined(ZTS) && defined(HTTP_HAVE_SSL)
31 # ifdef PHP_WIN32
32 # define HTTP_NEED_OPENSSL_TSL
33 # include <openssl/crypto.h>
34 # else /* !PHP_WIN32 */
35 # if defined(HTTP_HAVE_OPENSSL)
36 # if defined(HAVE_OPENSSL_CRYPTO_H)
37 # define HTTP_NEED_OPENSSL_TSL
38 # include <openssl/crypto.h>
39 # else
40 # warning \
41 "libcurl was compiled with OpenSSL support, but configure could not find " \
42 "openssl/crypto.h; thus no SSL crypto locking callbacks will be set, which may " \
43 "cause random crashes on SSL requests"
44 # endif
45 # elif defined(HTTP_HAVE_GNUTLS)
46 # if defined(HAVE_GCRYPT_H)
47 # define HTTP_NEED_GNUTLS_TSL
48 # include <gcrypt.h>
49 # else
50 # warning \
51 "libcurl was compiled with GnuTLS support, but configure could not find " \
52 "gcrypt.h; thus no SSL crypto locking callbacks will be set, which may " \
53 "cause random crashes on SSL requests"
54 # endif
55 # else
56 # warning \
57 "libcurl was compiled with SSL support, but configure could not determine which" \
58 "library was used; thus no SSL crypto locking callbacks will be set, which may " \
59 "cause random crashes on SSL requests"
60 # endif /* HTTP_HAVE_OPENSSL || HTTP_HAVE_GNUTLS */
61 # endif /* PHP_WIN32 */
62 #endif /* ZTS && HTTP_HAVE_SSL */
63
64 #ifdef HTTP_NEED_OPENSSL_TSL
65 static MUTEX_T *http_openssl_tsl = NULL;
66
67 static void http_openssl_thread_lock(int mode, int n, const char * file, int line)
68 {
69 if (mode & CRYPTO_LOCK) {
70 tsrm_mutex_lock(http_openssl_tsl[n]);
71 } else {
72 tsrm_mutex_unlock(http_openssl_tsl[n]);
73 }
74 }
75
76 static ulong http_openssl_thread_id(void)
77 {
78 return (ulong) tsrm_thread_id();
79 }
80 #endif
81 #ifdef HTTP_NEED_GNUTLS_TSL
82 static int http_gnutls_mutex_create(void **m)
83 {
84 if (*((MUTEX_T *) m) = tsrm_mutex_alloc()) {
85 return SUCCESS;
86 } else {
87 return FAILURE;
88 }
89 }
90
91 static int http_gnutls_mutex_destroy(void **m)
92 {
93 tsrm_mutex_free(*((MUTEX_T *) m));
94 return SUCCESS;
95 }
96
97 static int http_gnutls_mutex_lock(void **m)
98 {
99 return tsrm_mutex_lock(*((MUTEX_T *) m));
100 }
101
102 static int http_gnutls_mutex_unlock(void **m)
103 {
104 return tsrm_mutex_unlock(*((MUTEX_T *) m));
105 }
106
107 static struct gcry_thread_cbs http_gnutls_tsl = {
108 GCRY_THREAD_OPTION_USER,
109 NULL,
110 http_gnutls_mutex_create,
111 http_gnutls_mutex_destroy,
112 http_gnutls_mutex_lock,
113 http_gnutls_mutex_unlock
114 };
115 #endif
116 /* }}} */
117
118 /* {{{ MINIT */
119 PHP_MINIT_FUNCTION(http_request)
120 {
121 #ifdef HTTP_NEED_OPENSSL_TSL
122 int i, c = CRYPTO_num_locks();
123
124 http_openssl_tsl = malloc(c * sizeof(MUTEX_T));
125
126 for (i = 0; i < c; ++i) {
127 http_openssl_tsl[i] = tsrm_mutex_alloc();
128 }
129
130 CRYPTO_set_id_callback(http_openssl_thread_id);
131 CRYPTO_set_locking_callback(http_openssl_thread_lock);
132 #endif
133 #ifdef HTTP_NEED_GNUTLS_TSL
134 gcry_control(GCRYCTL_SET_THREAD_CBS, &http_gnutls_tsl);
135 #endif
136
137 if (CURLE_OK != curl_global_init(CURL_GLOBAL_ALL)) {
138 return FAILURE;
139 }
140
141 HTTP_LONG_CONSTANT("HTTP_AUTH_BASIC", CURLAUTH_BASIC);
142 HTTP_LONG_CONSTANT("HTTP_AUTH_DIGEST", CURLAUTH_DIGEST);
143 HTTP_LONG_CONSTANT("HTTP_AUTH_NTLM", CURLAUTH_NTLM);
144 HTTP_LONG_CONSTANT("HTTP_AUTH_ANY", CURLAUTH_ANY);
145
146 HTTP_LONG_CONSTANT("HTTP_VERSION_NONE", CURL_HTTP_VERSION_NONE);
147 HTTP_LONG_CONSTANT("HTTP_VERSION_1_0", CURL_HTTP_VERSION_1_0);
148 HTTP_LONG_CONSTANT("HTTP_VERSION_1_1", CURL_HTTP_VERSION_1_1);
149
150 #if HTTP_CURL_VERSION(7,15,2)
151 HTTP_LONG_CONSTANT("HTTP_PROXY_SOCKS4", CURLPROXY_SOCKS4);
152 #endif
153 HTTP_LONG_CONSTANT("HTTP_PROXY_SOCKS5", CURLPROXY_SOCKS5);
154 HTTP_LONG_CONSTANT("HTTP_PROXY_HTTP", CURLPROXY_HTTP);
155 return SUCCESS;
156 }
157 /* }}} */
158
159 /* {{{ MSHUTDOWN */
160 PHP_MSHUTDOWN_FUNCTION(http_request)
161 {
162 #ifdef HTTP_NEED_OPENSSL_TSL
163 CRYPTO_set_id_callback(http_openssl_thread_id);
164 CRYPTO_set_locking_callback(http_openssl_thread_lock);
165 #endif
166 curl_global_cleanup();
167 #ifdef HTTP_NEED_OPENSSL_TSL
168 if (http_openssl_tsl) {
169 int i, c = CRYPTO_num_locks();
170
171 CRYPTO_set_id_callback(NULL);
172 CRYPTO_set_locking_callback(NULL);
173
174 for (i = 0; i < c; ++i) {
175 tsrm_mutex_free(http_openssl_tsl[i]);
176 }
177
178 free(http_openssl_tsl);
179 http_openssl_tsl = NULL;
180 }
181 #endif
182 return SUCCESS;
183 }
184 /* }}} */
185
186 /* {{{ MACROS */
187 #ifndef HAVE_CURL_EASY_STRERROR
188 # define curl_easy_strerror(dummy) "unknown error"
189 #endif
190
191 #define HTTP_CURL_INFO(I) \
192 { \
193 char *N = #I; \
194 HTTP_CURL_INFO_EX(I, N+lenof("CURLINFO_")); \
195 }
196 #define HTTP_CURL_INFO_EX(I, X) \
197 switch (I & ~CURLINFO_MASK) \
198 { \
199 case CURLINFO_STRING: \
200 { \
201 char *c; \
202 if (CURLE_OK == curl_easy_getinfo(request->ch, I, &c)) { \
203 char *key = estrndup(X, strlen(X)); \
204 add_assoc_string(&array, pretty_key(key, strlen(X), 0, 0), c ? c : "", 1); \
205 efree(key); \
206 } \
207 } \
208 break; \
209 \
210 case CURLINFO_DOUBLE: \
211 { \
212 double d; \
213 if (CURLE_OK == curl_easy_getinfo(request->ch, I, &d)) { \
214 char *key = estrndup(X, strlen(X)); \
215 add_assoc_double(&array, pretty_key(key, strlen(X), 0, 0), d); \
216 efree(key); \
217 } \
218 } \
219 break; \
220 \
221 case CURLINFO_LONG: \
222 { \
223 long l; \
224 if (CURLE_OK == curl_easy_getinfo(request->ch, I, &l)) { \
225 char *key = estrndup(X, strlen(X)); \
226 add_assoc_long(&array, pretty_key(key, strlen(X), 0, 0), l); \
227 efree(key); \
228 } \
229 } \
230 break; \
231 \
232 case CURLINFO_SLIST: \
233 { \
234 struct curl_slist *l, *p; \
235 if (CURLE_OK == curl_easy_getinfo(request->ch, I, &l)) { \
236 zval *subarray; \
237 char *key = estrndup(X, strlen(X)); \
238 MAKE_STD_ZVAL(subarray); \
239 array_init(subarray); \
240 for (p = l; p; p = p->next) { \
241 add_next_index_string(subarray, p->data, 1); \
242 } \
243 add_assoc_zval(&array, pretty_key(key, strlen(X), 0, 0), subarray); \
244 curl_slist_free_all(l); \
245 efree(key); \
246 } \
247 } \
248 }
249
250 #define HTTP_CURL_OPT(OPTION, p) HTTP_CURL_OPT_EX(request->ch, OPTION, (p))
251 #define HTTP_CURL_OPT_EX(ch, OPTION, p) curl_easy_setopt((ch), OPTION, (p))
252
253 #define HTTP_CURL_OPT_STRING(OPTION, ldiff, obdc) \
254 { \
255 char *K = #OPTION; \
256 HTTP_CURL_OPT_STRING_EX(K+lenof("CURLOPT_KEY")+ldiff, OPTION, obdc); \
257 }
258 #define HTTP_CURL_OPT_STRING_EX(keyname, optname, obdc) \
259 if (!strcasecmp(key, keyname)) { \
260 zval *copy = http_request_option_cache_ex(request, keyname, strlen(keyname)+1, 0, zval_copy(IS_STRING, *param)); \
261 if (obdc) { \
262 HTTP_CHECK_OPEN_BASEDIR(Z_STRVAL_P(copy), return FAILURE); \
263 } \
264 HTTP_CURL_OPT(optname, Z_STRVAL_P(copy)); \
265 key = NULL; \
266 continue; \
267 }
268 #define HTTP_CURL_OPT_LONG(OPTION, ldiff) \
269 { \
270 char *K = #OPTION; \
271 HTTP_CURL_OPT_LONG_EX(K+lenof("CURLOPT_KEY")+ldiff, OPTION); \
272 }
273 #define HTTP_CURL_OPT_LONG_EX(keyname, optname) \
274 if (!strcasecmp(key, keyname)) { \
275 zval *copy = zval_copy(IS_LONG, *param); \
276 HTTP_CURL_OPT(optname, Z_LVAL_P(copy)); \
277 key = NULL; \
278 zval_free(&copy); \
279 continue; \
280 }
281 /* }}} */
282
283 /* {{{ forward declarations */
284 #define http_request_option(r, o, k, t) _http_request_option_ex((r), (o), (k), sizeof(k), (t) TSRMLS_CC)
285 #define http_request_option_ex(r, o, k, l, t) _http_request_option_ex((r), (o), (k), (l), (t) TSRMLS_CC)
286 static inline zval *_http_request_option_ex(http_request *request, HashTable *options, char *key, size_t keylen, int type TSRMLS_DC);
287 #define http_request_option_cache(r, k, z) _http_request_option_cache_ex((r), (k), sizeof(k), 0, (z) TSRMLS_CC)
288 #define http_request_option_cache_ex(r, k, kl, h, z) _http_request_option_cache_ex((r), (k), (kl), (h), (z) TSRMLS_CC)
289 static inline zval *_http_request_option_cache_ex(http_request *r, char *key, size_t keylen, ulong h, zval *opt TSRMLS_DC);
290
291 static size_t http_curl_read_callback(void *, size_t, size_t, void *);
292 static int http_curl_progress_callback(void *, double, double, double, double);
293 static int http_curl_raw_callback(CURL *, curl_infotype, char *, size_t, void *);
294 static int http_curl_dummy_callback(char *data, size_t n, size_t l, void *s) { return n*l; }
295 static curlioerr http_curl_ioctl_callback(CURL *, curliocmd, void *);
296 /* }}} */
297
298 /* {{{ CURL *http_curl_init(http_request *) */
299 PHP_HTTP_API CURL * _http_curl_init_ex(CURL *ch, http_request *request)
300 {
301 if (ch || (ch = curl_easy_init())) {
302 #if defined(ZTS)
303 HTTP_CURL_OPT_EX(ch, CURLOPT_NOSIGNAL, 1);
304 #endif
305 HTTP_CURL_OPT_EX(ch, CURLOPT_HEADER, 0);
306 HTTP_CURL_OPT_EX(ch, CURLOPT_FILETIME, 1);
307 HTTP_CURL_OPT_EX(ch, CURLOPT_AUTOREFERER, 1);
308 HTTP_CURL_OPT_EX(ch, CURLOPT_VERBOSE, 1);
309 HTTP_CURL_OPT_EX(ch, CURLOPT_HEADERFUNCTION, NULL);
310 HTTP_CURL_OPT_EX(ch, CURLOPT_DEBUGFUNCTION, http_curl_raw_callback);
311 HTTP_CURL_OPT_EX(ch, CURLOPT_READFUNCTION, http_curl_read_callback);
312 HTTP_CURL_OPT_EX(ch, CURLOPT_IOCTLFUNCTION, http_curl_ioctl_callback);
313 HTTP_CURL_OPT_EX(ch, CURLOPT_WRITEFUNCTION, http_curl_dummy_callback);
314
315 /* set context */
316 if (request) {
317 HTTP_CURL_OPT_EX(ch, CURLOPT_PRIVATE, request);
318 HTTP_CURL_OPT_EX(ch, CURLOPT_DEBUGDATA, request);
319 HTTP_CURL_OPT_EX(ch, CURLOPT_ERRORBUFFER, request->_error);
320
321 /* attach curl handle */
322 request->ch = ch;
323 /* set defaults (also in http_request_reset()) */
324 http_request_defaults(request);
325 }
326 }
327
328 return ch;
329 }
330 /* }}} */
331
332 /* {{{ void http_curl_free(CURL **) */
333 PHP_HTTP_API void _http_curl_free(CURL **ch)
334 {
335 if (*ch) {
336 /* avoid nasty segfaults with already cleaned up callbacks */
337 HTTP_CURL_OPT_EX(*ch, CURLOPT_NOPROGRESS, 1);
338 HTTP_CURL_OPT_EX(*ch, CURLOPT_PROGRESSFUNCTION, NULL);
339 HTTP_CURL_OPT_EX(*ch, CURLOPT_VERBOSE, 0);
340 HTTP_CURL_OPT_EX(*ch, CURLOPT_DEBUGFUNCTION, NULL);
341 curl_easy_cleanup(*ch);
342 *ch = NULL;
343 }
344 }
345 /* }}} */
346
347 /* {{{ http_request *http_request_init(http_request *) */
348 PHP_HTTP_API http_request *_http_request_init_ex(http_request *request, CURL *ch, http_request_method meth, const char *url ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC TSRMLS_DC)
349 {
350 http_request *r;
351
352 if (request) {
353 r = request;
354 } else {
355 r = emalloc_rel(sizeof(http_request));
356 }
357 memset(r, 0, sizeof(http_request));
358
359 r->ch = ch;
360 r->url = (url) ? http_absolute_url(url) : NULL;
361 r->meth = (meth > 0) ? meth : HTTP_GET;
362
363 phpstr_init(&r->conv.request);
364 phpstr_init_ex(&r->conv.response, HTTP_CURLBUF_SIZE, 0);
365 phpstr_init(&r->_cache.cookies);
366 zend_hash_init(&r->_cache.options, 0, NULL, ZVAL_PTR_DTOR, 0);
367
368 TSRMLS_SET_CTX(r->tsrm_ls);
369
370 return r;
371 }
372 /* }}} */
373
374 /* {{{ void http_request_dtor(http_request *) */
375 PHP_HTTP_API void _http_request_dtor(http_request *request)
376 {
377 http_curl_free(&request->ch);
378 http_request_reset(request);
379
380 phpstr_dtor(&request->_cache.cookies);
381 zend_hash_destroy(&request->_cache.options);
382 if (request->_cache.headers) {
383 curl_slist_free_all(request->_cache.headers);
384 request->_cache.headers = NULL;
385 }
386 if (request->_progress_callback) {
387 zval_ptr_dtor(&request->_progress_callback);
388 request->_progress_callback = NULL;
389 }
390 }
391 /* }}} */
392
393 /* {{{ void http_request_free(http_request **) */
394 PHP_HTTP_API void _http_request_free(http_request **request)
395 {
396 if (*request) {
397 TSRMLS_FETCH_FROM_CTX((*request)->tsrm_ls);
398 http_request_body_free(&(*request)->body);
399 http_request_dtor(*request);
400 efree(*request);
401 *request = NULL;
402 }
403 }
404 /* }}} */
405
406 /* {{{ void http_request_reset(http_request *) */
407 PHP_HTTP_API void _http_request_reset(http_request *request)
408 {
409 TSRMLS_FETCH_FROM_CTX(request->tsrm_ls);
410 STR_SET(request->url, NULL);
411 request->conv.last_type = 0;
412 phpstr_dtor(&request->conv.request);
413 phpstr_dtor(&request->conv.response);
414 http_request_body_dtor(request->body);
415
416 if (request->ch) {
417 http_request_defaults(request);
418 }
419 request->_error[0] = '\0';
420 }
421 /* }}} */
422
423 /* {{{ STATUS http_request_enable_cookies(http_request *) */
424 PHP_HTTP_API STATUS _http_request_enable_cookies(http_request *request)
425 {
426 TSRMLS_FETCH_FROM_CTX(request->tsrm_ls);
427 if (CURLE_OK == curl_easy_setopt(request->ch, CURLOPT_COOKIEFILE, "")) {
428 return SUCCESS;
429 }
430 http_error(HE_WARNING, HTTP_E_REQUEST, "Could not enable cookies for this session");
431 return FAILURE;
432 }
433 /* }}} */
434
435 /* {{{ STATUS http_request_reset_cookies(http_request *) */
436 PHP_HTTP_API STATUS _http_request_reset_cookies(http_request *request)
437 {
438 TSRMLS_FETCH_FROM_CTX(request->tsrm_ls);
439 #if HTTP_CURL_VERSION(7,14,1)
440 if (CURLE_OK == curl_easy_setopt(request->ch, CURLOPT_COOKIELIST, "ALL")) {
441 return SUCCESS;
442 }
443 #endif
444 http_error(HE_WARNING, HTTP_E_REQUEST, "Could not reset cookies");
445 return FAILURE;
446 }
447 /* }}} */
448
449 /* {{{ void http_request_defaults(http_request *) */
450 PHP_HTTP_API void _http_request_defaults(http_request *request)
451 {
452 if (request->ch) {
453 HTTP_CURL_OPT(CURLOPT_PROGRESSFUNCTION, NULL);
454 HTTP_CURL_OPT(CURLOPT_URL, NULL);
455 HTTP_CURL_OPT(CURLOPT_NOPROGRESS, 1);
456 HTTP_CURL_OPT(CURLOPT_PROXY, NULL);
457 HTTP_CURL_OPT(CURLOPT_PROXYPORT, 0);
458 HTTP_CURL_OPT(CURLOPT_PROXYTYPE, 0);
459 HTTP_CURL_OPT(CURLOPT_PROXYUSERPWD, NULL);
460 HTTP_CURL_OPT(CURLOPT_PROXYAUTH, 0);
461 HTTP_CURL_OPT(CURLOPT_INTERFACE, NULL);
462 HTTP_CURL_OPT(CURLOPT_PORT, 0);
463 #if HTTP_CURL_VERSION(7,15,2)
464 HTTP_CURL_OPT(CURLOPT_LOCALPORT, 0);
465 HTTP_CURL_OPT(CURLOPT_LOCALPORTRANGE, 0);
466 #endif
467 HTTP_CURL_OPT(CURLOPT_USERPWD, NULL);
468 HTTP_CURL_OPT(CURLOPT_HTTPAUTH, 0);
469 HTTP_CURL_OPT(CURLOPT_ENCODING, NULL);
470 HTTP_CURL_OPT(CURLOPT_FOLLOWLOCATION, 0);
471 HTTP_CURL_OPT(CURLOPT_UNRESTRICTED_AUTH, 0);
472 HTTP_CURL_OPT(CURLOPT_REFERER, NULL);
473 HTTP_CURL_OPT(CURLOPT_USERAGENT, "PECL::HTTP/" PHP_EXT_HTTP_VERSION " (PHP/" PHP_VERSION ")");
474 HTTP_CURL_OPT(CURLOPT_HTTPHEADER, NULL);
475 HTTP_CURL_OPT(CURLOPT_COOKIE, NULL);
476 #if HTTP_CURL_VERSION(7,14,1)
477 HTTP_CURL_OPT(CURLOPT_COOKIELIST, NULL);
478 #endif
479 HTTP_CURL_OPT(CURLOPT_RANGE, NULL);
480 HTTP_CURL_OPT(CURLOPT_RESUME_FROM, 0);
481 HTTP_CURL_OPT(CURLOPT_MAXFILESIZE, 0);
482 HTTP_CURL_OPT(CURLOPT_TIMECONDITION, 0);
483 HTTP_CURL_OPT(CURLOPT_TIMEVALUE, 0);
484 HTTP_CURL_OPT(CURLOPT_TIMEOUT, 0);
485 HTTP_CURL_OPT(CURLOPT_CONNECTTIMEOUT, 3);
486 HTTP_CURL_OPT(CURLOPT_SSLCERT, NULL);
487 HTTP_CURL_OPT(CURLOPT_SSLCERTTYPE, NULL);
488 HTTP_CURL_OPT(CURLOPT_SSLCERTPASSWD, NULL);
489 HTTP_CURL_OPT(CURLOPT_SSLKEY, NULL);
490 HTTP_CURL_OPT(CURLOPT_SSLKEYTYPE, NULL);
491 HTTP_CURL_OPT(CURLOPT_SSLKEYPASSWD, NULL);
492 HTTP_CURL_OPT(CURLOPT_SSLENGINE, NULL);
493 HTTP_CURL_OPT(CURLOPT_SSLVERSION, 0);
494 HTTP_CURL_OPT(CURLOPT_SSL_VERIFYPEER, 0);
495 HTTP_CURL_OPT(CURLOPT_SSL_VERIFYHOST, 0);
496 HTTP_CURL_OPT(CURLOPT_SSL_CIPHER_LIST, NULL);
497 HTTP_CURL_OPT(CURLOPT_CAINFO, NULL);
498 HTTP_CURL_OPT(CURLOPT_CAPATH, NULL);
499 HTTP_CURL_OPT(CURLOPT_RANDOM_FILE, NULL);
500 HTTP_CURL_OPT(CURLOPT_EGDSOCKET, NULL);
501 HTTP_CURL_OPT(CURLOPT_POSTFIELDS, NULL);
502 HTTP_CURL_OPT(CURLOPT_POSTFIELDSIZE, 0);
503 HTTP_CURL_OPT(CURLOPT_HTTPPOST, NULL);
504 HTTP_CURL_OPT(CURLOPT_IOCTLDATA, NULL);
505 HTTP_CURL_OPT(CURLOPT_READDATA, NULL);
506 HTTP_CURL_OPT(CURLOPT_INFILESIZE, 0);
507 HTTP_CURL_OPT(CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_NONE);
508 HTTP_CURL_OPT(CURLOPT_CUSTOMREQUEST, NULL);
509 HTTP_CURL_OPT(CURLOPT_NOBODY, 0);
510 HTTP_CURL_OPT(CURLOPT_POST, 0);
511 HTTP_CURL_OPT(CURLOPT_UPLOAD, 0);
512 HTTP_CURL_OPT(CURLOPT_HTTPGET, 1);
513 }
514 }
515 /* }}} */
516
517 PHP_HTTP_API void _http_request_set_progress_callback(http_request *request, zval *cb)
518 {
519 if (request->_progress_callback) {
520 zval_ptr_dtor(&request->_progress_callback);
521 }
522 if ((request->_progress_callback = cb)) {
523 ZVAL_ADDREF(cb);
524 HTTP_CURL_OPT(CURLOPT_NOPROGRESS, 0);
525 HTTP_CURL_OPT(CURLOPT_PROGRESSDATA, request);
526 HTTP_CURL_OPT(CURLOPT_PROGRESSFUNCTION, http_curl_progress_callback);
527 } else {
528 HTTP_CURL_OPT(CURLOPT_NOPROGRESS, 1);
529 HTTP_CURL_OPT(CURLOPT_PROGRESSDATA, NULL);
530 HTTP_CURL_OPT(CURLOPT_PROGRESSFUNCTION, NULL);
531 }
532 }
533
534 /* {{{ STATUS http_request_prepare(http_request *, HashTable *) */
535 PHP_HTTP_API STATUS _http_request_prepare(http_request *request, HashTable *options)
536 {
537 zval *zoption;
538 zend_bool range_req = 0;
539
540 TSRMLS_FETCH_FROM_CTX(request->tsrm_ls);
541
542 HTTP_CHECK_CURL_INIT(request->ch, http_curl_init(request), return FAILURE);
543
544 /* set options */
545 HTTP_CURL_OPT(CURLOPT_URL, request->url);
546
547 /* progress callback */
548 if ((zoption = http_request_option(request, options, "onprogress", -1))) {
549 http_request_set_progress_callback(request, zoption);
550 }
551
552 /* proxy */
553 if ((zoption = http_request_option(request, options, "proxyhost", IS_STRING))) {
554 if (Z_STRLEN_P(zoption)) {
555 HTTP_CURL_OPT(CURLOPT_PROXY, Z_STRVAL_P(zoption));
556 }
557 /* type */
558 if ((zoption = http_request_option(request, options, "proxytype", IS_LONG))) {
559 HTTP_CURL_OPT(CURLOPT_PROXYTYPE, Z_LVAL_P(zoption));
560 }
561 /* port */
562 if ((zoption = http_request_option(request, options, "proxyport", IS_LONG))) {
563 HTTP_CURL_OPT(CURLOPT_PROXYPORT, Z_LVAL_P(zoption));
564 }
565 /* user:pass */
566 if ((zoption = http_request_option(request, options, "proxyauth", IS_STRING)) && Z_STRLEN_P(zoption)) {
567 HTTP_CURL_OPT(CURLOPT_PROXYUSERPWD, Z_STRVAL_P(zoption));
568 }
569 /* auth method */
570 if ((zoption = http_request_option(request, options, "proxyauthtype", IS_LONG))) {
571 HTTP_CURL_OPT(CURLOPT_PROXYAUTH, Z_LVAL_P(zoption));
572 }
573 }
574
575 /* outgoing interface */
576 if ((zoption = http_request_option(request, options, "interface", IS_STRING))) {
577 HTTP_CURL_OPT(CURLOPT_INTERFACE, Z_STRVAL_P(zoption));
578
579 #if HTTP_CURL_VERSION(7,15,2)
580 if ((zoption = http_request_option(request, options, "portrange", IS_ARRAY))) {
581 zval **prs, **pre;
582
583 zend_hash_internal_pointer_reset(Z_ARRVAL_P(zoption));
584 if (SUCCESS == zend_hash_get_current_data(Z_ARRVAL_P(zoption), (void *) &prs)) {
585 zend_hash_move_forward(Z_ARRVAL_P(zoption));
586 if (SUCCESS == zend_hash_get_current_data(Z_ARRVAL_P(zoption), (void *) &pre)) {
587 zval *prs_cpy = zval_copy(IS_LONG, *prs), *pre_cpy = zval_copy(IS_LONG, *pre);
588
589 if (Z_LVAL_P(prs_cpy) && Z_LVAL_P(pre_cpy)) {
590 HTTP_CURL_OPT(CURLOPT_LOCALPORT, MIN(Z_LVAL_P(prs_cpy), Z_LVAL_P(pre_cpy)));
591 HTTP_CURL_OPT(CURLOPT_LOCALPORTRANGE, labs(Z_LVAL_P(prs_cpy)-Z_LVAL_P(pre_cpy))+1L);
592 }
593 zval_free(&prs_cpy);
594 zval_free(&pre_cpy);
595 }
596 }
597 }
598 #endif
599 }
600
601 /* another port */
602 if ((zoption = http_request_option(request, options, "port", IS_LONG))) {
603 HTTP_CURL_OPT(CURLOPT_PORT, Z_LVAL_P(zoption));
604 }
605
606 /* auth */
607 if ((zoption = http_request_option(request, options, "httpauth", IS_STRING)) && Z_STRLEN_P(zoption)) {
608 HTTP_CURL_OPT(CURLOPT_USERPWD, Z_STRVAL_P(zoption));
609 }
610 if ((zoption = http_request_option(request, options, "httpauthtype", IS_LONG))) {
611 HTTP_CURL_OPT(CURLOPT_HTTPAUTH, Z_LVAL_P(zoption));
612 }
613
614 /* redirects, defaults to 0 */
615 if ((zoption = http_request_option(request, options, "redirect", IS_LONG))) {
616 HTTP_CURL_OPT(CURLOPT_FOLLOWLOCATION, Z_LVAL_P(zoption) ? 1 : 0);
617 HTTP_CURL_OPT(CURLOPT_MAXREDIRS, Z_LVAL_P(zoption));
618 if ((zoption = http_request_option(request, options, "unrestrictedauth", IS_BOOL))) {
619 HTTP_CURL_OPT(CURLOPT_UNRESTRICTED_AUTH, Z_LVAL_P(zoption));
620 }
621 }
622
623 /* referer */
624 if ((zoption = http_request_option(request, options, "referer", IS_STRING)) && Z_STRLEN_P(zoption)) {
625 HTTP_CURL_OPT(CURLOPT_REFERER, Z_STRVAL_P(zoption));
626 }
627
628 /* useragent, default "PECL::HTTP/version (PHP/version)" */
629 if ((zoption = http_request_option(request, options, "useragent", IS_STRING))) {
630 /* allow to send no user agent, not even default one */
631 if (Z_STRLEN_P(zoption)) {
632 HTTP_CURL_OPT(CURLOPT_USERAGENT, Z_STRVAL_P(zoption));
633 } else {
634 HTTP_CURL_OPT(CURLOPT_USERAGENT, NULL);
635 }
636 }
637
638 /* resume */
639 if ((zoption = http_request_option(request, options, "resume", IS_LONG)) && (Z_LVAL_P(zoption) != 0)) {
640 range_req = 1;
641 HTTP_CURL_OPT(CURLOPT_RESUME_FROM, Z_LVAL_P(zoption));
642 }
643 /* or range of kind array(array(0,499), array(100,1499)) */
644 else if ((zoption = http_request_option(request, options, "range", IS_ARRAY)) && zend_hash_num_elements(Z_ARRVAL_P(zoption))) {
645 HashPosition pos1, pos2;
646 zval **rr, **rb, **re;
647 phpstr rs;
648
649 phpstr_init(&rs);
650 FOREACH_VAL(pos1, zoption, rr) {
651 if (Z_TYPE_PP(rr) == IS_ARRAY) {
652 zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(rr), &pos2);
653 if (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_PP(rr), (void *) &rb, &pos2)) {
654 zend_hash_move_forward_ex(Z_ARRVAL_PP(rr), &pos2);
655 if (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_PP(rr), (void *) &re, &pos2)) {
656 if ( ((Z_TYPE_PP(rb) == IS_LONG) || ((Z_TYPE_PP(rb) == IS_STRING) && is_numeric_string(Z_STRVAL_PP(rb), Z_STRLEN_PP(rb), NULL, NULL, 1))) &&
657 ((Z_TYPE_PP(re) == IS_LONG) || ((Z_TYPE_PP(re) == IS_STRING) && is_numeric_string(Z_STRVAL_PP(re), Z_STRLEN_PP(re), NULL, NULL, 1)))) {
658 zval *rbl = zval_copy(IS_LONG, *rb), *rel = zval_copy(IS_LONG, *re);
659
660 if ((Z_LVAL_P(rbl) >= 0) && (Z_LVAL_P(rel) >= 0)) {
661 phpstr_appendf(&rs, "%ld-%ld,", Z_LVAL_P(rbl), Z_LVAL_P(rel));
662 }
663 zval_free(&rbl);
664 zval_free(&rel);
665 }
666 }
667 }
668 }
669 }
670
671 if (PHPSTR_LEN(&rs)) {
672 zval *cached_range;
673
674 /* ditch last comma */
675 PHPSTR_VAL(&rs)[PHPSTR_LEN(&rs)-- -1] = '\0';
676 /* cache string */
677 MAKE_STD_ZVAL(cached_range);
678 ZVAL_STRINGL(cached_range, PHPSTR_VAL(&rs), PHPSTR_LEN(&rs), 0);
679 HTTP_CURL_OPT(CURLOPT_RANGE, Z_STRVAL_P(http_request_option_cache(request, "range", cached_range)));
680 zval_ptr_dtor(&cached_range);
681 }
682 }
683
684 /* additional headers, array('name' => 'value') */
685 if (request->_cache.headers) {
686 curl_slist_free_all(request->_cache.headers);
687 request->_cache.headers = NULL;
688 }
689 if ((zoption = http_request_option(request, options, "headers", IS_ARRAY))) {
690 char *header_key;
691 ulong header_idx;
692 HashPosition pos;
693
694 FOREACH_KEY(pos, zoption, header_key, header_idx) {
695 if (header_key) {
696 zval **header_val;
697 if (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_P(zoption), (void *) &header_val, &pos)) {
698 char header[1024] = {0};
699
700 ZVAL_ADDREF(*header_val);
701 convert_to_string_ex(header_val);
702 if (!strcasecmp(header_key, "range")) {
703 range_req = 1;
704 }
705 snprintf(header, lenof(header), "%s: %s", header_key, Z_STRVAL_PP(header_val));
706 request->_cache.headers = curl_slist_append(request->_cache.headers, header);
707 zval_ptr_dtor(header_val);
708 }
709
710 /* reset */
711 header_key = NULL;
712 }
713 }
714 }
715 /* etag */
716 if ((zoption = http_request_option(request, options, "etag", IS_STRING)) && Z_STRLEN_P(zoption)) {
717 char match_header[1024] = {0}, *quoted_etag = NULL;
718
719 if ((Z_STRVAL_P(zoption)[0] != '"') || (Z_STRVAL_P(zoption)[Z_STRLEN_P(zoption)-1] != '"')) {
720 spprintf(&quoted_etag, 0, "\"%s\"", Z_STRVAL_P(zoption));
721 }
722 snprintf(match_header, lenof(match_header), "%s: %s", range_req?"If-Match":"If-None-Match", quoted_etag?quoted_etag:Z_STRVAL_P(zoption));
723 request->_cache.headers = curl_slist_append(request->_cache.headers, match_header);
724 STR_FREE(quoted_etag);
725 }
726 /* compression */
727 if ((zoption = http_request_option(request, options, "compress", IS_BOOL)) && Z_LVAL_P(zoption)) {
728 request->_cache.headers = curl_slist_append(request->_cache.headers, "Accept-Encoding: gzip;q=1.0,deflate;q=0.5");
729 }
730 HTTP_CURL_OPT(CURLOPT_HTTPHEADER, request->_cache.headers);
731
732 /* lastmodified */
733 if ((zoption = http_request_option(request, options, "lastmodified", IS_LONG))) {
734 if (Z_LVAL_P(zoption)) {
735 if (Z_LVAL_P(zoption) > 0) {
736 HTTP_CURL_OPT(CURLOPT_TIMEVALUE, Z_LVAL_P(zoption));
737 } else {
738 HTTP_CURL_OPT(CURLOPT_TIMEVALUE, HTTP_GET_REQUEST_TIME() + Z_LVAL_P(zoption));
739 }
740 HTTP_CURL_OPT(CURLOPT_TIMECONDITION, range_req ? CURL_TIMECOND_IFUNMODSINCE : CURL_TIMECOND_IFMODSINCE);
741 } else {
742 HTTP_CURL_OPT(CURLOPT_TIMECONDITION, CURL_TIMECOND_NONE);
743 }
744 }
745
746 /* cookies, array('name' => 'value') */
747 if ((zoption = http_request_option(request, options, "cookies", IS_ARRAY))) {
748 phpstr_dtor(&request->_cache.cookies);
749 if (zend_hash_num_elements(Z_ARRVAL_P(zoption))) {
750 zval *urlenc_cookies = NULL;
751 /* check whether cookies should not be urlencoded; default is to urlencode them */
752 if ((!(urlenc_cookies = http_request_option(request, options, "encodecookies", IS_BOOL))) || Z_BVAL_P(urlenc_cookies)) {
753 if (SUCCESS == http_urlencode_hash_recursive(HASH_OF(zoption), &request->_cache.cookies, "; ", lenof("; "), NULL, 0)) {
754 phpstr_fix(&request->_cache.cookies);
755 HTTP_CURL_OPT(CURLOPT_COOKIE, request->_cache.cookies.data);
756 }
757 } else {
758 HashPosition pos;
759 char *cookie_key = NULL;
760 ulong cookie_idx;
761
762 FOREACH_KEY(pos, zoption, cookie_key, cookie_idx) {
763 if (cookie_key) {
764 zval **cookie_val;
765 if (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_P(zoption), (void *) &cookie_val, &pos)) {
766 zval *val = zval_copy(IS_STRING, *cookie_val);
767 phpstr_appendf(&request->_cache.cookies, "%s=%s; ", cookie_key, Z_STRVAL_P(val));
768 zval_free(&val);
769 }
770
771 /* reset */
772 cookie_key = NULL;
773 }
774 }
775
776 phpstr_fix(&request->_cache.cookies);
777 if (PHPSTR_LEN(&request->_cache.cookies)) {
778 HTTP_CURL_OPT(CURLOPT_COOKIE, PHPSTR_VAL(&request->_cache.cookies));
779 }
780 }
781 }
782 }
783
784 /* don't load session cookies from cookiestore */
785 if ((zoption = http_request_option(request, options, "cookiesession", IS_BOOL)) && Z_BVAL_P(zoption)) {
786 HTTP_CURL_OPT(CURLOPT_COOKIESESSION, 1);
787 }
788
789 /* cookiestore, read initial cookies from that file and store cookies back into that file */
790 if ((zoption = http_request_option(request, options, "cookiestore", IS_STRING))) {
791 if (Z_STRLEN_P(zoption)) {
792 HTTP_CHECK_OPEN_BASEDIR(Z_STRVAL_P(zoption), return FAILURE);
793 }
794 HTTP_CURL_OPT(CURLOPT_COOKIEFILE, Z_STRVAL_P(zoption));
795 HTTP_CURL_OPT(CURLOPT_COOKIEJAR, Z_STRVAL_P(zoption));
796 }
797
798 /* maxfilesize */
799 if ((zoption = http_request_option(request, options, "maxfilesize", IS_LONG))) {
800 HTTP_CURL_OPT(CURLOPT_MAXFILESIZE, Z_LVAL_P(zoption));
801 }
802
803 /* http protocol */
804 if ((zoption = http_request_option(request, options, "protocol", IS_LONG))) {
805 HTTP_CURL_OPT(CURLOPT_HTTP_VERSION, Z_LVAL_P(zoption));
806 }
807
808 /* timeout, defaults to 0 */
809 if ((zoption = http_request_option(request, options, "timeout", IS_LONG))) {
810 HTTP_CURL_OPT(CURLOPT_TIMEOUT, Z_LVAL_P(zoption));
811 }
812
813 /* connecttimeout, defaults to 0 */
814 if ((zoption = http_request_option(request, options, "connecttimeout", IS_LONG))) {
815 HTTP_CURL_OPT(CURLOPT_CONNECTTIMEOUT, Z_LVAL_P(zoption));
816 }
817
818 /* ssl */
819 if ((zoption = http_request_option(request, options, "ssl", IS_ARRAY))) {
820 ulong idx;
821 char *key = NULL;
822 zval **param;
823 HashPosition pos;
824
825 FOREACH_KEYVAL(pos, zoption, key, idx, param) {
826 if (key) {
827 HTTP_CURL_OPT_STRING(CURLOPT_SSLCERT, 0, 1);
828 HTTP_CURL_OPT_STRING(CURLOPT_SSLCERTTYPE, 0, 0);
829 HTTP_CURL_OPT_STRING(CURLOPT_SSLCERTPASSWD, 0, 0);
830
831 HTTP_CURL_OPT_STRING(CURLOPT_SSLKEY, 0, 0);
832 HTTP_CURL_OPT_STRING(CURLOPT_SSLKEYTYPE, 0, 0);
833 HTTP_CURL_OPT_STRING(CURLOPT_SSLKEYPASSWD, 0, 0);
834
835 HTTP_CURL_OPT_STRING(CURLOPT_SSLENGINE, 0, 0);
836 HTTP_CURL_OPT_LONG(CURLOPT_SSLVERSION, 0);
837
838 HTTP_CURL_OPT_LONG(CURLOPT_SSL_VERIFYPEER, 1);
839 HTTP_CURL_OPT_LONG(CURLOPT_SSL_VERIFYHOST, 1);
840 HTTP_CURL_OPT_STRING(CURLOPT_SSL_CIPHER_LIST, 1, 0);
841
842 HTTP_CURL_OPT_STRING(CURLOPT_CAINFO, -3, 1);
843 HTTP_CURL_OPT_STRING(CURLOPT_CAPATH, -3, 1);
844 HTTP_CURL_OPT_STRING(CURLOPT_RANDOM_FILE, -3, 1);
845 HTTP_CURL_OPT_STRING(CURLOPT_EGDSOCKET, -3, 1);
846
847 /* reset key */
848 key = NULL;
849 }
850 }
851 }
852
853 /* request method */
854 switch (request->meth) {
855 case HTTP_GET:
856 HTTP_CURL_OPT(CURLOPT_HTTPGET, 1);
857 break;
858
859 case HTTP_HEAD:
860 HTTP_CURL_OPT(CURLOPT_NOBODY, 1);
861 break;
862
863 case HTTP_POST:
864 HTTP_CURL_OPT(CURLOPT_POST, 1);
865 break;
866
867 case HTTP_PUT:
868 HTTP_CURL_OPT(CURLOPT_UPLOAD, 1);
869 break;
870
871 default:
872 if (http_request_method_exists(0, request->meth, NULL)) {
873 HTTP_CURL_OPT(CURLOPT_CUSTOMREQUEST, http_request_method_name(request->meth));
874 } else {
875 http_error_ex(HE_WARNING, HTTP_E_REQUEST_METHOD, "Unsupported request method: %d (%s)", request->meth, request->url);
876 return FAILURE;
877 }
878 break;
879 }
880
881 /* attach request body */
882 if (request->body && (request->meth != HTTP_GET) && (request->meth != HTTP_HEAD) && (request->meth != HTTP_OPTIONS)) {
883 switch (request->body->type) {
884 case HTTP_REQUEST_BODY_EMPTY:
885 /* nothing */
886 break;
887
888 case HTTP_REQUEST_BODY_CURLPOST:
889 HTTP_CURL_OPT(CURLOPT_HTTPPOST, (struct curl_httppost *) request->body->data);
890 break;
891
892 case HTTP_REQUEST_BODY_CSTRING:
893 if (request->meth != HTTP_PUT) {
894 HTTP_CURL_OPT(CURLOPT_POSTFIELDS, request->body->data);
895 HTTP_CURL_OPT(CURLOPT_POSTFIELDSIZE, request->body->size);
896 break;
897 }
898 /* fallthrough, PUT/UPLOAD _needs_ READDATA */
899 case HTTP_REQUEST_BODY_UPLOADFILE:
900 HTTP_CURL_OPT(CURLOPT_IOCTLDATA, request);
901 HTTP_CURL_OPT(CURLOPT_READDATA, request);
902 HTTP_CURL_OPT(CURLOPT_INFILESIZE, request->body->size);
903 break;
904
905 default:
906 /* shouldn't ever happen */
907 http_error_ex(HE_ERROR, 0, "Unknown request body type: %d (%s)", request->body->type, request->url);
908 return FAILURE;
909 }
910 }
911
912 return SUCCESS;
913 }
914 /* }}} */
915
916 /* {{{ void http_request_exec(http_request *) */
917 PHP_HTTP_API void _http_request_exec(http_request *request)
918 {
919 CURLcode result;
920 TSRMLS_FETCH_FROM_CTX(request->tsrm_ls);
921
922 if (CURLE_OK != (result = curl_easy_perform(request->ch))) {
923 http_error_ex(HE_WARNING, HTTP_E_REQUEST, "%s; %s (%s)", curl_easy_strerror(result), request->_error, request->url);
924 }
925 }
926 /* }}} */
927
928 /* {{{ void http_request_info(http_request *, HashTable *) */
929 PHP_HTTP_API void _http_request_info(http_request *request, HashTable *info)
930 {
931 zval array;
932 INIT_ZARR(array, info);
933
934 HTTP_CURL_INFO(CURLINFO_EFFECTIVE_URL);
935 HTTP_CURL_INFO(CURLINFO_RESPONSE_CODE);
936 HTTP_CURL_INFO_EX(CURLINFO_HTTP_CONNECTCODE, "connect_code");
937 HTTP_CURL_INFO(CURLINFO_FILETIME);
938 HTTP_CURL_INFO(CURLINFO_TOTAL_TIME);
939 HTTP_CURL_INFO(CURLINFO_NAMELOOKUP_TIME);
940 HTTP_CURL_INFO(CURLINFO_CONNECT_TIME);
941 HTTP_CURL_INFO(CURLINFO_PRETRANSFER_TIME);
942 HTTP_CURL_INFO(CURLINFO_STARTTRANSFER_TIME);
943 HTTP_CURL_INFO(CURLINFO_REDIRECT_TIME);
944 HTTP_CURL_INFO(CURLINFO_REDIRECT_COUNT);
945 HTTP_CURL_INFO(CURLINFO_SIZE_UPLOAD);
946 HTTP_CURL_INFO(CURLINFO_SIZE_DOWNLOAD);
947 HTTP_CURL_INFO(CURLINFO_SPEED_DOWNLOAD);
948 HTTP_CURL_INFO(CURLINFO_SPEED_UPLOAD);
949 HTTP_CURL_INFO(CURLINFO_HEADER_SIZE);
950 HTTP_CURL_INFO(CURLINFO_REQUEST_SIZE);
951 HTTP_CURL_INFO(CURLINFO_SSL_VERIFYRESULT);
952 HTTP_CURL_INFO(CURLINFO_SSL_ENGINES);
953 HTTP_CURL_INFO(CURLINFO_CONTENT_LENGTH_DOWNLOAD);
954 HTTP_CURL_INFO(CURLINFO_CONTENT_LENGTH_UPLOAD);
955 HTTP_CURL_INFO(CURLINFO_CONTENT_TYPE);
956 HTTP_CURL_INFO(CURLINFO_HTTPAUTH_AVAIL);
957 HTTP_CURL_INFO(CURLINFO_PROXYAUTH_AVAIL);
958 HTTP_CURL_INFO(CURLINFO_NUM_CONNECTS);
959 #if HTTP_CURL_VERSION(7,14,1)
960 HTTP_CURL_INFO_EX(CURLINFO_COOKIELIST, "cookies");
961 #endif
962 HTTP_CURL_INFO(CURLINFO_OS_ERRNO);
963 add_assoc_string(&array, "error", request->_error, 1);
964 }
965 /* }}} */
966
967 /* {{{ static size_t http_curl_read_callback(void *, size_t, size_t, void *) */
968 static size_t http_curl_read_callback(void *data, size_t len, size_t n, void *ctx)
969 {
970 http_request *request = (http_request *) ctx;
971 TSRMLS_FETCH_FROM_CTX(request->tsrm_ls);
972
973 if (request->body) {
974 switch (request->body->type) {
975 case HTTP_REQUEST_BODY_CSTRING:
976 {
977 size_t out = MIN(len * n, request->body->size - request->body->priv);
978
979 if (out) {
980 memcpy(data, ((char *) request->body->data) + request->body->priv, out);
981 request->body->priv += out;
982 return out;
983 }
984 break;
985 }
986
987 case HTTP_REQUEST_BODY_UPLOADFILE:
988 return php_stream_read((php_stream *) request->body->data, data, len * n);
989 }
990 }
991 return 0;
992 }
993 /* }}} */
994
995 /* {{{ static int http_curl_progress_callback(void *, double, double, double, double) */
996 static int http_curl_progress_callback(void *ctx, double dltotal, double dlnow, double ultotal, double ulnow)
997 {
998 zval *param, retval;
999 http_request *request = (http_request *) ctx;
1000 TSRMLS_FETCH_FROM_CTX(request->tsrm_ls);
1001
1002 INIT_PZVAL(&retval);
1003 ZVAL_NULL(&retval);
1004
1005 MAKE_STD_ZVAL(param);
1006 array_init(param);
1007 add_assoc_double(param, "dltotal", dltotal);
1008 add_assoc_double(param, "dlnow", dlnow);
1009 add_assoc_double(param, "ultotal", ultotal);
1010 add_assoc_double(param, "ulnow", ulnow);
1011
1012 with_error_handling(EH_NORMAL, NULL) {
1013 call_user_function(EG(function_table), NULL, request->_progress_callback, &retval, 1, &param TSRMLS_CC);
1014 } end_error_handling();
1015
1016 zval_ptr_dtor(&param);
1017 zval_dtor(&retval);
1018
1019 return 0;
1020 }
1021 /* }}} */
1022
1023 /* {{{ static curlioerr http_curl_ioctl_callback(CURL *, curliocmd, void *) */
1024 static curlioerr http_curl_ioctl_callback(CURL *ch, curliocmd cmd, void *ctx)
1025 {
1026 http_request *request = (http_request *) ctx;
1027 TSRMLS_FETCH_FROM_CTX(request->tsrm_ls);
1028
1029 if (cmd != CURLIOCMD_RESTARTREAD) {
1030 return CURLIOE_UNKNOWNCMD;
1031 }
1032
1033 if (request->body) {
1034 switch (request->body->type) {
1035 case HTTP_REQUEST_BODY_CSTRING:
1036 request->body->priv = 0;
1037 return CURLIOE_OK;
1038 break;
1039
1040 case HTTP_REQUEST_BODY_UPLOADFILE:
1041 if (SUCCESS == php_stream_rewind((php_stream *) request->body->data)) {
1042 return CURLIOE_OK;
1043 }
1044 break;
1045 }
1046 }
1047
1048 return CURLIOE_FAILRESTART;
1049 }
1050 /* }}} */
1051
1052 /* {{{ static int http_curl_raw_callback(CURL *, curl_infotype, char *, size_t, void *) */
1053 static int http_curl_raw_callback(CURL *ch, curl_infotype type, char *data, size_t length, void *ctx)
1054 {
1055 http_request *request = (http_request *) ctx;
1056
1057 switch (type) {
1058 case CURLINFO_DATA_IN:
1059 if (request->conv.last_type == CURLINFO_HEADER_IN) {
1060 phpstr_appends(&request->conv.response, HTTP_CRLF);
1061 }
1062 case CURLINFO_HEADER_IN:
1063 phpstr_append(&request->conv.response, data, length);
1064 break;
1065 case CURLINFO_DATA_OUT:
1066 if (request->conv.last_type == CURLINFO_HEADER_OUT) {
1067 phpstr_appends(&request->conv.request, HTTP_CRLF);
1068 }
1069 case CURLINFO_HEADER_OUT:
1070 phpstr_append(&request->conv.request, data, length);
1071 break;
1072 default:
1073 #if 0
1074 fprintf(stderr, "## ", type);
1075 if (!type) {
1076 fprintf(stderr, "%s", data);
1077 } else {
1078 ulong i;
1079 for (i = 1; i <= length; ++i) {
1080 fprintf(stderr, "%02X ", data[i-1] & 0xFF);
1081 if (!(i % 20)) {
1082 fprintf(stderr, "\n## ");
1083 }
1084 }
1085 fprintf(stderr, "\n");
1086 }
1087 if (data[length-1] != 0xa) {
1088 fprintf(stderr, "\n");
1089 }
1090 #endif
1091 break;
1092 }
1093
1094 if (type) {
1095 request->conv.last_type = type;
1096 }
1097 return 0;
1098 }
1099 /* }}} */
1100
1101 /* {{{ static inline zval *http_request_option(http_request *, HashTable *, char *, size_t, int) */
1102 static inline zval *_http_request_option_ex(http_request *r, HashTable *options, char *key, size_t keylen, int type TSRMLS_DC)
1103 {
1104 zval **zoption;
1105 #ifdef ZEND_ENGINE_2
1106 ulong h = zend_get_hash_value(key, keylen);
1107 #else
1108 ulong h = 0;
1109 #endif
1110
1111 if (!options ||
1112 #ifdef ZEND_ENGINE_2
1113 (SUCCESS != zend_hash_quick_find(options, key, keylen, h, (void *) &zoption))
1114 #else
1115 (SUCCESS != zend_hash_find(options, key, keylen, (void *) &zoption))
1116 #endif
1117 ) {
1118 return NULL;
1119 }
1120
1121 return http_request_option_cache_ex(r, key, keylen, h, zval_copy(type, *zoption));
1122 }
1123 /* }}} */
1124
1125 /* {{{ static inline zval *http_request_option_cache(http_request *, char *key, zval *) */
1126 static inline zval *_http_request_option_cache_ex(http_request *r, char *key, size_t keylen, ulong h, zval *opt TSRMLS_DC)
1127 {
1128 ZVAL_ADDREF(opt);
1129
1130 #ifdef ZEND_ENGINE_2
1131 if (h) {
1132 _zend_hash_quick_add_or_update(&r->_cache.options, key, keylen, h, &opt, sizeof(zval *), NULL,
1133 zend_hash_quick_exists(&r->_cache.options, key, keylen, h)?HASH_UPDATE:HASH_ADD ZEND_FILE_LINE_CC);
1134 }
1135 else
1136 #endif
1137 {
1138 if (zend_hash_exists(&r->_cache.options, key, keylen)) {
1139 zend_hash_update(&r->_cache.options, key, keylen, &opt, sizeof(zval *), NULL);
1140 } else {
1141 zend_hash_add(&r->_cache.options, key, keylen, &opt, sizeof(zval *), NULL);
1142 }
1143 }
1144
1145 return opt;
1146 }
1147 /* }}} */
1148
1149 #endif /* HTTP_HAVE_CURL */
1150
1151 /*
1152 * Local variables:
1153 * tab-width: 4
1154 * c-basic-offset: 4
1155 * End:
1156 * vim600: noet sw=4 ts=4 fdm=marker
1157 * vim<600: noet sw=4 ts=4
1158 */
1159
Extended HTTP Support