Annotation of embedaddon/php/ext/curl/interface.c, revision 1.1.1.1
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
5: | Copyright (c) 1997-2012 The PHP Group |
6: +----------------------------------------------------------------------+
7: | This source file is subject to version 3.01 of the PHP license, |
8: | that is bundled with this package in the file LICENSE, and is |
9: | available through the world-wide-web at the following url: |
10: | http://www.php.net/license/3_01.txt |
11: | If you did not receive a copy of the PHP license and are unable to |
12: | obtain it through the world-wide-web, please send a note to |
13: | license@php.net so we can mail you a copy immediately. |
14: +----------------------------------------------------------------------+
15: | Author: Sterling Hughes <sterling@php.net> |
16: +----------------------------------------------------------------------+
17: */
18:
19: /* $Id: interface.c 321634 2012-01-01 13:15:04Z felipe $ */
20:
21: #define ZEND_INCLUDE_FULL_WINDOWS_HEADERS
22:
23: #ifdef HAVE_CONFIG_H
24: #include "config.h"
25: #endif
26:
27: #include "php.h"
28:
29: #if HAVE_CURL
30:
31: #include <stdio.h>
32: #include <string.h>
33:
34: #ifdef PHP_WIN32
35: #include <winsock2.h>
36: #include <sys/types.h>
37: #endif
38:
39: #include <curl/curl.h>
40: #include <curl/easy.h>
41:
42: /* As of curl 7.11.1 this is no longer defined inside curl.h */
43: #ifndef HttpPost
44: #define HttpPost curl_httppost
45: #endif
46:
47: /* {{{ cruft for thread safe SSL crypto locks */
48: #if defined(ZTS) && defined(HAVE_CURL_SSL)
49: # ifdef PHP_WIN32
50: # define PHP_CURL_NEED_OPENSSL_TSL
51: # include <openssl/crypto.h>
52: # else /* !PHP_WIN32 */
53: # if defined(HAVE_CURL_OPENSSL)
54: # if defined(HAVE_OPENSSL_CRYPTO_H)
55: # define PHP_CURL_NEED_OPENSSL_TSL
56: # include <openssl/crypto.h>
57: # else
58: # warning \
59: "libcurl was compiled with OpenSSL support, but configure could not find " \
60: "openssl/crypto.h; thus no SSL crypto locking callbacks will be set, which may " \
61: "cause random crashes on SSL requests"
62: # endif
63: # elif defined(HAVE_CURL_GNUTLS)
64: # if defined(HAVE_GCRYPT_H)
65: # define PHP_CURL_NEED_GNUTLS_TSL
66: # include <gcrypt.h>
67: # else
68: # warning \
69: "libcurl was compiled with GnuTLS support, but configure could not find " \
70: "gcrypt.h; thus no SSL crypto locking callbacks will be set, which may " \
71: "cause random crashes on SSL requests"
72: # endif
73: # else
74: # warning \
75: "libcurl was compiled with SSL support, but configure could not determine which" \
76: "library was used; thus no SSL crypto locking callbacks will be set, which may " \
77: "cause random crashes on SSL requests"
78: # endif /* HAVE_CURL_OPENSSL || HAVE_CURL_GNUTLS */
79: # endif /* PHP_WIN32 */
80: #endif /* ZTS && HAVE_CURL_SSL */
81: /* }}} */
82:
83: #define SMART_STR_PREALLOC 4096
84:
85: #include "ext/standard/php_smart_str.h"
86: #include "ext/standard/info.h"
87: #include "ext/standard/file.h"
88: #include "ext/standard/url.h"
89: #include "php_curl.h"
90:
91: int le_curl;
92: int le_curl_multi_handle;
93:
94: #ifdef PHP_CURL_NEED_OPENSSL_TSL /* {{{ */
95: static MUTEX_T *php_curl_openssl_tsl = NULL;
96:
97: static void php_curl_ssl_lock(int mode, int n, const char * file, int line)
98: {
99: if (mode & CRYPTO_LOCK) {
100: tsrm_mutex_lock(php_curl_openssl_tsl[n]);
101: } else {
102: tsrm_mutex_unlock(php_curl_openssl_tsl[n]);
103: }
104: }
105:
106: static unsigned long php_curl_ssl_id(void)
107: {
108: return (unsigned long) tsrm_thread_id();
109: }
110: #endif
111: /* }}} */
112:
113: #ifdef PHP_CURL_NEED_GNUTLS_TSL /* {{{ */
114: static int php_curl_ssl_mutex_create(void **m)
115: {
116: if (*((MUTEX_T *) m) = tsrm_mutex_alloc()) {
117: return SUCCESS;
118: } else {
119: return FAILURE;
120: }
121: }
122:
123: static int php_curl_ssl_mutex_destroy(void **m)
124: {
125: tsrm_mutex_free(*((MUTEX_T *) m));
126: return SUCCESS;
127: }
128:
129: static int php_curl_ssl_mutex_lock(void **m)
130: {
131: return tsrm_mutex_lock(*((MUTEX_T *) m));
132: }
133:
134: static int php_curl_ssl_mutex_unlock(void **m)
135: {
136: return tsrm_mutex_unlock(*((MUTEX_T *) m));
137: }
138:
139: static struct gcry_thread_cbs php_curl_gnutls_tsl = {
140: GCRY_THREAD_OPTION_USER,
141: NULL,
142: php_curl_ssl_mutex_create,
143: php_curl_ssl_mutex_destroy,
144: php_curl_ssl_mutex_lock,
145: php_curl_ssl_mutex_unlock
146: };
147: #endif
148: /* }}} */
149:
150: static void _php_curl_close_ex(php_curl *ch TSRMLS_DC);
151: static void _php_curl_close(zend_rsrc_list_entry *rsrc TSRMLS_DC);
152:
153:
154: #define SAVE_CURL_ERROR(__handle, __err) (__handle)->err.no = (int) __err;
155:
156: #define CAAL(s, v) add_assoc_long_ex(return_value, s, sizeof(s), (long) v);
157: #define CAAD(s, v) add_assoc_double_ex(return_value, s, sizeof(s), (double) v);
158: #define CAAS(s, v) add_assoc_string_ex(return_value, s, sizeof(s), (char *) (v ? v : ""), 1);
159: #define CAAZ(s, v) add_assoc_zval_ex(return_value, s, sizeof(s), (zval *) v);
160:
161: #if defined(PHP_WIN32) || defined(__GNUC__)
162: # define php_curl_ret(__ret) RETVAL_FALSE; return __ret;
163: #else
164: # define php_curl_ret(__ret) RETVAL_FALSE; return;
165: #endif
166:
167: static int php_curl_option_url(php_curl *ch, const char *url, const int len) /* {{{ */
168: {
169: CURLcode error = CURLE_OK;
170: #if LIBCURL_VERSION_NUM < 0x071100
171: char *copystr = NULL;
172: #endif
173: TSRMLS_FETCH();
174:
175: /* Disable file:// if open_basedir or safe_mode are used */
176: if ((PG(open_basedir) && *PG(open_basedir)) || PG(safe_mode)) {
177: #if LIBCURL_VERSION_NUM >= 0x071304
178: error = curl_easy_setopt(ch->cp, CURLOPT_PROTOCOLS, CURLPROTO_ALL & ~CURLPROTO_FILE);
179: #else
180: php_url *uri;
181:
182: if (!(uri = php_url_parse_ex(url, len))) {
183: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid URL '%s'", url);
184: return 0;
185: }
186:
187: if (uri->scheme && !strncasecmp("file", uri->scheme, sizeof("file"))) {
188: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Protocol 'file' disabled in cURL");
189: php_url_free(uri);
190: return 0;
191: }
192: php_url_free(uri);
193: #endif
194: }
195: /* Strings passed to libcurl as 'char *' arguments, are copied by the library... NOTE: before 7.17.0 strings were not copied. */
196: #if LIBCURL_VERSION_NUM >= 0x071100
197: error = curl_easy_setopt(ch->cp, CURLOPT_URL, url);
198: #else
199: copystr = estrndup(url, len);
200: error = curl_easy_setopt(ch->cp, CURLOPT_URL, copystr);
201: zend_llist_add_element(&ch->to_free->str, ©str);
202: #endif
203:
204: return (error == CURLE_OK ? 1 : 0);
205: }
206: /* }}} */
207:
208: int _php_curl_verify_handlers(php_curl *ch, int reporterror TSRMLS_DC) /* {{{ */
209: {
210: php_stream *stream;
211: if (!ch || !ch->handlers) {
212: return 0;
213: }
214:
215: if (ch->handlers->std_err) {
216: stream = (php_stream *) zend_fetch_resource(&ch->handlers->std_err TSRMLS_CC, -1, NULL, NULL, 2, php_file_le_stream(), php_file_le_pstream());
217: if (stream == NULL) {
218: if (reporterror) {
219: php_error_docref(NULL TSRMLS_CC, E_WARNING, "CURLOPT_STDERR resource has gone away, resetting to stderr");
220: }
221: zval_ptr_dtor(&ch->handlers->std_err);
222: ch->handlers->std_err = NULL;
223:
224: curl_easy_setopt(ch->cp, CURLOPT_STDERR, stderr);
225: }
226: }
227: if (ch->handlers->read && ch->handlers->read->stream) {
228: stream = (php_stream *) zend_fetch_resource(&ch->handlers->read->stream TSRMLS_CC, -1, NULL, NULL, 2, php_file_le_stream(), php_file_le_pstream());
229: if (stream == NULL) {
230: if (reporterror) {
231: php_error_docref(NULL TSRMLS_CC, E_WARNING, "CURLOPT_INFILE resource has gone away, resetting to default");
232: }
233: zval_ptr_dtor(&ch->handlers->read->stream);
234: ch->handlers->read->fd = 0;
235: ch->handlers->read->fp = 0;
236: ch->handlers->read->stream = NULL;
237:
238: curl_easy_setopt(ch->cp, CURLOPT_INFILE, (void *) ch);
239: }
240: }
241: if (ch->handlers->write_header && ch->handlers->write_header->stream) {
242: stream = (php_stream *) zend_fetch_resource(&ch->handlers->write_header->stream TSRMLS_CC, -1, NULL, NULL, 2, php_file_le_stream(), php_file_le_pstream());
243: if (stream == NULL) {
244: if (reporterror) {
245: php_error_docref(NULL TSRMLS_CC, E_WARNING, "CURLOPT_WRITEHEADER resource has gone away, resetting to default");
246: }
247: zval_ptr_dtor(&ch->handlers->write_header->stream);
248: ch->handlers->write_header->fp = 0;
249: ch->handlers->write_header->stream = NULL;
250:
251: ch->handlers->write_header->method = PHP_CURL_IGNORE;
252: curl_easy_setopt(ch->cp, CURLOPT_WRITEHEADER, (void *) ch);
253: }
254: }
255: if (ch->handlers->write && ch->handlers->write->stream) {
256: stream = (php_stream *) zend_fetch_resource(&ch->handlers->write->stream TSRMLS_CC, -1, NULL, NULL, 2, php_file_le_stream(), php_file_le_pstream());
257: if (stream == NULL) {
258: if (reporterror) {
259: php_error_docref(NULL TSRMLS_CC, E_WARNING, "CURLOPT_FILE resource has gone away, resetting to default");
260: }
261: zval_ptr_dtor(&ch->handlers->write->stream);
262: ch->handlers->write->fp = 0;
263: ch->handlers->write->stream = NULL;
264:
265: ch->handlers->write->method = PHP_CURL_STDOUT;
266: ch->handlers->write->type = PHP_CURL_ASCII;
267: curl_easy_setopt(ch->cp, CURLOPT_FILE, (void *) ch);
268: }
269: }
270: return 1;
271: }
272: /* }}} */
273:
274: /* {{{ arginfo */
275: ZEND_BEGIN_ARG_INFO_EX(arginfo_curl_version, 0, 0, 0)
276: ZEND_ARG_INFO(0, version)
277: ZEND_END_ARG_INFO()
278:
279: ZEND_BEGIN_ARG_INFO_EX(arginfo_curl_init, 0, 0, 0)
280: ZEND_ARG_INFO(0, url)
281: ZEND_END_ARG_INFO()
282:
283: ZEND_BEGIN_ARG_INFO(arginfo_curl_copy_handle, 0)
284: ZEND_ARG_INFO(0, ch)
285: ZEND_END_ARG_INFO()
286:
287: ZEND_BEGIN_ARG_INFO(arginfo_curl_setopt, 0)
288: ZEND_ARG_INFO(0, ch)
289: ZEND_ARG_INFO(0, option)
290: ZEND_ARG_INFO(0, value)
291: ZEND_END_ARG_INFO()
292:
293: ZEND_BEGIN_ARG_INFO(arginfo_curl_setopt_array, 0)
294: ZEND_ARG_INFO(0, ch)
295: ZEND_ARG_ARRAY_INFO(0, options, 0)
296: ZEND_END_ARG_INFO()
297:
298: ZEND_BEGIN_ARG_INFO(arginfo_curl_exec, 0)
299: ZEND_ARG_INFO(0, ch)
300: ZEND_END_ARG_INFO()
301:
302: ZEND_BEGIN_ARG_INFO_EX(arginfo_curl_getinfo, 0, 0, 1)
303: ZEND_ARG_INFO(0, ch)
304: ZEND_ARG_INFO(0, option)
305: ZEND_END_ARG_INFO()
306:
307: ZEND_BEGIN_ARG_INFO(arginfo_curl_error, 0)
308: ZEND_ARG_INFO(0, ch)
309: ZEND_END_ARG_INFO()
310:
311: ZEND_BEGIN_ARG_INFO(arginfo_curl_errno, 0)
312: ZEND_ARG_INFO(0, ch)
313: ZEND_END_ARG_INFO()
314:
315: ZEND_BEGIN_ARG_INFO(arginfo_curl_close, 0)
316: ZEND_ARG_INFO(0, ch)
317: ZEND_END_ARG_INFO()
318:
319: ZEND_BEGIN_ARG_INFO(arginfo_curl_multi_init, 0)
320: ZEND_END_ARG_INFO()
321:
322: ZEND_BEGIN_ARG_INFO(arginfo_curl_multi_add_handle, 0)
323: ZEND_ARG_INFO(0, mh)
324: ZEND_ARG_INFO(0, ch)
325: ZEND_END_ARG_INFO()
326:
327: ZEND_BEGIN_ARG_INFO(arginfo_curl_multi_remove_handle, 0)
328: ZEND_ARG_INFO(0, mh)
329: ZEND_ARG_INFO(0, ch)
330: ZEND_END_ARG_INFO()
331:
332: ZEND_BEGIN_ARG_INFO_EX(arginfo_curl_multi_select, 0, 0, 1)
333: ZEND_ARG_INFO(0, mh)
334: ZEND_ARG_INFO(0, timeout)
335: ZEND_END_ARG_INFO()
336:
337: ZEND_BEGIN_ARG_INFO_EX(arginfo_curl_multi_exec, 0, 0, 1)
338: ZEND_ARG_INFO(0, mh)
339: ZEND_ARG_INFO(1, still_running)
340: ZEND_END_ARG_INFO()
341:
342: ZEND_BEGIN_ARG_INFO(arginfo_curl_multi_getcontent, 0)
343: ZEND_ARG_INFO(0, ch)
344: ZEND_END_ARG_INFO()
345:
346: ZEND_BEGIN_ARG_INFO_EX(arginfo_curl_multi_info_read, 0, 0, 1)
347: ZEND_ARG_INFO(0, mh)
348: ZEND_ARG_INFO(1, msgs_in_queue)
349: ZEND_END_ARG_INFO()
350:
351: ZEND_BEGIN_ARG_INFO(arginfo_curl_multi_close, 0)
352: ZEND_ARG_INFO(0, mh)
353: ZEND_END_ARG_INFO()
354: /* }}} */
355:
356: /* {{{ curl_functions[]
357: */
358: const zend_function_entry curl_functions[] = {
359: PHP_FE(curl_init, arginfo_curl_init)
360: PHP_FE(curl_copy_handle, arginfo_curl_copy_handle)
361: PHP_FE(curl_version, arginfo_curl_version)
362: PHP_FE(curl_setopt, arginfo_curl_setopt)
363: PHP_FE(curl_setopt_array, arginfo_curl_setopt_array)
364: PHP_FE(curl_exec, arginfo_curl_exec)
365: PHP_FE(curl_getinfo, arginfo_curl_getinfo)
366: PHP_FE(curl_error, arginfo_curl_error)
367: PHP_FE(curl_errno, arginfo_curl_errno)
368: PHP_FE(curl_close, arginfo_curl_close)
369: PHP_FE(curl_multi_init, arginfo_curl_multi_init)
370: PHP_FE(curl_multi_add_handle, arginfo_curl_multi_add_handle)
371: PHP_FE(curl_multi_remove_handle, arginfo_curl_multi_remove_handle)
372: PHP_FE(curl_multi_select, arginfo_curl_multi_select)
373: PHP_FE(curl_multi_exec, arginfo_curl_multi_exec)
374: PHP_FE(curl_multi_getcontent, arginfo_curl_multi_getcontent)
375: PHP_FE(curl_multi_info_read, arginfo_curl_multi_info_read)
376: PHP_FE(curl_multi_close, arginfo_curl_multi_close)
377: PHP_FE_END
378: };
379: /* }}} */
380:
381: /* {{{ curl_module_entry
382: */
383: zend_module_entry curl_module_entry = {
384: STANDARD_MODULE_HEADER,
385: "curl",
386: curl_functions,
387: PHP_MINIT(curl),
388: PHP_MSHUTDOWN(curl),
389: NULL,
390: NULL,
391: PHP_MINFO(curl),
392: NO_VERSION_YET,
393: STANDARD_MODULE_PROPERTIES
394: };
395: /* }}} */
396:
397: #ifdef COMPILE_DL_CURL
398: ZEND_GET_MODULE (curl)
399: #endif
400:
401: /* {{{ PHP_INI_BEGIN */
402: PHP_INI_BEGIN()
403: PHP_INI_ENTRY("curl.cainfo", "", PHP_INI_SYSTEM, NULL)
404: PHP_INI_END()
405: /* }}} */
406:
407: /* {{{ PHP_MINFO_FUNCTION
408: */
409: PHP_MINFO_FUNCTION(curl)
410: {
411: curl_version_info_data *d;
412: char **p;
413: char str[1024];
414: size_t n = 0;
415:
416: d = curl_version_info(CURLVERSION_NOW);
417: php_info_print_table_start();
418: php_info_print_table_row(2, "cURL support", "enabled");
419: php_info_print_table_row(2, "cURL Information", d->version);
420: sprintf(str, "%d", d->age);
421: php_info_print_table_row(2, "Age", str);
422:
423: /* To update on each new cURL release using src/main.c in cURL sources */
424: if (d->features) {
425: struct feat {
426: const char *name;
427: int bitmask;
428: };
429:
430: unsigned int i;
431:
432: static const struct feat feats[] = {
433: #if LIBCURL_VERSION_NUM > 0x070a06 /* 7.10.7 */
434: {"AsynchDNS", CURL_VERSION_ASYNCHDNS},
435: #endif
436: #if LIBCURL_VERSION_NUM > 0x070a05 /* 7.10.6 */
437: {"Debug", CURL_VERSION_DEBUG},
438: {"GSS-Negotiate", CURL_VERSION_GSSNEGOTIATE},
439: #endif
440: #if LIBCURL_VERSION_NUM > 0x070b02 /* 7.12.0 */
441: {"IDN", CURL_VERSION_IDN},
442: #endif
443: #ifdef CURL_VERSION_IPV6
444: {"IPv6", CURL_VERSION_IPV6},
445: #endif
446: #if LIBCURL_VERSION_NUM > 0x070b00 /* 7.11.1 */
447: {"Largefile", CURL_VERSION_LARGEFILE},
448: #endif
449: #if LIBCURL_VERSION_NUM > 0x070a05 /* 7.10.6 */
450: {"NTLM", CURL_VERSION_NTLM},
451: #endif
452: #if LIBCURL_VERSION_NUM > 0x070a07 /* 7.10.8 */
453: {"SPNEGO", CURL_VERSION_SPNEGO},
454: #endif
455: #ifdef CURL_VERSION_SSL
456: {"SSL", CURL_VERSION_SSL},
457: #endif
458: #if LIBCURL_VERSION_NUM > 0x070d01 /* 7.13.2 */
459: {"SSPI", CURL_VERSION_SSPI},
460: #endif
461: #ifdef CURL_VERSION_KERBEROS4
462: {"krb4", CURL_VERSION_KERBEROS4},
463: #endif
464: #ifdef CURL_VERSION_LIBZ
465: {"libz", CURL_VERSION_LIBZ},
466: #endif
467: #if LIBCURL_VERSION_NUM > 0x070f03 /* 7.15.4 */
468: {"CharConv", CURL_VERSION_CONV},
469: #endif
470: {NULL, 0}
471: };
472:
473: php_info_print_table_row(1, "Features");
474: for(i=0; i<sizeof(feats)/sizeof(feats[0]); i++) {
475: if (feats[i].name) {
476: php_info_print_table_row(2, feats[i].name, d->features & feats[i].bitmask ? "Yes" : "No");
477: }
478: }
479: }
480:
481: n = 0;
482: p = (char **) d->protocols;
483: while (*p != NULL) {
484: n += sprintf(str + n, "%s%s", *p, *(p + 1) != NULL ? ", " : "");
485: p++;
486: }
487: php_info_print_table_row(2, "Protocols", str);
488:
489: php_info_print_table_row(2, "Host", d->host);
490:
491: if (d->ssl_version) {
492: php_info_print_table_row(2, "SSL Version", d->ssl_version);
493: }
494:
495: if (d->libz_version) {
496: php_info_print_table_row(2, "ZLib Version", d->libz_version);
497: }
498:
499: #if defined(CURLVERSION_SECOND) && CURLVERSION_NOW >= CURLVERSION_SECOND
500: if (d->ares) {
501: php_info_print_table_row(2, "ZLib Version", d->ares);
502: }
503: #endif
504:
505: #if defined(CURLVERSION_THIRD) && CURLVERSION_NOW >= CURLVERSION_THIRD
506: if (d->libidn) {
507: php_info_print_table_row(2, "libIDN Version", d->libidn);
508: }
509: #endif
510:
511: #if LIBCURL_VERSION_NUM >= 0x071300
512:
513: if (d->iconv_ver_num) {
514: php_info_print_table_row(2, "IconV Version", d->iconv_ver_num);
515: }
516:
517: if (d->libssh_version) {
518: php_info_print_table_row(2, "libSSH Version", d->libssh_version);
519: }
520: #endif
521: php_info_print_table_end();
522: }
523: /* }}} */
524:
525: #define REGISTER_CURL_CONSTANT(__c) REGISTER_LONG_CONSTANT(#__c, __c, CONST_CS | CONST_PERSISTENT)
526:
527: /* {{{ PHP_MINIT_FUNCTION
528: */
529: PHP_MINIT_FUNCTION(curl)
530: {
531: le_curl = zend_register_list_destructors_ex(_php_curl_close, NULL, "curl", module_number);
532: le_curl_multi_handle = zend_register_list_destructors_ex(_php_curl_multi_close, NULL, "curl_multi", module_number);
533:
534: REGISTER_INI_ENTRIES();
535:
536: /* See http://curl.haxx.se/lxr/source/docs/libcurl/symbols-in-versions
537: or curl src/docs/libcurl/symbols-in-versions for a (almost) complete list
538: of options and which version they were introduced */
539:
540: /* Constants for curl_setopt() */
541: #if LIBCURL_VERSION_NUM > 0x070a07 /* CURLOPT_IPRESOLVE is available since curl 7.10.8 */
542: REGISTER_CURL_CONSTANT(CURLOPT_IPRESOLVE);
543: REGISTER_CURL_CONSTANT(CURL_IPRESOLVE_WHATEVER);
544: REGISTER_CURL_CONSTANT(CURL_IPRESOLVE_V4);
545: REGISTER_CURL_CONSTANT(CURL_IPRESOLVE_V6);
546: #endif
547: REGISTER_CURL_CONSTANT(CURLOPT_DNS_USE_GLOBAL_CACHE);
548: REGISTER_CURL_CONSTANT(CURLOPT_DNS_CACHE_TIMEOUT);
549: REGISTER_CURL_CONSTANT(CURLOPT_PORT);
550: REGISTER_CURL_CONSTANT(CURLOPT_FILE);
551: REGISTER_CURL_CONSTANT(CURLOPT_READDATA);
552: REGISTER_CURL_CONSTANT(CURLOPT_INFILE);
553: REGISTER_CURL_CONSTANT(CURLOPT_INFILESIZE);
554: REGISTER_CURL_CONSTANT(CURLOPT_URL);
555: REGISTER_CURL_CONSTANT(CURLOPT_PROXY);
556: REGISTER_CURL_CONSTANT(CURLOPT_VERBOSE);
557: REGISTER_CURL_CONSTANT(CURLOPT_HEADER);
558: REGISTER_CURL_CONSTANT(CURLOPT_HTTPHEADER);
559: REGISTER_CURL_CONSTANT(CURLOPT_NOPROGRESS);
560: REGISTER_CURL_CONSTANT(CURLOPT_PROGRESSFUNCTION);
561: REGISTER_CURL_CONSTANT(CURLOPT_NOBODY);
562: REGISTER_CURL_CONSTANT(CURLOPT_FAILONERROR);
563: REGISTER_CURL_CONSTANT(CURLOPT_UPLOAD);
564: REGISTER_CURL_CONSTANT(CURLOPT_POST);
565: REGISTER_CURL_CONSTANT(CURLOPT_FTPLISTONLY);
566: REGISTER_CURL_CONSTANT(CURLOPT_FTPAPPEND);
567: REGISTER_CURL_CONSTANT(CURLOPT_NETRC);
568: REGISTER_CURL_CONSTANT(CURLOPT_FOLLOWLOCATION);
569: #if CURLOPT_FTPASCII != 0
570: REGISTER_CURL_CONSTANT(CURLOPT_FTPASCII);
571: #endif
572: REGISTER_CURL_CONSTANT(CURLOPT_PUT);
573: #if CURLOPT_MUTE != 0
574: REGISTER_CURL_CONSTANT(CURLOPT_MUTE);
575: #endif
576: REGISTER_CURL_CONSTANT(CURLOPT_USERPWD);
577: REGISTER_CURL_CONSTANT(CURLOPT_PROXYUSERPWD);
578: REGISTER_CURL_CONSTANT(CURLOPT_RANGE);
579: REGISTER_CURL_CONSTANT(CURLOPT_TIMEOUT);
580: #if LIBCURL_VERSION_NUM > 0x071002
581: REGISTER_CURL_CONSTANT(CURLOPT_TIMEOUT_MS);
582: #endif
583: REGISTER_CURL_CONSTANT(CURLOPT_POSTFIELDS);
584: REGISTER_CURL_CONSTANT(CURLOPT_REFERER);
585: REGISTER_CURL_CONSTANT(CURLOPT_USERAGENT);
586: REGISTER_CURL_CONSTANT(CURLOPT_FTPPORT);
587: REGISTER_CURL_CONSTANT(CURLOPT_FTP_USE_EPSV);
588: REGISTER_CURL_CONSTANT(CURLOPT_LOW_SPEED_LIMIT);
589: REGISTER_CURL_CONSTANT(CURLOPT_LOW_SPEED_TIME);
590: REGISTER_CURL_CONSTANT(CURLOPT_RESUME_FROM);
591: REGISTER_CURL_CONSTANT(CURLOPT_COOKIE);
592: REGISTER_CURL_CONSTANT(CURLOPT_COOKIESESSION);
593: REGISTER_CURL_CONSTANT(CURLOPT_AUTOREFERER);
594: REGISTER_CURL_CONSTANT(CURLOPT_SSLCERT);
595: REGISTER_CURL_CONSTANT(CURLOPT_SSLCERTPASSWD);
596: REGISTER_CURL_CONSTANT(CURLOPT_WRITEHEADER);
597: REGISTER_CURL_CONSTANT(CURLOPT_SSL_VERIFYHOST);
598: REGISTER_CURL_CONSTANT(CURLOPT_COOKIEFILE);
599: REGISTER_CURL_CONSTANT(CURLOPT_SSLVERSION);
600: REGISTER_CURL_CONSTANT(CURLOPT_TIMECONDITION);
601: REGISTER_CURL_CONSTANT(CURLOPT_TIMEVALUE);
602: REGISTER_CURL_CONSTANT(CURLOPT_CUSTOMREQUEST);
603: REGISTER_CURL_CONSTANT(CURLOPT_STDERR);
604: REGISTER_CURL_CONSTANT(CURLOPT_TRANSFERTEXT);
605: REGISTER_CURL_CONSTANT(CURLOPT_RETURNTRANSFER);
606: REGISTER_CURL_CONSTANT(CURLOPT_QUOTE);
607: REGISTER_CURL_CONSTANT(CURLOPT_POSTQUOTE);
608: REGISTER_CURL_CONSTANT(CURLOPT_INTERFACE);
609: REGISTER_CURL_CONSTANT(CURLOPT_KRB4LEVEL);
610: REGISTER_CURL_CONSTANT(CURLOPT_HTTPPROXYTUNNEL);
611: REGISTER_CURL_CONSTANT(CURLOPT_FILETIME);
612: REGISTER_CURL_CONSTANT(CURLOPT_WRITEFUNCTION);
613: REGISTER_CURL_CONSTANT(CURLOPT_READFUNCTION);
614: #if CURLOPT_PASSWDFUNCTION != 0
615: REGISTER_CURL_CONSTANT(CURLOPT_PASSWDFUNCTION);
616: #endif
617: REGISTER_CURL_CONSTANT(CURLOPT_HEADERFUNCTION);
618: REGISTER_CURL_CONSTANT(CURLOPT_MAXREDIRS);
619: REGISTER_CURL_CONSTANT(CURLOPT_MAXCONNECTS);
620: REGISTER_CURL_CONSTANT(CURLOPT_CLOSEPOLICY);
621: REGISTER_CURL_CONSTANT(CURLOPT_FRESH_CONNECT);
622: REGISTER_CURL_CONSTANT(CURLOPT_FORBID_REUSE);
623: REGISTER_CURL_CONSTANT(CURLOPT_RANDOM_FILE);
624: REGISTER_CURL_CONSTANT(CURLOPT_EGDSOCKET);
625: REGISTER_CURL_CONSTANT(CURLOPT_CONNECTTIMEOUT);
626: #if LIBCURL_VERSION_NUM > 0x071002
627: REGISTER_CURL_CONSTANT(CURLOPT_CONNECTTIMEOUT_MS);
628: #endif
629: REGISTER_CURL_CONSTANT(CURLOPT_SSL_VERIFYPEER);
630: REGISTER_CURL_CONSTANT(CURLOPT_CAINFO);
631: REGISTER_CURL_CONSTANT(CURLOPT_CAPATH);
632: REGISTER_CURL_CONSTANT(CURLOPT_COOKIEJAR);
633: REGISTER_CURL_CONSTANT(CURLOPT_SSL_CIPHER_LIST);
634: REGISTER_CURL_CONSTANT(CURLOPT_BINARYTRANSFER);
635: REGISTER_CURL_CONSTANT(CURLOPT_NOSIGNAL);
636: REGISTER_CURL_CONSTANT(CURLOPT_PROXYTYPE);
637: REGISTER_CURL_CONSTANT(CURLOPT_BUFFERSIZE);
638: REGISTER_CURL_CONSTANT(CURLOPT_HTTPGET);
639: REGISTER_CURL_CONSTANT(CURLOPT_HTTP_VERSION);
640: REGISTER_CURL_CONSTANT(CURLOPT_SSLKEY);
641: REGISTER_CURL_CONSTANT(CURLOPT_SSLKEYTYPE);
642: REGISTER_CURL_CONSTANT(CURLOPT_SSLKEYPASSWD);
643: REGISTER_CURL_CONSTANT(CURLOPT_SSLENGINE);
644: REGISTER_CURL_CONSTANT(CURLOPT_SSLENGINE_DEFAULT);
645: REGISTER_CURL_CONSTANT(CURLOPT_SSLCERTTYPE);
646: REGISTER_CURL_CONSTANT(CURLOPT_CRLF);
647: REGISTER_CURL_CONSTANT(CURLOPT_ENCODING);
648: REGISTER_CURL_CONSTANT(CURLOPT_PROXYPORT);
649: REGISTER_CURL_CONSTANT(CURLOPT_UNRESTRICTED_AUTH);
650: REGISTER_CURL_CONSTANT(CURLOPT_FTP_USE_EPRT);
651: #if LIBCURL_VERSION_NUM > 0x070b01 /* CURLOPT_TCP_NODELAY is available since curl 7.11.2 */
652: REGISTER_CURL_CONSTANT(CURLOPT_TCP_NODELAY);
653: #endif
654: REGISTER_CURL_CONSTANT(CURLOPT_HTTP200ALIASES);
655: REGISTER_CURL_CONSTANT(CURL_TIMECOND_IFMODSINCE);
656: REGISTER_CURL_CONSTANT(CURL_TIMECOND_IFUNMODSINCE);
657: REGISTER_CURL_CONSTANT(CURL_TIMECOND_LASTMOD);
658:
659: #if LIBCURL_VERSION_NUM > 0x070f04 /* CURLOPT_MAX_RECV_SPEED_LARGE & CURLOPT_MAX_SEND_SPEED_LARGE are available since curl 7.15.5 */
660: REGISTER_CURL_CONSTANT(CURLOPT_MAX_RECV_SPEED_LARGE);
661: REGISTER_CURL_CONSTANT(CURLOPT_MAX_SEND_SPEED_LARGE);
662: #endif
663:
664: #if LIBCURL_VERSION_NUM > 0x070a05 /* CURLOPT_HTTPAUTH is available since curl 7.10.6 */
665: REGISTER_CURL_CONSTANT(CURLOPT_HTTPAUTH);
666: /* http authentication options */
667: REGISTER_CURL_CONSTANT(CURLAUTH_BASIC);
668: REGISTER_CURL_CONSTANT(CURLAUTH_DIGEST);
669: REGISTER_CURL_CONSTANT(CURLAUTH_GSSNEGOTIATE);
670: REGISTER_CURL_CONSTANT(CURLAUTH_NTLM);
671: REGISTER_CURL_CONSTANT(CURLAUTH_ANY);
672: REGISTER_CURL_CONSTANT(CURLAUTH_ANYSAFE);
673: #endif
674:
675: #if LIBCURL_VERSION_NUM > 0x070a06 /* CURLOPT_PROXYAUTH & CURLOPT_FTP_CREATE_MISSING_DIRS are available since curl 7.10.7 */
676: REGISTER_CURL_CONSTANT(CURLOPT_PROXYAUTH);
677: REGISTER_CURL_CONSTANT(CURLOPT_FTP_CREATE_MISSING_DIRS);
678: #endif
679:
680: REGISTER_CURL_CONSTANT(CURLOPT_PRIVATE);
681:
682: /* Constants effecting the way CURLOPT_CLOSEPOLICY works */
683: REGISTER_CURL_CONSTANT(CURLCLOSEPOLICY_LEAST_RECENTLY_USED);
684: REGISTER_CURL_CONSTANT(CURLCLOSEPOLICY_LEAST_TRAFFIC);
685: REGISTER_CURL_CONSTANT(CURLCLOSEPOLICY_SLOWEST);
686: REGISTER_CURL_CONSTANT(CURLCLOSEPOLICY_CALLBACK);
687: REGISTER_CURL_CONSTANT(CURLCLOSEPOLICY_OLDEST);
688:
689: /* Info constants */
690: REGISTER_CURL_CONSTANT(CURLINFO_EFFECTIVE_URL);
691: REGISTER_CURL_CONSTANT(CURLINFO_HTTP_CODE);
692: REGISTER_CURL_CONSTANT(CURLINFO_HEADER_SIZE);
693: REGISTER_CURL_CONSTANT(CURLINFO_REQUEST_SIZE);
694: REGISTER_CURL_CONSTANT(CURLINFO_TOTAL_TIME);
695: REGISTER_CURL_CONSTANT(CURLINFO_NAMELOOKUP_TIME);
696: REGISTER_CURL_CONSTANT(CURLINFO_CONNECT_TIME);
697: REGISTER_CURL_CONSTANT(CURLINFO_PRETRANSFER_TIME);
698: REGISTER_CURL_CONSTANT(CURLINFO_SIZE_UPLOAD);
699: REGISTER_CURL_CONSTANT(CURLINFO_SIZE_DOWNLOAD);
700: REGISTER_CURL_CONSTANT(CURLINFO_SPEED_DOWNLOAD);
701: REGISTER_CURL_CONSTANT(CURLINFO_SPEED_UPLOAD);
702: REGISTER_CURL_CONSTANT(CURLINFO_FILETIME);
703: REGISTER_CURL_CONSTANT(CURLINFO_SSL_VERIFYRESULT);
704: REGISTER_CURL_CONSTANT(CURLINFO_CONTENT_LENGTH_DOWNLOAD);
705: REGISTER_CURL_CONSTANT(CURLINFO_CONTENT_LENGTH_UPLOAD);
706: REGISTER_CURL_CONSTANT(CURLINFO_STARTTRANSFER_TIME);
707: REGISTER_CURL_CONSTANT(CURLINFO_CONTENT_TYPE);
708: REGISTER_CURL_CONSTANT(CURLINFO_REDIRECT_TIME);
709: REGISTER_CURL_CONSTANT(CURLINFO_REDIRECT_COUNT);
710: REGISTER_CURL_CONSTANT(CURLINFO_HEADER_OUT);
711: REGISTER_CURL_CONSTANT(CURLINFO_PRIVATE);
712: #if LIBCURL_VERSION_NUM > 0x071301
713: REGISTER_CURL_CONSTANT(CURLINFO_CERTINFO);
714: #endif
715: #if LIBCURL_VERSION_NUM >= 0x071202
716: REGISTER_CURL_CONSTANT(CURLINFO_REDIRECT_URL);
717: #endif
718:
719:
720: /* cURL protocol constants (curl_version) */
721: REGISTER_CURL_CONSTANT(CURL_VERSION_IPV6);
722: REGISTER_CURL_CONSTANT(CURL_VERSION_KERBEROS4);
723: REGISTER_CURL_CONSTANT(CURL_VERSION_SSL);
724: REGISTER_CURL_CONSTANT(CURL_VERSION_LIBZ);
725:
726: /* version constants */
727: REGISTER_CURL_CONSTANT(CURLVERSION_NOW);
728:
729: /* Error Constants */
730: REGISTER_CURL_CONSTANT(CURLE_OK);
731: REGISTER_CURL_CONSTANT(CURLE_UNSUPPORTED_PROTOCOL);
732: REGISTER_CURL_CONSTANT(CURLE_FAILED_INIT);
733: REGISTER_CURL_CONSTANT(CURLE_URL_MALFORMAT);
734: REGISTER_CURL_CONSTANT(CURLE_URL_MALFORMAT_USER);
735: REGISTER_CURL_CONSTANT(CURLE_COULDNT_RESOLVE_PROXY);
736: REGISTER_CURL_CONSTANT(CURLE_COULDNT_RESOLVE_HOST);
737: REGISTER_CURL_CONSTANT(CURLE_COULDNT_CONNECT);
738: REGISTER_CURL_CONSTANT(CURLE_FTP_WEIRD_SERVER_REPLY);
739: REGISTER_CURL_CONSTANT(CURLE_FTP_ACCESS_DENIED);
740: REGISTER_CURL_CONSTANT(CURLE_FTP_USER_PASSWORD_INCORRECT);
741: REGISTER_CURL_CONSTANT(CURLE_FTP_WEIRD_PASS_REPLY);
742: REGISTER_CURL_CONSTANT(CURLE_FTP_WEIRD_USER_REPLY);
743: REGISTER_CURL_CONSTANT(CURLE_FTP_WEIRD_PASV_REPLY);
744: REGISTER_CURL_CONSTANT(CURLE_FTP_WEIRD_227_FORMAT);
745: REGISTER_CURL_CONSTANT(CURLE_FTP_CANT_GET_HOST);
746: REGISTER_CURL_CONSTANT(CURLE_FTP_CANT_RECONNECT);
747: REGISTER_CURL_CONSTANT(CURLE_FTP_COULDNT_SET_BINARY);
748: REGISTER_CURL_CONSTANT(CURLE_PARTIAL_FILE);
749: REGISTER_CURL_CONSTANT(CURLE_FTP_COULDNT_RETR_FILE);
750: REGISTER_CURL_CONSTANT(CURLE_FTP_WRITE_ERROR);
751: REGISTER_CURL_CONSTANT(CURLE_FTP_QUOTE_ERROR);
752: REGISTER_CURL_CONSTANT(CURLE_HTTP_NOT_FOUND);
753: REGISTER_CURL_CONSTANT(CURLE_WRITE_ERROR);
754: REGISTER_CURL_CONSTANT(CURLE_MALFORMAT_USER);
755: REGISTER_CURL_CONSTANT(CURLE_FTP_COULDNT_STOR_FILE);
756: REGISTER_CURL_CONSTANT(CURLE_READ_ERROR);
757: REGISTER_CURL_CONSTANT(CURLE_OUT_OF_MEMORY);
758: REGISTER_CURL_CONSTANT(CURLE_OPERATION_TIMEOUTED);
759: REGISTER_CURL_CONSTANT(CURLE_FTP_COULDNT_SET_ASCII);
760: REGISTER_CURL_CONSTANT(CURLE_FTP_PORT_FAILED);
761: REGISTER_CURL_CONSTANT(CURLE_FTP_COULDNT_USE_REST);
762: REGISTER_CURL_CONSTANT(CURLE_FTP_COULDNT_GET_SIZE);
763: REGISTER_CURL_CONSTANT(CURLE_HTTP_RANGE_ERROR);
764: REGISTER_CURL_CONSTANT(CURLE_HTTP_POST_ERROR);
765: REGISTER_CURL_CONSTANT(CURLE_SSL_CONNECT_ERROR);
766: REGISTER_CURL_CONSTANT(CURLE_FTP_BAD_DOWNLOAD_RESUME);
767: REGISTER_CURL_CONSTANT(CURLE_FILE_COULDNT_READ_FILE);
768: REGISTER_CURL_CONSTANT(CURLE_LDAP_CANNOT_BIND);
769: REGISTER_CURL_CONSTANT(CURLE_LDAP_SEARCH_FAILED);
770: REGISTER_CURL_CONSTANT(CURLE_LIBRARY_NOT_FOUND);
771: REGISTER_CURL_CONSTANT(CURLE_FUNCTION_NOT_FOUND);
772: REGISTER_CURL_CONSTANT(CURLE_ABORTED_BY_CALLBACK);
773: REGISTER_CURL_CONSTANT(CURLE_BAD_FUNCTION_ARGUMENT);
774: REGISTER_CURL_CONSTANT(CURLE_BAD_CALLING_ORDER);
775: REGISTER_CURL_CONSTANT(CURLE_HTTP_PORT_FAILED);
776: REGISTER_CURL_CONSTANT(CURLE_BAD_PASSWORD_ENTERED);
777: REGISTER_CURL_CONSTANT(CURLE_TOO_MANY_REDIRECTS);
778: REGISTER_CURL_CONSTANT(CURLE_UNKNOWN_TELNET_OPTION);
779: REGISTER_CURL_CONSTANT(CURLE_TELNET_OPTION_SYNTAX);
780: REGISTER_CURL_CONSTANT(CURLE_OBSOLETE);
781: REGISTER_CURL_CONSTANT(CURLE_SSL_PEER_CERTIFICATE);
782: REGISTER_CURL_CONSTANT(CURLE_GOT_NOTHING);
783: REGISTER_CURL_CONSTANT(CURLE_SSL_ENGINE_NOTFOUND);
784: REGISTER_CURL_CONSTANT(CURLE_SSL_ENGINE_SETFAILED);
785: REGISTER_CURL_CONSTANT(CURLE_SEND_ERROR);
786: REGISTER_CURL_CONSTANT(CURLE_RECV_ERROR);
787: REGISTER_CURL_CONSTANT(CURLE_SHARE_IN_USE);
788: REGISTER_CURL_CONSTANT(CURLE_SSL_CERTPROBLEM);
789: REGISTER_CURL_CONSTANT(CURLE_SSL_CIPHER);
790: REGISTER_CURL_CONSTANT(CURLE_SSL_CACERT);
791: REGISTER_CURL_CONSTANT(CURLE_BAD_CONTENT_ENCODING);
792: #if LIBCURL_VERSION_NUM >= 0x070a08
793: REGISTER_CURL_CONSTANT(CURLE_LDAP_INVALID_URL);
794: REGISTER_CURL_CONSTANT(CURLE_FILESIZE_EXCEEDED);
795: #endif
796: #if LIBCURL_VERSION_NUM >= 0x070b00
797: REGISTER_CURL_CONSTANT(CURLE_FTP_SSL_FAILED);
798: #endif
799: REGISTER_CURL_CONSTANT(CURLPROXY_HTTP);
800: REGISTER_CURL_CONSTANT(CURLPROXY_SOCKS4);
801: REGISTER_CURL_CONSTANT(CURLPROXY_SOCKS5);
802:
803: REGISTER_CURL_CONSTANT(CURL_NETRC_OPTIONAL);
804: REGISTER_CURL_CONSTANT(CURL_NETRC_IGNORED);
805: REGISTER_CURL_CONSTANT(CURL_NETRC_REQUIRED);
806:
807: REGISTER_CURL_CONSTANT(CURL_HTTP_VERSION_NONE);
808: REGISTER_CURL_CONSTANT(CURL_HTTP_VERSION_1_0);
809: REGISTER_CURL_CONSTANT(CURL_HTTP_VERSION_1_1);
810:
811: REGISTER_CURL_CONSTANT(CURLM_CALL_MULTI_PERFORM);
812: REGISTER_CURL_CONSTANT(CURLM_OK);
813: REGISTER_CURL_CONSTANT(CURLM_BAD_HANDLE);
814: REGISTER_CURL_CONSTANT(CURLM_BAD_EASY_HANDLE);
815: REGISTER_CURL_CONSTANT(CURLM_OUT_OF_MEMORY);
816: REGISTER_CURL_CONSTANT(CURLM_INTERNAL_ERROR);
817:
818: REGISTER_CURL_CONSTANT(CURLMSG_DONE);
819:
820: #if LIBCURL_VERSION_NUM >= 0x070c02
821: REGISTER_CURL_CONSTANT(CURLOPT_FTPSSLAUTH);
822: REGISTER_CURL_CONSTANT(CURLFTPAUTH_DEFAULT);
823: REGISTER_CURL_CONSTANT(CURLFTPAUTH_SSL);
824: REGISTER_CURL_CONSTANT(CURLFTPAUTH_TLS);
825: #endif
826:
827: #if LIBCURL_VERSION_NUM > 0x070b00
828: REGISTER_CURL_CONSTANT(CURLOPT_FTP_SSL);
829: REGISTER_CURL_CONSTANT(CURLFTPSSL_NONE);
830: REGISTER_CURL_CONSTANT(CURLFTPSSL_TRY);
831: REGISTER_CURL_CONSTANT(CURLFTPSSL_CONTROL);
832: REGISTER_CURL_CONSTANT(CURLFTPSSL_ALL);
833: #endif
834:
835: #if LIBCURL_VERSION_NUM > 0x071301
836: REGISTER_CURL_CONSTANT(CURLOPT_CERTINFO);
837: REGISTER_CURL_CONSTANT(CURLOPT_POSTREDIR);
838: #endif
839:
840: /* SSH support works in 7.19.0+ using libssh2 */
841: #if LIBCURL_VERSION_NUM >= 0x071300
842: REGISTER_CURL_CONSTANT(CURLSSH_AUTH_NONE);
843: REGISTER_CURL_CONSTANT(CURLSSH_AUTH_PUBLICKEY);
844: REGISTER_CURL_CONSTANT(CURLSSH_AUTH_PASSWORD);
845: REGISTER_CURL_CONSTANT(CURLSSH_AUTH_HOST);
846: REGISTER_CURL_CONSTANT(CURLSSH_AUTH_KEYBOARD);
847: REGISTER_CURL_CONSTANT(CURLSSH_AUTH_DEFAULT);
848: REGISTER_CURL_CONSTANT(CURLOPT_SSH_AUTH_TYPES);
849: REGISTER_CURL_CONSTANT(CURLOPT_KEYPASSWD);
850: REGISTER_CURL_CONSTANT(CURLOPT_SSH_PUBLIC_KEYFILE);
851: REGISTER_CURL_CONSTANT(CURLOPT_SSH_PRIVATE_KEYFILE);
852: REGISTER_CURL_CONSTANT(CURLOPT_SSH_HOST_PUBLIC_KEY_MD5);
853: REGISTER_CURL_CONSTANT(CURLE_SSH);
854: #endif
855:
856: #if LIBCURL_VERSION_NUM >= 0x071304
857: REGISTER_CURL_CONSTANT(CURLOPT_REDIR_PROTOCOLS);
858: REGISTER_CURL_CONSTANT(CURLOPT_PROTOCOLS);
859: REGISTER_CURL_CONSTANT(CURLPROTO_HTTP);
860: REGISTER_CURL_CONSTANT(CURLPROTO_HTTPS);
861: REGISTER_CURL_CONSTANT(CURLPROTO_FTP);
862: REGISTER_CURL_CONSTANT(CURLPROTO_FTPS);
863: REGISTER_CURL_CONSTANT(CURLPROTO_SCP);
864: REGISTER_CURL_CONSTANT(CURLPROTO_SFTP);
865: REGISTER_CURL_CONSTANT(CURLPROTO_TELNET);
866: REGISTER_CURL_CONSTANT(CURLPROTO_LDAP);
867: REGISTER_CURL_CONSTANT(CURLPROTO_LDAPS);
868: REGISTER_CURL_CONSTANT(CURLPROTO_DICT);
869: REGISTER_CURL_CONSTANT(CURLPROTO_FILE);
870: REGISTER_CURL_CONSTANT(CURLPROTO_TFTP);
871: REGISTER_CURL_CONSTANT(CURLPROTO_ALL);
872: #endif
873:
874: #if LIBCURL_VERSION_NUM >= 0x070f01
875: REGISTER_CURL_CONSTANT(CURLOPT_FTP_FILEMETHOD);
876: REGISTER_CURL_CONSTANT(CURLOPT_FTP_SKIP_PASV_IP);
877: #endif
878:
879: #if LIBCURL_VERSION_NUM >= 0x071001
880: REGISTER_CURL_CONSTANT(CURLFTPMETHOD_MULTICWD);
881: REGISTER_CURL_CONSTANT(CURLFTPMETHOD_NOCWD);
882: REGISTER_CURL_CONSTANT(CURLFTPMETHOD_SINGLECWD);
883: #endif
884:
885: #ifdef PHP_CURL_NEED_OPENSSL_TSL
886: if (!CRYPTO_get_id_callback()) {
887: int i, c = CRYPTO_num_locks();
888:
889: php_curl_openssl_tsl = malloc(c * sizeof(MUTEX_T));
890: if (!php_curl_openssl_tsl) {
891: return FAILURE;
892: }
893:
894: for (i = 0; i < c; ++i) {
895: php_curl_openssl_tsl[i] = tsrm_mutex_alloc();
896: }
897:
898: CRYPTO_set_id_callback(php_curl_ssl_id);
899: CRYPTO_set_locking_callback(php_curl_ssl_lock);
900: }
901: #endif
902: #ifdef PHP_CURL_NEED_GNUTLS_TSL
903: gcry_control(GCRYCTL_SET_THREAD_CBS, &php_curl_gnutls_tsl);
904: #endif
905:
906: if (curl_global_init(CURL_GLOBAL_SSL) != CURLE_OK) {
907: return FAILURE;
908: }
909:
910: #ifdef PHP_CURL_URL_WRAPPERS
911: # if HAVE_CURL_VERSION_INFO
912: {
913: curl_version_info_data *info = curl_version_info(CURLVERSION_NOW);
914: char **p = (char **)info->protocols;
915:
916: while (*p != NULL) {
917: /* Do not enable cURL "file" protocol and make sure cURL is always used when --with-curlwrappers is enabled */
918: if (strncasecmp(*p, "file", sizeof("file")-1) != 0) {
919: php_unregister_url_stream_wrapper(*p TSRMLS_CC);
920: php_register_url_stream_wrapper(*p, &php_curl_wrapper TSRMLS_CC);
921: }
922: (void) *p++;
923: }
924: }
925: # else
926: php_unregister_url_stream_wrapper("http");
927: php_register_url_stream_wrapper("http", &php_curl_wrapper TSRMLS_CC);
928: php_unregister_url_stream_wrapper("https");
929: php_register_url_stream_wrapper("https", &php_curl_wrapper TSRMLS_CC);
930: php_unregister_url_stream_wrapper("ftp");
931: php_register_url_stream_wrapper("ftp", &php_curl_wrapper TSRMLS_CC);
932: php_unregister_url_stream_wrapper("ftps");
933: php_register_url_stream_wrapper("ftps", &php_curl_wrapper TSRMLS_CC);
934: php_unregister_url_stream_wrapper("ldap");
935: php_register_url_stream_wrapper("ldap", &php_curl_wrapper TSRMLS_CC);
936: # endif
937: #endif
938:
939: return SUCCESS;
940: }
941: /* }}} */
942:
943: /* {{{ PHP_MSHUTDOWN_FUNCTION
944: */
945: PHP_MSHUTDOWN_FUNCTION(curl)
946: {
947: #ifdef PHP_CURL_URL_WRAPPERS
948: php_unregister_url_stream_wrapper("http" TSRMLS_CC);
949: php_unregister_url_stream_wrapper("https" TSRMLS_CC);
950: php_unregister_url_stream_wrapper("ftp" TSRMLS_CC);
951: php_unregister_url_stream_wrapper("ldap" TSRMLS_CC);
952: #endif
953: curl_global_cleanup();
954: #ifdef PHP_CURL_NEED_OPENSSL_TSL
955: if (php_curl_openssl_tsl) {
956: int i, c = CRYPTO_num_locks();
957:
958: CRYPTO_set_id_callback(NULL);
959: CRYPTO_set_locking_callback(NULL);
960:
961: for (i = 0; i < c; ++i) {
962: tsrm_mutex_free(php_curl_openssl_tsl[i]);
963: }
964:
965: free(php_curl_openssl_tsl);
966: php_curl_openssl_tsl = NULL;
967: }
968: #endif
969: UNREGISTER_INI_ENTRIES();
970: return SUCCESS;
971: }
972: /* }}} */
973:
974: /* {{{ curl_write
975: */
976: static size_t curl_write(char *data, size_t size, size_t nmemb, void *ctx)
977: {
978: php_curl *ch = (php_curl *) ctx;
979: php_curl_write *t = ch->handlers->write;
980: size_t length = size * nmemb;
981: TSRMLS_FETCH_FROM_CTX(ch->thread_ctx);
982:
983: #if PHP_CURL_DEBUG
984: fprintf(stderr, "curl_write() called\n");
985: fprintf(stderr, "data = %s, size = %d, nmemb = %d, ctx = %x\n", data, size, nmemb, ctx);
986: #endif
987:
988: switch (t->method) {
989: case PHP_CURL_STDOUT:
990: PHPWRITE(data, length);
991: break;
992: case PHP_CURL_FILE:
993: return fwrite(data, size, nmemb, t->fp);
994: case PHP_CURL_RETURN:
995: if (length > 0) {
996: smart_str_appendl(&t->buf, data, (int) length);
997: }
998: break;
999: case PHP_CURL_USER: {
1000: zval **argv[2];
1001: zval *retval_ptr = NULL;
1002: zval *handle = NULL;
1003: zval *zdata = NULL;
1004: int error;
1005: zend_fcall_info fci;
1006:
1007: MAKE_STD_ZVAL(handle);
1008: ZVAL_RESOURCE(handle, ch->id);
1009: zend_list_addref(ch->id);
1010: argv[0] = &handle;
1011:
1012: MAKE_STD_ZVAL(zdata);
1013: ZVAL_STRINGL(zdata, data, length, 1);
1014: argv[1] = &zdata;
1015:
1016: fci.size = sizeof(fci);
1017: fci.function_table = EG(function_table);
1018: fci.object_ptr = NULL;
1019: fci.function_name = t->func_name;
1020: fci.retval_ptr_ptr = &retval_ptr;
1021: fci.param_count = 2;
1022: fci.params = argv;
1023: fci.no_separation = 0;
1024: fci.symbol_table = NULL;
1025:
1026: ch->in_callback = 1;
1027: error = zend_call_function(&fci, &t->fci_cache TSRMLS_CC);
1028: ch->in_callback = 0;
1029: if (error == FAILURE) {
1030: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not call the CURLOPT_WRITEFUNCTION");
1031: length = -1;
1032: } else if (retval_ptr) {
1033: if (Z_TYPE_P(retval_ptr) != IS_LONG) {
1034: convert_to_long_ex(&retval_ptr);
1035: }
1036: length = Z_LVAL_P(retval_ptr);
1037: zval_ptr_dtor(&retval_ptr);
1038: }
1039:
1040: zval_ptr_dtor(argv[0]);
1041: zval_ptr_dtor(argv[1]);
1042: break;
1043: }
1044: }
1045:
1046: return length;
1047: }
1048: /* }}} */
1049:
1050: /* {{{ curl_progress
1051: */
1052: static size_t curl_progress(void *clientp, double dltotal, double dlnow, double ultotal, double ulnow)
1053: {
1054: php_curl *ch = (php_curl *) clientp;
1055: php_curl_progress *t = ch->handlers->progress;
1056: int length = -1;
1057: size_t rval = 0;
1058:
1059: #if PHP_CURL_DEBUG
1060: fprintf(stderr, "curl_progress() called\n");
1061: fprintf(stderr, "clientp = %x, dltotal = %f, dlnow = %f, ultotal = %f, ulnow = %f\n", clientp, dltotal, dlnow, ultotal, ulnow);
1062: #endif
1063:
1064: switch (t->method) {
1065: case PHP_CURL_USER: {
1066: zval **argv[4];
1067: zval *zdltotal = NULL;
1068: zval *zdlnow = NULL;
1069: zval *zultotal = NULL;
1070: zval *zulnow = NULL;
1071: zval *retval_ptr;
1072: int error;
1073: zend_fcall_info fci;
1074: TSRMLS_FETCH_FROM_CTX(ch->thread_ctx);
1075:
1076: MAKE_STD_ZVAL(zdltotal);
1077: MAKE_STD_ZVAL(zdlnow);
1078: MAKE_STD_ZVAL(zultotal);
1079: MAKE_STD_ZVAL(zulnow);
1080:
1081: ZVAL_LONG(zdltotal, (long) dltotal);
1082: ZVAL_LONG(zdlnow, (long) dlnow);
1083: ZVAL_LONG(zultotal, (long) ultotal);
1084: ZVAL_LONG(zulnow, (long) ulnow);
1085:
1086: argv[0] = &zdltotal;
1087: argv[1] = &zdlnow;
1088: argv[2] = &zultotal;
1089: argv[3] = &zulnow;
1090:
1091: fci.size = sizeof(fci);
1092: fci.function_table = EG(function_table);
1093: fci.function_name = t->func_name;
1094: fci.object_ptr = NULL;
1095: fci.retval_ptr_ptr = &retval_ptr;
1096: fci.param_count = 4;
1097: fci.params = argv;
1098: fci.no_separation = 0;
1099: fci.symbol_table = NULL;
1100:
1101: ch->in_callback = 1;
1102: error = zend_call_function(&fci, &t->fci_cache TSRMLS_CC);
1103: ch->in_callback = 0;
1104: if (error == FAILURE) {
1105: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot call the CURLOPT_PROGRESSFUNCTION");
1106: length = -1;
1107: } else if (retval_ptr) {
1108: if (Z_TYPE_P(retval_ptr) != IS_LONG) {
1109: convert_to_long_ex(&retval_ptr);
1110: }
1111: if (0 != Z_LVAL_P(retval_ptr)) {
1112: rval = 1;
1113: }
1114: zval_ptr_dtor(&retval_ptr);
1115: }
1116: zval_ptr_dtor(argv[0]);
1117: zval_ptr_dtor(argv[1]);
1118: zval_ptr_dtor(argv[2]);
1119: zval_ptr_dtor(argv[3]);
1120: break;
1121: }
1122: }
1123: return rval;
1124: }
1125: /* }}} */
1126:
1127: /* {{{ curl_read
1128: */
1129: static size_t curl_read(char *data, size_t size, size_t nmemb, void *ctx)
1130: {
1131: php_curl *ch = (php_curl *) ctx;
1132: php_curl_read *t = ch->handlers->read;
1133: int length = 0;
1134:
1135: switch (t->method) {
1136: case PHP_CURL_DIRECT:
1137: if (t->fp) {
1138: length = fread(data, size, nmemb, t->fp);
1139: }
1140: break;
1141: case PHP_CURL_USER: {
1142: zval **argv[3];
1143: zval *handle = NULL;
1144: zval *zfd = NULL;
1145: zval *zlength = NULL;
1146: zval *retval_ptr;
1147: int error;
1148: zend_fcall_info fci;
1149: TSRMLS_FETCH_FROM_CTX(ch->thread_ctx);
1150:
1151: MAKE_STD_ZVAL(handle);
1152: MAKE_STD_ZVAL(zfd);
1153: MAKE_STD_ZVAL(zlength);
1154:
1155: ZVAL_RESOURCE(handle, ch->id);
1156: zend_list_addref(ch->id);
1157: ZVAL_RESOURCE(zfd, t->fd);
1158: zend_list_addref(t->fd);
1159: ZVAL_LONG(zlength, (int) size * nmemb);
1160:
1161: argv[0] = &handle;
1162: argv[1] = &zfd;
1163: argv[2] = &zlength;
1164:
1165: fci.size = sizeof(fci);
1166: fci.function_table = EG(function_table);
1167: fci.function_name = t->func_name;
1168: fci.object_ptr = NULL;
1169: fci.retval_ptr_ptr = &retval_ptr;
1170: fci.param_count = 3;
1171: fci.params = argv;
1172: fci.no_separation = 0;
1173: fci.symbol_table = NULL;
1174:
1175: ch->in_callback = 1;
1176: error = zend_call_function(&fci, &t->fci_cache TSRMLS_CC);
1177: ch->in_callback = 0;
1178: if (error == FAILURE) {
1179: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot call the CURLOPT_READFUNCTION");
1180: #if LIBCURL_VERSION_NUM >= 0x070c01 /* 7.12.1 */
1181: length = CURL_READFUNC_ABORT;
1182: #endif
1183: } else if (retval_ptr) {
1184: if (Z_TYPE_P(retval_ptr) == IS_STRING) {
1185: length = MIN((int) (size * nmemb), Z_STRLEN_P(retval_ptr));
1186: memcpy(data, Z_STRVAL_P(retval_ptr), length);
1187: }
1188: zval_ptr_dtor(&retval_ptr);
1189: }
1190:
1191: zval_ptr_dtor(argv[0]);
1192: zval_ptr_dtor(argv[1]);
1193: zval_ptr_dtor(argv[2]);
1194: break;
1195: }
1196: }
1197:
1198: return length;
1199: }
1200: /* }}} */
1201:
1202: /* {{{ curl_write_header
1203: */
1204: static size_t curl_write_header(char *data, size_t size, size_t nmemb, void *ctx)
1205: {
1206: php_curl *ch = (php_curl *) ctx;
1207: php_curl_write *t = ch->handlers->write_header;
1208: size_t length = size * nmemb;
1209: TSRMLS_FETCH_FROM_CTX(ch->thread_ctx);
1210:
1211: switch (t->method) {
1212: case PHP_CURL_STDOUT:
1213: /* Handle special case write when we're returning the entire transfer
1214: */
1215: if (ch->handlers->write->method == PHP_CURL_RETURN && length > 0) {
1216: smart_str_appendl(&ch->handlers->write->buf, data, (int) length);
1217: } else {
1218: PHPWRITE(data, length);
1219: }
1220: break;
1221: case PHP_CURL_FILE:
1222: return fwrite(data, size, nmemb, t->fp);
1223: case PHP_CURL_USER: {
1224: zval **argv[2];
1225: zval *handle = NULL;
1226: zval *zdata = NULL;
1227: zval *retval_ptr;
1228: int error;
1229: zend_fcall_info fci;
1230:
1231: MAKE_STD_ZVAL(handle);
1232: MAKE_STD_ZVAL(zdata);
1233:
1234: ZVAL_RESOURCE(handle, ch->id);
1235: zend_list_addref(ch->id);
1236: ZVAL_STRINGL(zdata, data, length, 1);
1237:
1238: argv[0] = &handle;
1239: argv[1] = &zdata;
1240:
1241: fci.size = sizeof(fci);
1242: fci.function_table = EG(function_table);
1243: fci.function_name = t->func_name;
1244: fci.symbol_table = NULL;
1245: fci.object_ptr = NULL;
1246: fci.retval_ptr_ptr = &retval_ptr;
1247: fci.param_count = 2;
1248: fci.params = argv;
1249: fci.no_separation = 0;
1250:
1251: ch->in_callback = 1;
1252: error = zend_call_function(&fci, &t->fci_cache TSRMLS_CC);
1253: ch->in_callback = 0;
1254: if (error == FAILURE) {
1255: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not call the CURLOPT_HEADERFUNCTION");
1256: length = -1;
1257: } else if (retval_ptr) {
1258: if (Z_TYPE_P(retval_ptr) != IS_LONG) {
1259: convert_to_long_ex(&retval_ptr);
1260: }
1261: length = Z_LVAL_P(retval_ptr);
1262: zval_ptr_dtor(&retval_ptr);
1263: }
1264: zval_ptr_dtor(argv[0]);
1265: zval_ptr_dtor(argv[1]);
1266: break;
1267: }
1268:
1269: case PHP_CURL_IGNORE:
1270: return length;
1271:
1272: default:
1273: return -1;
1274: }
1275:
1276: return length;
1277: }
1278: /* }}} */
1279:
1280: static int curl_debug(CURL *cp, curl_infotype type, char *buf, size_t buf_len, void *ctx) /* {{{ */
1281: {
1282: php_curl *ch = (php_curl *) ctx;
1283:
1284: if (type == CURLINFO_HEADER_OUT) {
1285: if (ch->header.str_len) {
1286: efree(ch->header.str);
1287: }
1288: if (buf_len > 0) {
1289: ch->header.str = estrndup(buf, buf_len);
1290: ch->header.str_len = buf_len;
1291: }
1292: }
1293:
1294: return 0;
1295: }
1296: /* }}} */
1297:
1298: #if CURLOPT_PASSWDFUNCTION != 0
1299: /* {{{ curl_passwd
1300: */
1301: static size_t curl_passwd(void *ctx, char *prompt, char *buf, int buflen)
1302: {
1303: php_curl *ch = (php_curl *) ctx;
1304: zval *func = ch->handlers->passwd;
1305: zval *argv[3];
1306: zval *retval = NULL;
1307: int error;
1308: int ret = -1;
1309: TSRMLS_FETCH_FROM_CTX(ch->thread_ctx);
1310:
1311: MAKE_STD_ZVAL(argv[0]);
1312: MAKE_STD_ZVAL(argv[1]);
1313: MAKE_STD_ZVAL(argv[2]);
1314:
1315: ZVAL_RESOURCE(argv[0], ch->id);
1316: zend_list_addref(ch->id);
1317: ZVAL_STRING(argv[1], prompt, 1);
1318: ZVAL_LONG(argv[2], buflen);
1319:
1320: error = call_user_function(EG(function_table), NULL, func, retval, 2, argv TSRMLS_CC);
1321: if (error == FAILURE) {
1322: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not call the CURLOPT_PASSWDFUNCTION");
1323: } else if (Z_TYPE_P(retval) == IS_STRING) {
1324: if (Z_STRLEN_P(retval) > buflen) {
1325: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Returned password is too long for libcurl to handle");
1326: } else {
1327: strlcpy(buf, Z_STRVAL_P(retval), Z_STRLEN_P(retval));
1328: }
1329: } else {
1330: php_error_docref(NULL TSRMLS_CC, E_WARNING, "User handler '%s' did not return a string", Z_STRVAL_P(func));
1331: }
1332:
1333: zval_ptr_dtor(&argv[0]);
1334: zval_ptr_dtor(&argv[1]);
1335: zval_ptr_dtor(&argv[2]);
1336: zval_ptr_dtor(&retval);
1337:
1338: return ret;
1339: }
1340: /* }}} */
1341: #endif
1342:
1343: /* {{{ curl_free_string
1344: */
1345: static void curl_free_string(void **string)
1346: {
1347: efree(*string);
1348: }
1349: /* }}} */
1350:
1351: /* {{{ curl_free_post
1352: */
1353: static void curl_free_post(void **post)
1354: {
1355: curl_formfree((struct HttpPost *) *post);
1356: }
1357: /* }}} */
1358:
1359: /* {{{ curl_free_slist
1360: */
1361: static void curl_free_slist(void **slist)
1362: {
1363: curl_slist_free_all((struct curl_slist *) *slist);
1364: }
1365: /* }}} */
1366:
1367: /* {{{ proto array curl_version([int version])
1368: Return cURL version information. */
1369: PHP_FUNCTION(curl_version)
1370: {
1371: curl_version_info_data *d;
1372: long uversion = CURLVERSION_NOW;
1373:
1374: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &uversion) == FAILURE) {
1375: return;
1376: }
1377:
1378: d = curl_version_info(uversion);
1379: if (d == NULL) {
1380: RETURN_FALSE;
1381: }
1382:
1383: array_init(return_value);
1384:
1385: CAAL("version_number", d->version_num);
1386: CAAL("age", d->age);
1387: CAAL("features", d->features);
1388: CAAL("ssl_version_number", d->ssl_version_num);
1389: CAAS("version", d->version);
1390: CAAS("host", d->host);
1391: CAAS("ssl_version", d->ssl_version);
1392: CAAS("libz_version", d->libz_version);
1393: /* Add an array of protocols */
1394: {
1395: char **p = (char **) d->protocols;
1396: zval *protocol_list = NULL;
1397:
1398: MAKE_STD_ZVAL(protocol_list);
1399: array_init(protocol_list);
1400:
1401: while (*p != NULL) {
1402: add_next_index_string(protocol_list, *p, 1);
1403: p++;
1404: }
1405: CAAZ("protocols", protocol_list);
1406: }
1407: }
1408: /* }}} */
1409:
1410: /* {{{ alloc_curl_handle
1411: */
1412: static void alloc_curl_handle(php_curl **ch)
1413: {
1414: *ch = emalloc(sizeof(php_curl));
1415: (*ch)->to_free = ecalloc(1, sizeof(struct _php_curl_free));
1416: (*ch)->handlers = ecalloc(1, sizeof(php_curl_handlers));
1417: (*ch)->handlers->write = ecalloc(1, sizeof(php_curl_write));
1418: (*ch)->handlers->write_header = ecalloc(1, sizeof(php_curl_write));
1419: (*ch)->handlers->read = ecalloc(1, sizeof(php_curl_read));
1420: (*ch)->handlers->progress = ecalloc(1, sizeof(php_curl_progress));
1421:
1422: (*ch)->in_callback = 0;
1423: (*ch)->header.str_len = 0;
1424:
1425: memset(&(*ch)->err, 0, sizeof((*ch)->err));
1426: (*ch)->handlers->write->stream = NULL;
1427: (*ch)->handlers->write_header->stream = NULL;
1428: (*ch)->handlers->read->stream = NULL;
1429:
1430: zend_llist_init(&(*ch)->to_free->str, sizeof(char *), (llist_dtor_func_t) curl_free_string, 0);
1431: zend_llist_init(&(*ch)->to_free->slist, sizeof(struct curl_slist), (llist_dtor_func_t) curl_free_slist, 0);
1432: zend_llist_init(&(*ch)->to_free->post, sizeof(struct HttpPost), (llist_dtor_func_t) curl_free_post, 0);
1433: }
1434: /* }}} */
1435:
1436: #if LIBCURL_VERSION_NUM > 0x071301
1437: /* {{{ split_certinfo
1438: */
1439: static void split_certinfo(char *string, zval *hash)
1440: {
1441: char *org = estrdup(string);
1442: char *s = org;
1443: char *split;
1444:
1445: if(org) {
1446: do {
1447: char *key;
1448: char *val;
1449: char *tmp;
1450:
1451: split = strstr(s, "; ");
1452: if(split)
1453: *split = '\0';
1454:
1455: key = s;
1456: tmp = memchr(key, '=', 64);
1457: if(tmp) {
1458: *tmp = '\0';
1459: val = tmp+1;
1460: add_assoc_string(hash, key, val, 1);
1461: }
1462: s = split+2;
1463: } while(split);
1464: efree(org);
1465: }
1466: }
1467: /* }}} */
1468:
1469: /* {{{ create_certinfo
1470: */
1471: static void create_certinfo(struct curl_certinfo *ci, zval *listcode TSRMLS_DC)
1472: {
1473: int i;
1474:
1475: if(ci) {
1476: zval *certhash = NULL;
1477:
1478: for(i=0; i<ci->num_of_certs; i++) {
1479: struct curl_slist *slist;
1480:
1481: MAKE_STD_ZVAL(certhash);
1482: array_init(certhash);
1483: for(slist = ci->certinfo[i]; slist; slist = slist->next) {
1484: int len;
1485: char s[64];
1486: char *tmp;
1487: strncpy(s, slist->data, 64);
1488: tmp = memchr(s, ':', 64);
1489: if(tmp) {
1490: *tmp = '\0';
1491: len = strlen(s);
1492: if(!strcmp(s, "Subject") || !strcmp(s, "Issuer")) {
1493: zval *hash;
1494:
1495: MAKE_STD_ZVAL(hash);
1496: array_init(hash);
1497:
1498: split_certinfo(&slist->data[len+1], hash);
1499: add_assoc_zval(certhash, s, hash);
1500: } else {
1501: add_assoc_string(certhash, s, &slist->data[len+1], 1);
1502: }
1503: } else {
1504: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not extract hash key from certificate info");
1505: }
1506: }
1507: add_next_index_zval(listcode, certhash);
1508: }
1509: }
1510: }
1511: /* }}} */
1512: #endif
1513:
1514: /* {{{ proto resource curl_init([string url])
1515: Initialize a cURL session */
1516: PHP_FUNCTION(curl_init)
1517: {
1518: php_curl *ch;
1519: CURL *cp;
1520: zval *clone;
1521: char *url = NULL;
1522: int url_len = 0;
1523: char *cainfo;
1524:
1525: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &url, &url_len) == FAILURE) {
1526: return;
1527: }
1528:
1529: cp = curl_easy_init();
1530: if (!cp) {
1531: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not initialize a new cURL handle");
1532: RETURN_FALSE;
1533: }
1534:
1535: alloc_curl_handle(&ch);
1536: TSRMLS_SET_CTX(ch->thread_ctx);
1537:
1538: ch->cp = cp;
1539:
1540: ch->handlers->write->method = PHP_CURL_STDOUT;
1541: ch->handlers->write->type = PHP_CURL_ASCII;
1542: ch->handlers->read->method = PHP_CURL_DIRECT;
1543: ch->handlers->write_header->method = PHP_CURL_IGNORE;
1544:
1545: ch->uses = 0;
1546:
1547: MAKE_STD_ZVAL(clone);
1548: ch->clone = clone;
1549:
1550:
1551:
1552: curl_easy_setopt(ch->cp, CURLOPT_NOPROGRESS, 1);
1553: curl_easy_setopt(ch->cp, CURLOPT_VERBOSE, 0);
1554: curl_easy_setopt(ch->cp, CURLOPT_ERRORBUFFER, ch->err.str);
1555: curl_easy_setopt(ch->cp, CURLOPT_WRITEFUNCTION, curl_write);
1556: curl_easy_setopt(ch->cp, CURLOPT_FILE, (void *) ch);
1557: curl_easy_setopt(ch->cp, CURLOPT_READFUNCTION, curl_read);
1558: curl_easy_setopt(ch->cp, CURLOPT_INFILE, (void *) ch);
1559: curl_easy_setopt(ch->cp, CURLOPT_HEADERFUNCTION, curl_write_header);
1560: curl_easy_setopt(ch->cp, CURLOPT_WRITEHEADER, (void *) ch);
1561: curl_easy_setopt(ch->cp, CURLOPT_DNS_USE_GLOBAL_CACHE, 1);
1562: curl_easy_setopt(ch->cp, CURLOPT_DNS_CACHE_TIMEOUT, 120);
1563: curl_easy_setopt(ch->cp, CURLOPT_MAXREDIRS, 20); /* prevent infinite redirects */
1564:
1565: cainfo = INI_STR("curl.cainfo");
1566: if (cainfo && strlen(cainfo) > 0) {
1567: curl_easy_setopt(ch->cp, CURLOPT_CAINFO, cainfo);
1568: }
1569:
1570: #if defined(ZTS)
1571: curl_easy_setopt(ch->cp, CURLOPT_NOSIGNAL, 1);
1572: #endif
1573:
1574: if (url) {
1575: if (!php_curl_option_url(ch, url, url_len)) {
1576: _php_curl_close_ex(ch TSRMLS_CC);
1577: RETURN_FALSE;
1578: }
1579: }
1580:
1581: ZEND_REGISTER_RESOURCE(return_value, ch, le_curl);
1582: ch->id = Z_LVAL_P(return_value);
1583: }
1584: /* }}} */
1585:
1586: /* {{{ proto resource curl_copy_handle(resource ch)
1587: Copy a cURL handle along with all of it's preferences */
1588: PHP_FUNCTION(curl_copy_handle)
1589: {
1590: CURL *cp;
1591: zval *zid;
1592: php_curl *ch, *dupch;
1593:
1594: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zid) == FAILURE) {
1595: return;
1596: }
1597:
1598: ZEND_FETCH_RESOURCE(ch, php_curl *, &zid, -1, le_curl_name, le_curl);
1599:
1600: cp = curl_easy_duphandle(ch->cp);
1601: if (!cp) {
1602: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot duplicate cURL handle");
1603: RETURN_FALSE;
1604: }
1605:
1606: alloc_curl_handle(&dupch);
1607: TSRMLS_SET_CTX(dupch->thread_ctx);
1608:
1609: dupch->cp = cp;
1610: dupch->uses = 0;
1611: ch->uses++;
1612: if (ch->handlers->write->stream) {
1613: Z_ADDREF_P(dupch->handlers->write->stream);
1614: dupch->handlers->write->stream = ch->handlers->write->stream;
1615: }
1616: dupch->handlers->write->method = ch->handlers->write->method;
1617: dupch->handlers->write->type = ch->handlers->write->type;
1618: if (ch->handlers->read->stream) {
1619: Z_ADDREF_P(ch->handlers->read->stream);
1620: }
1621: dupch->handlers->read->stream = ch->handlers->read->stream;
1622: dupch->handlers->read->method = ch->handlers->read->method;
1623: dupch->handlers->write_header->method = ch->handlers->write_header->method;
1624: if (ch->handlers->write_header->stream) {
1625: Z_ADDREF_P(ch->handlers->write_header->stream);
1626: }
1627: dupch->handlers->write_header->stream = ch->handlers->write_header->stream;
1628:
1629: dupch->handlers->write->fp = ch->handlers->write->fp;
1630: dupch->handlers->write_header->fp = ch->handlers->write_header->fp;
1631: dupch->handlers->read->fp = ch->handlers->read->fp;
1632: dupch->handlers->read->fd = ch->handlers->read->fd;
1633: #if CURLOPT_PASSWDDATA != 0
1634: if (ch->handlers->passwd) {
1635: zval_add_ref(&ch->handlers->passwd);
1636: dupch->handlers->passwd = ch->handlers->passwd;
1637: curl_easy_setopt(ch->cp, CURLOPT_PASSWDDATA, (void *) dupch);
1638: }
1639: #endif
1640: if (ch->handlers->write->func_name) {
1641: zval_add_ref(&ch->handlers->write->func_name);
1642: dupch->handlers->write->func_name = ch->handlers->write->func_name;
1643: }
1644: if (ch->handlers->read->func_name) {
1645: zval_add_ref(&ch->handlers->read->func_name);
1646: dupch->handlers->read->func_name = ch->handlers->read->func_name;
1647: }
1648: if (ch->handlers->write_header->func_name) {
1649: zval_add_ref(&ch->handlers->write_header->func_name);
1650: dupch->handlers->write_header->func_name = ch->handlers->write_header->func_name;
1651: }
1652:
1653: if (ch->handlers->progress->func_name) {
1654: zval_add_ref(&ch->handlers->progress->func_name);
1655: dupch->handlers->progress->func_name = ch->handlers->progress->func_name;
1656: }
1657: dupch->handlers->progress->method = ch->handlers->progress->method;
1658:
1659: curl_easy_setopt(dupch->cp, CURLOPT_ERRORBUFFER, dupch->err.str);
1660: curl_easy_setopt(dupch->cp, CURLOPT_FILE, (void *) dupch);
1661: curl_easy_setopt(dupch->cp, CURLOPT_INFILE, (void *) dupch);
1662: curl_easy_setopt(dupch->cp, CURLOPT_WRITEHEADER, (void *) dupch);
1663: curl_easy_setopt(dupch->cp, CURLOPT_PROGRESSDATA, (void *) dupch);
1664:
1665: efree(dupch->to_free);
1666: dupch->to_free = ch->to_free;
1667:
1668: /* Keep track of cloned copies to avoid invoking curl destructors for every clone */
1669: Z_ADDREF_P(ch->clone);
1670: dupch->clone = ch->clone;
1671:
1672: ZEND_REGISTER_RESOURCE(return_value, dupch, le_curl);
1673: dupch->id = Z_LVAL_P(return_value);
1674: }
1675: /* }}} */
1676:
1677: static int _php_curl_setopt(php_curl *ch, long option, zval **zvalue, zval *return_value TSRMLS_DC) /* {{{ */
1678: {
1679: CURLcode error=CURLE_OK;
1680:
1681: switch (option) {
1682: case CURLOPT_INFILESIZE:
1683: case CURLOPT_VERBOSE:
1684: case CURLOPT_HEADER:
1685: case CURLOPT_NOPROGRESS:
1686: case CURLOPT_NOBODY:
1687: case CURLOPT_FAILONERROR:
1688: case CURLOPT_UPLOAD:
1689: case CURLOPT_POST:
1690: case CURLOPT_FTPLISTONLY:
1691: case CURLOPT_FTPAPPEND:
1692: case CURLOPT_NETRC:
1693: case CURLOPT_PUT:
1694: #if CURLOPT_MUTE != 0
1695: case CURLOPT_MUTE:
1696: #endif
1697: case CURLOPT_TIMEOUT:
1698: #if LIBCURL_VERSION_NUM > 0x071002
1699: case CURLOPT_TIMEOUT_MS:
1700: #endif
1701: case CURLOPT_FTP_USE_EPSV:
1702: case CURLOPT_LOW_SPEED_LIMIT:
1703: case CURLOPT_SSLVERSION:
1704: case CURLOPT_LOW_SPEED_TIME:
1705: case CURLOPT_RESUME_FROM:
1706: case CURLOPT_TIMEVALUE:
1707: case CURLOPT_TIMECONDITION:
1708: case CURLOPT_TRANSFERTEXT:
1709: case CURLOPT_HTTPPROXYTUNNEL:
1710: case CURLOPT_FILETIME:
1711: case CURLOPT_MAXREDIRS:
1712: case CURLOPT_MAXCONNECTS:
1713: case CURLOPT_CLOSEPOLICY:
1714: case CURLOPT_FRESH_CONNECT:
1715: case CURLOPT_FORBID_REUSE:
1716: case CURLOPT_CONNECTTIMEOUT:
1717: #if LIBCURL_VERSION_NUM > 0x071002
1718: case CURLOPT_CONNECTTIMEOUT_MS:
1719: #endif
1720: case CURLOPT_SSL_VERIFYHOST:
1721: case CURLOPT_SSL_VERIFYPEER:
1722: case CURLOPT_DNS_USE_GLOBAL_CACHE:
1723: case CURLOPT_NOSIGNAL:
1724: case CURLOPT_PROXYTYPE:
1725: case CURLOPT_BUFFERSIZE:
1726: case CURLOPT_HTTPGET:
1727: case CURLOPT_HTTP_VERSION:
1728: case CURLOPT_CRLF:
1729: case CURLOPT_DNS_CACHE_TIMEOUT:
1730: case CURLOPT_PROXYPORT:
1731: case CURLOPT_FTP_USE_EPRT:
1732: #if LIBCURL_VERSION_NUM > 0x070a05 /* CURLOPT_HTTPAUTH is available since curl 7.10.6 */
1733: case CURLOPT_HTTPAUTH:
1734: #endif
1735: #if LIBCURL_VERSION_NUM > 0x070a06 /* CURLOPT_PROXYAUTH & CURLOPT_FTP_CREATE_MISSING_DIRS are available since curl 7.10.7 */
1736: case CURLOPT_PROXYAUTH:
1737: case CURLOPT_FTP_CREATE_MISSING_DIRS:
1738: #endif
1739:
1740: #if LIBCURL_VERSION_NUM >= 0x070c02
1741: case CURLOPT_FTPSSLAUTH:
1742: #endif
1743: #if LIBCURL_VERSION_NUM > 0x070b00
1744: case CURLOPT_FTP_SSL:
1745: #endif
1746: case CURLOPT_UNRESTRICTED_AUTH:
1747: case CURLOPT_PORT:
1748: case CURLOPT_AUTOREFERER:
1749: case CURLOPT_COOKIESESSION:
1750: #if LIBCURL_VERSION_NUM > 0x070b01 /* CURLOPT_TCP_NODELAY is available since curl 7.11.2 */
1751: case CURLOPT_TCP_NODELAY:
1752: #endif
1753: #if LIBCURL_VERSION_NUM >= 0x71304
1754: case CURLOPT_REDIR_PROTOCOLS:
1755: case CURLOPT_PROTOCOLS:
1756: #endif
1757: #if LIBCURL_VERSION_NUM > 0x070a07 /* CURLOPT_IPRESOLVE is available since curl 7.10.8 */
1758: case CURLOPT_IPRESOLVE:
1759: #endif
1760: #if LIBCURL_VERSION_NUM >= 0x070f01
1761: case CURLOPT_FTP_FILEMETHOD:
1762: case CURLOPT_FTP_SKIP_PASV_IP:
1763: #endif
1764: #if LIBCURL_VERSION_NUM > 0x071301
1765: case CURLOPT_CERTINFO:
1766: #endif
1767: convert_to_long_ex(zvalue);
1768: #if LIBCURL_VERSION_NUM >= 0x71304
1769: if ((option == CURLOPT_PROTOCOLS || option == CURLOPT_REDIR_PROTOCOLS) &&
1770: ((PG(open_basedir) && *PG(open_basedir)) || PG(safe_mode)) && (Z_LVAL_PP(zvalue) & CURLPROTO_FILE)) {
1771: php_error_docref(NULL TSRMLS_CC, E_WARNING, "CURLPROTO_FILE cannot be activated when in safe_mode or an open_basedir is set");
1772: RETVAL_FALSE;
1773: return 1;
1774: }
1775: #endif
1776: error = curl_easy_setopt(ch->cp, option, Z_LVAL_PP(zvalue));
1777: break;
1778: #if LIBCURL_VERSION_NUM > 0x070f04
1779: case CURLOPT_MAX_RECV_SPEED_LARGE:
1780: case CURLOPT_MAX_SEND_SPEED_LARGE:
1781: convert_to_long_ex(zvalue);
1782: error = curl_easy_setopt(ch->cp, option, (curl_off_t)Z_LVAL_PP(zvalue));
1783: break;
1784: #endif
1785: case CURLOPT_FOLLOWLOCATION:
1786: convert_to_long_ex(zvalue);
1787: if ((PG(open_basedir) && *PG(open_basedir)) || PG(safe_mode)) {
1788: if (Z_LVAL_PP(zvalue) != 0) {
1789: php_error_docref(NULL TSRMLS_CC, E_WARNING, "CURLOPT_FOLLOWLOCATION cannot be activated when safe_mode is enabled or an open_basedir is set");
1790: RETVAL_FALSE;
1791: return 1;
1792: }
1793: }
1794: error = curl_easy_setopt(ch->cp, option, Z_LVAL_PP(zvalue));
1795: break;
1796: #if LIBCURL_VERSION_NUM > 0x071301
1797: case CURLOPT_POSTREDIR:
1798: convert_to_long_ex(zvalue);
1799: error = curl_easy_setopt(ch->cp, CURLOPT_POSTREDIR, Z_LVAL_PP(zvalue) & CURL_REDIR_POST_ALL);
1800: break;
1801: #endif
1802: case CURLOPT_PRIVATE:
1803: case CURLOPT_URL:
1804: case CURLOPT_PROXY:
1805: case CURLOPT_USERPWD:
1806: case CURLOPT_PROXYUSERPWD:
1807: case CURLOPT_RANGE:
1808: case CURLOPT_CUSTOMREQUEST:
1809: case CURLOPT_USERAGENT:
1810: case CURLOPT_FTPPORT:
1811: case CURLOPT_COOKIE:
1812: case CURLOPT_REFERER:
1813: case CURLOPT_INTERFACE:
1814: case CURLOPT_KRB4LEVEL:
1815: case CURLOPT_EGDSOCKET:
1816: case CURLOPT_CAINFO:
1817: case CURLOPT_CAPATH:
1818: case CURLOPT_SSL_CIPHER_LIST:
1819: case CURLOPT_SSLKEY:
1820: case CURLOPT_SSLKEYTYPE:
1821: case CURLOPT_SSLKEYPASSWD:
1822: case CURLOPT_SSLENGINE:
1823: case CURLOPT_SSLENGINE_DEFAULT:
1824: case CURLOPT_SSLCERTTYPE:
1825: case CURLOPT_ENCODING:
1826: #if LIBCURL_VERSION_NUM >= 0x071300
1827: case CURLOPT_SSH_PUBLIC_KEYFILE:
1828: case CURLOPT_SSH_PRIVATE_KEYFILE:
1829: #endif
1830: {
1831: #if LIBCURL_VERSION_NUM < 0x071100
1832: char *copystr = NULL;
1833: #endif
1834:
1835: convert_to_string_ex(zvalue);
1836: #if LIBCURL_VERSION_NUM >= 0x071300
1837: if (
1838: option == CURLOPT_SSH_PUBLIC_KEYFILE || option == CURLOPT_SSH_PRIVATE_KEYFILE
1839:
1840: ) {
1841: if (php_check_open_basedir(Z_STRVAL_PP(zvalue) TSRMLS_CC) || (PG(safe_mode) && !php_checkuid(Z_STRVAL_PP(zvalue), "rb+", CHECKUID_CHECK_MODE_PARAM))) {
1842: RETVAL_FALSE;
1843: return 1;
1844: }
1845: }
1846: #endif
1847: if (option == CURLOPT_URL) {
1848: if (!php_curl_option_url(ch, Z_STRVAL_PP(zvalue), Z_STRLEN_PP(zvalue))) {
1849: RETVAL_FALSE;
1850: return 1;
1851: }
1852: } else {
1853: if (option == CURLOPT_PRIVATE) {
1854: char *copystr;
1855: #if LIBCURL_VERSION_NUM < 0x071100
1856: string_copy:
1857: #endif
1858: copystr = estrndup(Z_STRVAL_PP(zvalue), Z_STRLEN_PP(zvalue));
1859: error = curl_easy_setopt(ch->cp, option, copystr);
1860: zend_llist_add_element(&ch->to_free->str, ©str);
1861: } else {
1862: #if LIBCURL_VERSION_NUM >= 0x071100
1863: /* Strings passed to libcurl as ’char *’ arguments, are copied by the library... NOTE: before 7.17.0 strings were not copied. */
1864: error = curl_easy_setopt(ch->cp, option, Z_STRVAL_PP(zvalue));
1865: #else
1866: goto string_copy;
1867: #endif
1868: }
1869: }
1870: break;
1871: }
1872: case CURLOPT_FILE:
1873: case CURLOPT_INFILE:
1874: case CURLOPT_WRITEHEADER:
1875: case CURLOPT_STDERR: {
1876: FILE *fp = NULL;
1877: int type;
1878: void * what;
1879:
1880: what = zend_fetch_resource(zvalue TSRMLS_CC, -1, "File-Handle", &type, 1, php_file_le_stream(), php_file_le_pstream());
1881: if (!what) {
1882: RETVAL_FALSE;
1883: return 1;
1884: }
1885:
1886: if (FAILURE == php_stream_cast((php_stream *) what, PHP_STREAM_AS_STDIO, (void *) &fp, REPORT_ERRORS)) {
1887: RETVAL_FALSE;
1888: return 1;
1889: }
1890:
1891: if (!fp) {
1892: RETVAL_FALSE;
1893: return 1;
1894: }
1895:
1896: error = CURLE_OK;
1897: switch (option) {
1898: case CURLOPT_FILE:
1899: if (((php_stream *) what)->mode[0] != 'r' || ((php_stream *) what)->mode[1] == '+') {
1900: if (ch->handlers->write->stream) {
1901: Z_DELREF_P(ch->handlers->write->stream);
1902: }
1903: Z_ADDREF_PP(zvalue);
1904: ch->handlers->write->fp = fp;
1905: ch->handlers->write->method = PHP_CURL_FILE;
1906: ch->handlers->write->stream = *zvalue;
1907: } else {
1908: php_error_docref(NULL TSRMLS_CC, E_WARNING, "the provided file handle is not writable");
1909: RETVAL_FALSE;
1910: return 1;
1911: }
1912: break;
1913: case CURLOPT_WRITEHEADER:
1914: if (((php_stream *) what)->mode[0] != 'r' || ((php_stream *) what)->mode[1] == '+') {
1915: if (ch->handlers->write_header->stream) {
1916: Z_DELREF_P(ch->handlers->write_header->stream);
1917: }
1918: Z_ADDREF_PP(zvalue);
1919: ch->handlers->write_header->fp = fp;
1920: ch->handlers->write_header->method = PHP_CURL_FILE;
1921: ch->handlers->write_header->stream = *zvalue;
1922: } else {
1923: php_error_docref(NULL TSRMLS_CC, E_WARNING, "the provided file handle is not writable");
1924: RETVAL_FALSE;
1925: return 1;
1926: }
1927: break;
1928: case CURLOPT_INFILE:
1929: if (ch->handlers->read->stream) {
1930: Z_DELREF_P(ch->handlers->read->stream);
1931: }
1932: Z_ADDREF_PP(zvalue);
1933: ch->handlers->read->fp = fp;
1934: ch->handlers->read->fd = Z_LVAL_PP(zvalue);
1935: ch->handlers->read->stream = *zvalue;
1936: break;
1937: case CURLOPT_STDERR:
1938: if (((php_stream *) what)->mode[0] != 'r' || ((php_stream *) what)->mode[1] == '+') {
1939: if (ch->handlers->std_err) {
1940: zval_ptr_dtor(&ch->handlers->std_err);
1941: }
1942: zval_add_ref(zvalue);
1943: ch->handlers->std_err = *zvalue;
1944: } else {
1945: php_error_docref(NULL TSRMLS_CC, E_WARNING, "the provided file handle is not writable");
1946: RETVAL_FALSE;
1947: return 1;
1948: }
1949: /* break omitted intentionally */
1950: default:
1951: error = curl_easy_setopt(ch->cp, option, fp);
1952: break;
1953: }
1954:
1955: break;
1956: }
1957: case CURLOPT_RETURNTRANSFER:
1958: convert_to_long_ex(zvalue);
1959:
1960: if (Z_LVAL_PP(zvalue)) {
1961: ch->handlers->write->method = PHP_CURL_RETURN;
1962: } else {
1963: ch->handlers->write->method = PHP_CURL_STDOUT;
1964: }
1965: break;
1966: case CURLOPT_BINARYTRANSFER:
1967: convert_to_long_ex(zvalue);
1968:
1969: if (Z_LVAL_PP(zvalue)) {
1970: ch->handlers->write->type = PHP_CURL_BINARY;
1971: } else {
1972: ch->handlers->write->type = PHP_CURL_ASCII;
1973: }
1974: break;
1975: case CURLOPT_WRITEFUNCTION:
1976: if (ch->handlers->write->func_name) {
1977: zval_ptr_dtor(&ch->handlers->write->func_name);
1978: ch->handlers->write->fci_cache = empty_fcall_info_cache;
1979: }
1980: zval_add_ref(zvalue);
1981: ch->handlers->write->func_name = *zvalue;
1982: ch->handlers->write->method = PHP_CURL_USER;
1983: break;
1984: case CURLOPT_READFUNCTION:
1985: if (ch->handlers->read->func_name) {
1986: zval_ptr_dtor(&ch->handlers->read->func_name);
1987: ch->handlers->read->fci_cache = empty_fcall_info_cache;
1988: }
1989: zval_add_ref(zvalue);
1990: ch->handlers->read->func_name = *zvalue;
1991: ch->handlers->read->method = PHP_CURL_USER;
1992: break;
1993: case CURLOPT_PROGRESSFUNCTION:
1994: curl_easy_setopt(ch->cp, CURLOPT_PROGRESSFUNCTION, curl_progress);
1995: curl_easy_setopt(ch->cp, CURLOPT_PROGRESSDATA, ch);
1996: if (ch->handlers->progress->func_name) {
1997: zval_ptr_dtor(&ch->handlers->progress->func_name);
1998: ch->handlers->progress->fci_cache = empty_fcall_info_cache;
1999: }
2000: zval_add_ref(zvalue);
2001: ch->handlers->progress->func_name = *zvalue;
2002: ch->handlers->progress->method = PHP_CURL_USER;
2003: break;
2004: case CURLOPT_HEADERFUNCTION:
2005: if (ch->handlers->write_header->func_name) {
2006: zval_ptr_dtor(&ch->handlers->write_header->func_name);
2007: ch->handlers->write_header->fci_cache = empty_fcall_info_cache;
2008: }
2009: zval_add_ref(zvalue);
2010: ch->handlers->write_header->func_name = *zvalue;
2011: ch->handlers->write_header->method = PHP_CURL_USER;
2012: break;
2013: #if CURLOPT_PASSWDFUNCTION != 0
2014: case CURLOPT_PASSWDFUNCTION:
2015: if (ch->handlers->passwd) {
2016: zval_ptr_dtor(&ch->handlers->passwd);
2017: }
2018: zval_add_ref(zvalue);
2019: ch->handlers->passwd = *zvalue;
2020: error = curl_easy_setopt(ch->cp, CURLOPT_PASSWDFUNCTION, curl_passwd);
2021: error = curl_easy_setopt(ch->cp, CURLOPT_PASSWDDATA, (void *) ch);
2022: break;
2023: #endif
2024: case CURLOPT_POSTFIELDS:
2025: if (Z_TYPE_PP(zvalue) == IS_ARRAY || Z_TYPE_PP(zvalue) == IS_OBJECT) {
2026: zval **current;
2027: HashTable *postfields;
2028: struct HttpPost *first = NULL;
2029: struct HttpPost *last = NULL;
2030: char *postval;
2031: char *string_key = NULL;
2032: ulong num_key;
2033: uint string_key_len;
2034:
2035: postfields = HASH_OF(*zvalue);
2036: if (!postfields) {
2037: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Couldn't get HashTable in CURLOPT_POSTFIELDS");
2038: RETVAL_FALSE;
2039: return 1;
2040: }
2041:
2042: for (zend_hash_internal_pointer_reset(postfields);
2043: zend_hash_get_current_data(postfields, (void **) ¤t) == SUCCESS;
2044: zend_hash_move_forward(postfields)
2045: ) {
2046:
2047: SEPARATE_ZVAL(current);
2048: convert_to_string_ex(current);
2049:
2050: zend_hash_get_current_key_ex(postfields, &string_key, &string_key_len, &num_key, 0, NULL);
2051:
2052: postval = Z_STRVAL_PP(current);
2053:
2054: /* The arguments after _NAMELENGTH and _CONTENTSLENGTH
2055: * must be explicitly cast to long in curl_formadd
2056: * use since curl needs a long not an int. */
2057: if (*postval == '@') {
2058: char *type, *filename;
2059: ++postval;
2060:
2061: if ((type = php_memnstr(postval, ";type=", sizeof(";type=") - 1, postval + Z_STRLEN_PP(current)))) {
2062: *type = '\0';
2063: }
2064: if ((filename = php_memnstr(postval, ";filename=", sizeof(";filename=") - 1, postval + Z_STRLEN_PP(current)))) {
2065: *filename = '\0';
2066: }
2067: /* safe_mode / open_basedir check */
2068: if (php_check_open_basedir(postval TSRMLS_CC) || (PG(safe_mode) && !php_checkuid(postval, "rb+", CHECKUID_CHECK_MODE_PARAM))) {
2069: RETVAL_FALSE;
2070: return 1;
2071: }
2072: error = curl_formadd(&first, &last,
2073: CURLFORM_COPYNAME, string_key,
2074: CURLFORM_NAMELENGTH, (long)string_key_len - 1,
2075: CURLFORM_FILENAME, filename ? filename + sizeof(";filename=") - 1 : postval,
2076: CURLFORM_CONTENTTYPE, type ? type + sizeof(";type=") - 1 : "application/octet-stream",
2077: CURLFORM_FILE, postval,
2078: CURLFORM_END);
2079: if (type) {
2080: *type = ';';
2081: }
2082: if (filename) {
2083: *filename = ';';
2084: }
2085: } else {
2086: error = curl_formadd(&first, &last,
2087: CURLFORM_COPYNAME, string_key,
2088: CURLFORM_NAMELENGTH, (long)string_key_len - 1,
2089: CURLFORM_COPYCONTENTS, postval,
2090: CURLFORM_CONTENTSLENGTH, (long)Z_STRLEN_PP(current),
2091: CURLFORM_END);
2092: }
2093: }
2094:
2095: SAVE_CURL_ERROR(ch, error);
2096: if (error != CURLE_OK) {
2097: RETVAL_FALSE;
2098: return 1;
2099: }
2100:
2101: zend_llist_add_element(&ch->to_free->post, &first);
2102: error = curl_easy_setopt(ch->cp, CURLOPT_HTTPPOST, first);
2103:
2104: } else {
2105: #if LIBCURL_VERSION_NUM >= 0x071101
2106: convert_to_string_ex(zvalue);
2107: /* with curl 7.17.0 and later, we can use COPYPOSTFIELDS, but we have to provide size before */
2108: error = curl_easy_setopt(ch->cp, CURLOPT_POSTFIELDSIZE, Z_STRLEN_PP(zvalue));
2109: error = curl_easy_setopt(ch->cp, CURLOPT_COPYPOSTFIELDS, Z_STRVAL_PP(zvalue));
2110: #else
2111: char *post = NULL;
2112:
2113: convert_to_string_ex(zvalue);
2114: post = estrndup(Z_STRVAL_PP(zvalue), Z_STRLEN_PP(zvalue));
2115: zend_llist_add_element(&ch->to_free->str, &post);
2116:
2117: error = curl_easy_setopt(ch->cp, CURLOPT_POSTFIELDS, post);
2118: error = curl_easy_setopt(ch->cp, CURLOPT_POSTFIELDSIZE, Z_STRLEN_PP(zvalue));
2119: #endif
2120: }
2121: break;
2122: case CURLOPT_HTTPHEADER:
2123: case CURLOPT_QUOTE:
2124: case CURLOPT_HTTP200ALIASES:
2125: case CURLOPT_POSTQUOTE: {
2126: zval **current;
2127: HashTable *ph;
2128: struct curl_slist *slist = NULL;
2129:
2130: ph = HASH_OF(*zvalue);
2131: if (!ph) {
2132: php_error_docref(NULL TSRMLS_CC, E_WARNING, "You must pass either an object or an array with the CURLOPT_HTTPHEADER, CURLOPT_QUOTE, CURLOPT_HTTP200ALIASES and CURLOPT_POSTQUOTE arguments");
2133: RETVAL_FALSE;
2134: return 1;
2135: }
2136:
2137: for (zend_hash_internal_pointer_reset(ph);
2138: zend_hash_get_current_data(ph, (void **) ¤t) == SUCCESS;
2139: zend_hash_move_forward(ph)
2140: ) {
2141: SEPARATE_ZVAL(current);
2142: convert_to_string_ex(current);
2143:
2144: slist = curl_slist_append(slist, Z_STRVAL_PP(current));
2145: if (!slist) {
2146: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not build curl_slist");
2147: RETVAL_FALSE;
2148: return 1;
2149: }
2150: }
2151: zend_llist_add_element(&ch->to_free->slist, &slist);
2152:
2153: error = curl_easy_setopt(ch->cp, option, slist);
2154:
2155: break;
2156: }
2157: /* the following options deal with files, therefor safe_mode & open_basedir checks
2158: * are required.
2159: */
2160: case CURLOPT_COOKIEJAR:
2161: case CURLOPT_SSLCERT:
2162: case CURLOPT_RANDOM_FILE:
2163: case CURLOPT_COOKIEFILE: {
2164: #if LIBCURL_VERSION_NUM < 0x071100
2165: char *copystr = NULL;
2166: #endif
2167:
2168: convert_to_string_ex(zvalue);
2169:
2170: if (php_check_open_basedir(Z_STRVAL_PP(zvalue) TSRMLS_CC) || (PG(safe_mode) && !php_checkuid(Z_STRVAL_PP(zvalue), "rb+", CHECKUID_CHECK_MODE_PARAM))) {
2171: RETVAL_FALSE;
2172: return 1;
2173: }
2174:
2175: #if LIBCURL_VERSION_NUM >= 0x071100
2176: error = curl_easy_setopt(ch->cp, option, Z_STRVAL_PP(zvalue));
2177: #else
2178: copystr = estrndup(Z_STRVAL_PP(zvalue), Z_STRLEN_PP(zvalue));
2179:
2180: error = curl_easy_setopt(ch->cp, option, copystr);
2181: zend_llist_add_element(&ch->to_free->str, ©str);
2182: #endif
2183: break;
2184: }
2185: case CURLINFO_HEADER_OUT:
2186: convert_to_long_ex(zvalue);
2187: if (Z_LVAL_PP(zvalue) == 1) {
2188: curl_easy_setopt(ch->cp, CURLOPT_DEBUGFUNCTION, curl_debug);
2189: curl_easy_setopt(ch->cp, CURLOPT_DEBUGDATA, (void *)ch);
2190: curl_easy_setopt(ch->cp, CURLOPT_VERBOSE, 1);
2191: } else {
2192: curl_easy_setopt(ch->cp, CURLOPT_DEBUGFUNCTION, NULL);
2193: curl_easy_setopt(ch->cp, CURLOPT_DEBUGDATA, NULL);
2194: curl_easy_setopt(ch->cp, CURLOPT_VERBOSE, 0);
2195: }
2196: break;
2197: }
2198:
2199: SAVE_CURL_ERROR(ch, error);
2200: if (error != CURLE_OK) {
2201: return 1;
2202: } else {
2203: return 0;
2204: }
2205: }
2206: /* }}} */
2207:
2208: /* {{{ proto bool curl_setopt(resource ch, int option, mixed value)
2209: Set an option for a cURL transfer */
2210: PHP_FUNCTION(curl_setopt)
2211: {
2212: zval *zid, **zvalue;
2213: long options;
2214: php_curl *ch;
2215:
2216: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlZ", &zid, &options, &zvalue) == FAILURE) {
2217: return;
2218: }
2219:
2220: ZEND_FETCH_RESOURCE(ch, php_curl *, &zid, -1, le_curl_name, le_curl);
2221:
2222: if (options <= 0) {
2223: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid curl configuration option");
2224: RETURN_FALSE;
2225: }
2226:
2227: if (!_php_curl_setopt(ch, options, zvalue, return_value TSRMLS_CC)) {
2228: RETURN_TRUE;
2229: } else {
2230: RETURN_FALSE;
2231: }
2232: }
2233: /* }}} */
2234:
2235: /* {{{ proto bool curl_setopt_array(resource ch, array options)
2236: Set an array of option for a cURL transfer */
2237: PHP_FUNCTION(curl_setopt_array)
2238: {
2239: zval *zid, *arr, **entry;
2240: php_curl *ch;
2241: ulong option;
2242: HashPosition pos;
2243: char *string_key;
2244: uint str_key_len;
2245:
2246: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "za", &zid, &arr) == FAILURE) {
2247: return;
2248: }
2249:
2250: ZEND_FETCH_RESOURCE(ch, php_curl *, &zid, -1, le_curl_name, le_curl);
2251:
2252: zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(arr), &pos);
2253: while (zend_hash_get_current_data_ex(Z_ARRVAL_P(arr), (void **)&entry, &pos) == SUCCESS) {
2254: if (zend_hash_get_current_key_ex(Z_ARRVAL_P(arr), &string_key, &str_key_len, &option, 0, &pos) != HASH_KEY_IS_LONG) {
2255: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Array keys must be CURLOPT constants or equivalent integer values");
2256: RETURN_FALSE;
2257: }
2258: if (_php_curl_setopt(ch, (long) option, entry, return_value TSRMLS_CC)) {
2259: RETURN_FALSE;
2260: }
2261: zend_hash_move_forward_ex(Z_ARRVAL_P(arr), &pos);
2262: }
2263: RETURN_TRUE;
2264: }
2265: /* }}} */
2266:
2267: /* {{{ _php_curl_cleanup_handle(ch)
2268: Cleanup an execution phase */
2269: void _php_curl_cleanup_handle(php_curl *ch)
2270: {
2271: if (ch->handlers->write->buf.len > 0) {
2272: smart_str_free(&ch->handlers->write->buf);
2273: }
2274: if (ch->header.str_len) {
2275: efree(ch->header.str);
2276: ch->header.str_len = 0;
2277: }
2278:
2279: memset(ch->err.str, 0, CURL_ERROR_SIZE + 1);
2280: ch->err.no = 0;
2281: }
2282: /* }}} */
2283:
2284: /* {{{ proto bool curl_exec(resource ch)
2285: Perform a cURL session */
2286: PHP_FUNCTION(curl_exec)
2287: {
2288: CURLcode error;
2289: zval *zid;
2290: php_curl *ch;
2291:
2292: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zid) == FAILURE) {
2293: return;
2294: }
2295:
2296: ZEND_FETCH_RESOURCE(ch, php_curl *, &zid, -1, le_curl_name, le_curl);
2297:
2298: _php_curl_verify_handlers(ch, 1 TSRMLS_CC);
2299:
2300: _php_curl_cleanup_handle(ch);
2301:
2302: error = curl_easy_perform(ch->cp);
2303: SAVE_CURL_ERROR(ch, error);
2304: /* CURLE_PARTIAL_FILE is returned by HEAD requests */
2305: if (error != CURLE_OK && error != CURLE_PARTIAL_FILE) {
2306: if (ch->handlers->write->buf.len > 0) {
2307: smart_str_free(&ch->handlers->write->buf);
2308: }
2309: RETURN_FALSE;
2310: }
2311:
2312: if (ch->handlers->std_err) {
2313: php_stream *stream;
2314: stream = (php_stream*)zend_fetch_resource(&ch->handlers->std_err TSRMLS_CC, -1, NULL, NULL, 2, php_file_le_stream(), php_file_le_pstream());
2315: if (stream) {
2316: php_stream_flush(stream);
2317: }
2318: }
2319:
2320: if (ch->handlers->write->method == PHP_CURL_RETURN && ch->handlers->write->buf.len > 0) {
2321: smart_str_0(&ch->handlers->write->buf);
2322: RETURN_STRINGL(ch->handlers->write->buf.c, ch->handlers->write->buf.len, 1);
2323: }
2324:
2325: /* flush the file handle, so any remaining data is synched to disk */
2326: if (ch->handlers->write->method == PHP_CURL_FILE && ch->handlers->write->fp) {
2327: fflush(ch->handlers->write->fp);
2328: }
2329: if (ch->handlers->write_header->method == PHP_CURL_FILE && ch->handlers->write_header->fp) {
2330: fflush(ch->handlers->write_header->fp);
2331: }
2332:
2333: if (ch->handlers->write->method == PHP_CURL_RETURN) {
2334: RETURN_EMPTY_STRING();
2335: } else {
2336: RETURN_TRUE;
2337: }
2338: }
2339: /* }}} */
2340:
2341: /* {{{ proto mixed curl_getinfo(resource ch [, int option])
2342: Get information regarding a specific transfer */
2343: PHP_FUNCTION(curl_getinfo)
2344: {
2345: zval *zid;
2346: php_curl *ch;
2347: long option = 0;
2348:
2349: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &zid, &option) == FAILURE) {
2350: return;
2351: }
2352:
2353: ZEND_FETCH_RESOURCE(ch, php_curl *, &zid, -1, le_curl_name, le_curl);
2354:
2355: if (ZEND_NUM_ARGS() < 2) {
2356: char *s_code;
2357: long l_code;
2358: double d_code;
2359: #if LIBCURL_VERSION_NUM > 0x071301
2360: struct curl_certinfo *ci = NULL;
2361: zval *listcode;
2362: #endif
2363:
2364: array_init(return_value);
2365:
2366: if (curl_easy_getinfo(ch->cp, CURLINFO_EFFECTIVE_URL, &s_code) == CURLE_OK) {
2367: CAAS("url", s_code);
2368: }
2369: if (curl_easy_getinfo(ch->cp, CURLINFO_CONTENT_TYPE, &s_code) == CURLE_OK) {
2370: if (s_code != NULL) {
2371: CAAS("content_type", s_code);
2372: } else {
2373: zval *retnull;
2374: MAKE_STD_ZVAL(retnull);
2375: ZVAL_NULL(retnull);
2376: CAAZ("content_type", retnull);
2377: }
2378: }
2379: if (curl_easy_getinfo(ch->cp, CURLINFO_HTTP_CODE, &l_code) == CURLE_OK) {
2380: CAAL("http_code", l_code);
2381: }
2382: if (curl_easy_getinfo(ch->cp, CURLINFO_HEADER_SIZE, &l_code) == CURLE_OK) {
2383: CAAL("header_size", l_code);
2384: }
2385: if (curl_easy_getinfo(ch->cp, CURLINFO_REQUEST_SIZE, &l_code) == CURLE_OK) {
2386: CAAL("request_size", l_code);
2387: }
2388: if (curl_easy_getinfo(ch->cp, CURLINFO_FILETIME, &l_code) == CURLE_OK) {
2389: CAAL("filetime", l_code);
2390: }
2391: if (curl_easy_getinfo(ch->cp, CURLINFO_SSL_VERIFYRESULT, &l_code) == CURLE_OK) {
2392: CAAL("ssl_verify_result", l_code);
2393: }
2394: if (curl_easy_getinfo(ch->cp, CURLINFO_REDIRECT_COUNT, &l_code) == CURLE_OK) {
2395: CAAL("redirect_count", l_code);
2396: }
2397: if (curl_easy_getinfo(ch->cp, CURLINFO_TOTAL_TIME, &d_code) == CURLE_OK) {
2398: CAAD("total_time", d_code);
2399: }
2400: if (curl_easy_getinfo(ch->cp, CURLINFO_NAMELOOKUP_TIME, &d_code) == CURLE_OK) {
2401: CAAD("namelookup_time", d_code);
2402: }
2403: if (curl_easy_getinfo(ch->cp, CURLINFO_CONNECT_TIME, &d_code) == CURLE_OK) {
2404: CAAD("connect_time", d_code);
2405: }
2406: if (curl_easy_getinfo(ch->cp, CURLINFO_PRETRANSFER_TIME, &d_code) == CURLE_OK) {
2407: CAAD("pretransfer_time", d_code);
2408: }
2409: if (curl_easy_getinfo(ch->cp, CURLINFO_SIZE_UPLOAD, &d_code) == CURLE_OK) {
2410: CAAD("size_upload", d_code);
2411: }
2412: if (curl_easy_getinfo(ch->cp, CURLINFO_SIZE_DOWNLOAD, &d_code) == CURLE_OK) {
2413: CAAD("size_download", d_code);
2414: }
2415: if (curl_easy_getinfo(ch->cp, CURLINFO_SPEED_DOWNLOAD, &d_code) == CURLE_OK) {
2416: CAAD("speed_download", d_code);
2417: }
2418: if (curl_easy_getinfo(ch->cp, CURLINFO_SPEED_UPLOAD, &d_code) == CURLE_OK) {
2419: CAAD("speed_upload", d_code);
2420: }
2421: if (curl_easy_getinfo(ch->cp, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &d_code) == CURLE_OK) {
2422: CAAD("download_content_length", d_code);
2423: }
2424: if (curl_easy_getinfo(ch->cp, CURLINFO_CONTENT_LENGTH_UPLOAD, &d_code) == CURLE_OK) {
2425: CAAD("upload_content_length", d_code);
2426: }
2427: if (curl_easy_getinfo(ch->cp, CURLINFO_STARTTRANSFER_TIME, &d_code) == CURLE_OK) {
2428: CAAD("starttransfer_time", d_code);
2429: }
2430: if (curl_easy_getinfo(ch->cp, CURLINFO_REDIRECT_TIME, &d_code) == CURLE_OK) {
2431: CAAD("redirect_time", d_code);
2432: }
2433: #if LIBCURL_VERSION_NUM > 0x071301
2434: if (curl_easy_getinfo(ch->cp, CURLINFO_CERTINFO, &ci) == CURLE_OK) {
2435: MAKE_STD_ZVAL(listcode);
2436: array_init(listcode);
2437: create_certinfo(ci, listcode TSRMLS_CC);
2438: CAAZ("certinfo", listcode);
2439: }
2440: #endif
2441: #if LIBCURL_VERSION_NUM >= 0x071202
2442: if (curl_easy_getinfo(ch->cp, CURLINFO_REDIRECT_URL, &s_code) == CURLE_OK) {
2443: CAAS("redirect_url", s_code);
2444: }
2445: #endif
2446: if (ch->header.str_len > 0) {
2447: CAAS("request_header", ch->header.str);
2448: }
2449: } else {
2450: switch (option) {
2451: case CURLINFO_PRIVATE:
2452: case CURLINFO_EFFECTIVE_URL:
2453: case CURLINFO_CONTENT_TYPE:
2454: #if LIBCURL_VERSION_NUM >= 0x071202
2455: case CURLINFO_REDIRECT_URL:
2456: #endif
2457: {
2458: char *s_code = NULL;
2459:
2460: if (curl_easy_getinfo(ch->cp, option, &s_code) == CURLE_OK && s_code) {
2461: RETURN_STRING(s_code, 1);
2462: } else {
2463: RETURN_FALSE;
2464: }
2465: break;
2466: }
2467: case CURLINFO_HTTP_CODE:
2468: case CURLINFO_HEADER_SIZE:
2469: case CURLINFO_REQUEST_SIZE:
2470: case CURLINFO_FILETIME:
2471: case CURLINFO_SSL_VERIFYRESULT:
2472: case CURLINFO_REDIRECT_COUNT: {
2473: long code = 0;
2474:
2475: if (curl_easy_getinfo(ch->cp, option, &code) == CURLE_OK) {
2476: RETURN_LONG(code);
2477: } else {
2478: RETURN_FALSE;
2479: }
2480: break;
2481: }
2482: case CURLINFO_TOTAL_TIME:
2483: case CURLINFO_NAMELOOKUP_TIME:
2484: case CURLINFO_CONNECT_TIME:
2485: case CURLINFO_PRETRANSFER_TIME:
2486: case CURLINFO_SIZE_UPLOAD:
2487: case CURLINFO_SIZE_DOWNLOAD:
2488: case CURLINFO_SPEED_DOWNLOAD:
2489: case CURLINFO_SPEED_UPLOAD:
2490: case CURLINFO_CONTENT_LENGTH_DOWNLOAD:
2491: case CURLINFO_CONTENT_LENGTH_UPLOAD:
2492: case CURLINFO_STARTTRANSFER_TIME:
2493: case CURLINFO_REDIRECT_TIME: {
2494: double code = 0.0;
2495:
2496: if (curl_easy_getinfo(ch->cp, option, &code) == CURLE_OK) {
2497: RETURN_DOUBLE(code);
2498: } else {
2499: RETURN_FALSE;
2500: }
2501: break;
2502: }
2503: case CURLINFO_HEADER_OUT:
2504: if (ch->header.str_len > 0) {
2505: RETURN_STRINGL(ch->header.str, ch->header.str_len, 1);
2506: } else {
2507: RETURN_FALSE;
2508: }
2509: #if LIBCURL_VERSION_NUM > 0x071301
2510: case CURLINFO_CERTINFO: {
2511: struct curl_certinfo *ci = NULL;
2512:
2513: array_init(return_value);
2514:
2515: if (curl_easy_getinfo(ch->cp, CURLINFO_CERTINFO, &ci) == CURLE_OK) {
2516: create_certinfo(ci, return_value TSRMLS_CC);
2517: } else {
2518: RETURN_FALSE;
2519: }
2520: break;
2521: }
2522: #endif
2523: }
2524: }
2525: }
2526: /* }}} */
2527:
2528: /* {{{ proto string curl_error(resource ch)
2529: Return a string contain the last error for the current session */
2530: PHP_FUNCTION(curl_error)
2531: {
2532: zval *zid;
2533: php_curl *ch;
2534:
2535: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zid) == FAILURE) {
2536: return;
2537: }
2538:
2539: ZEND_FETCH_RESOURCE(ch, php_curl *, &zid, -1, le_curl_name, le_curl);
2540:
2541: ch->err.str[CURL_ERROR_SIZE] = 0;
2542: RETURN_STRING(ch->err.str, 1);
2543: }
2544: /* }}} */
2545:
2546: /* {{{ proto int curl_errno(resource ch)
2547: Return an integer containing the last error number */
2548: PHP_FUNCTION(curl_errno)
2549: {
2550: zval *zid;
2551: php_curl *ch;
2552:
2553: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zid) == FAILURE) {
2554: return;
2555: }
2556:
2557: ZEND_FETCH_RESOURCE(ch, php_curl *, &zid, -1, le_curl_name, le_curl);
2558:
2559: RETURN_LONG(ch->err.no);
2560: }
2561: /* }}} */
2562:
2563: /* {{{ proto void curl_close(resource ch)
2564: Close a cURL session */
2565: PHP_FUNCTION(curl_close)
2566: {
2567: zval *zid;
2568: php_curl *ch;
2569:
2570: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zid) == FAILURE) {
2571: return;
2572: }
2573:
2574: ZEND_FETCH_RESOURCE(ch, php_curl *, &zid, -1, le_curl_name, le_curl);
2575:
2576: if (ch->in_callback) {
2577: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Attempt to close cURL handle from a callback");
2578: return;
2579: }
2580:
2581: if (ch->uses) {
2582: ch->uses--;
2583: } else {
2584: zend_list_delete(Z_LVAL_P(zid));
2585: }
2586: }
2587: /* }}} */
2588:
2589: /* {{{ _php_curl_close()
2590: List destructor for curl handles */
2591: static void _php_curl_close_ex(php_curl *ch TSRMLS_DC)
2592: {
2593: #if PHP_CURL_DEBUG
2594: fprintf(stderr, "DTOR CALLED, ch = %x\n", ch);
2595: #endif
2596:
2597: _php_curl_verify_handlers(ch, 0 TSRMLS_CC);
2598: curl_easy_cleanup(ch->cp);
2599:
2600: /* cURL destructors should be invoked only by last curl handle */
2601: if (Z_REFCOUNT_P(ch->clone) <= 1) {
2602: zend_llist_clean(&ch->to_free->str);
2603: zend_llist_clean(&ch->to_free->slist);
2604: zend_llist_clean(&ch->to_free->post);
2605: efree(ch->to_free);
2606: FREE_ZVAL(ch->clone);
2607: } else {
2608: Z_DELREF_P(ch->clone);
2609: }
2610:
2611: if (ch->handlers->write->buf.len > 0) {
2612: smart_str_free(&ch->handlers->write->buf);
2613: }
2614: if (ch->handlers->write->func_name) {
2615: zval_ptr_dtor(&ch->handlers->write->func_name);
2616: }
2617: if (ch->handlers->read->func_name) {
2618: zval_ptr_dtor(&ch->handlers->read->func_name);
2619: }
2620: if (ch->handlers->write_header->func_name) {
2621: zval_ptr_dtor(&ch->handlers->write_header->func_name);
2622: }
2623: if (ch->handlers->progress->func_name) {
2624: zval_ptr_dtor(&ch->handlers->progress->func_name);
2625: }
2626: if (ch->handlers->passwd) {
2627: zval_ptr_dtor(&ch->handlers->passwd);
2628: }
2629: if (ch->handlers->std_err) {
2630: zval_ptr_dtor(&ch->handlers->std_err);
2631: }
2632: if (ch->header.str_len > 0) {
2633: efree(ch->header.str);
2634: }
2635:
2636: if (ch->handlers->write_header->stream) {
2637: zval_ptr_dtor(&ch->handlers->write_header->stream);
2638: }
2639: if (ch->handlers->write->stream) {
2640: zval_ptr_dtor(&ch->handlers->write->stream);
2641: }
2642: if (ch->handlers->read->stream) {
2643: zval_ptr_dtor(&ch->handlers->read->stream);
2644: }
2645:
2646: efree(ch->handlers->write);
2647: efree(ch->handlers->write_header);
2648: efree(ch->handlers->read);
2649: efree(ch->handlers->progress);
2650: efree(ch->handlers);
2651: efree(ch);
2652: }
2653: /* }}} */
2654:
2655: /* {{{ _php_curl_close()
2656: List destructor for curl handles */
2657: static void _php_curl_close(zend_rsrc_list_entry *rsrc TSRMLS_DC)
2658: {
2659: php_curl *ch = (php_curl *) rsrc->ptr;
2660: _php_curl_close_ex(ch TSRMLS_CC);
2661: }
2662: /* }}} */
2663:
2664: #endif /* HAVE_CURL */
2665:
2666: /*
2667: * Local variables:
2668: * tab-width: 4
2669: * c-basic-offset: 4
2670: * End:
2671: * vim600: fdm=marker
2672: * vim: noet sw=4 ts=4
2673: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to interface.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / curl