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