?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kill evhttp_*
[hiphop-php.git] / hphp / runtime / ext / curl / ext_curl.cpp
blobc08d1628b9da88f13c3fe882b48946765df22150
1 /*
2 +----------------------------------------------------------------------+
3 | HipHop for PHP |
4 +----------------------------------------------------------------------+
5 | Copyright (c) 2010-2014 Facebook, Inc. (http://www.facebook.com) |
6 | Copyright (c) 1997-2010 The PHP Group |
7 +----------------------------------------------------------------------+
8 | This source file is subject to version 3.01 of the PHP license, |
9 | that is bundled with this package in the file LICENSE, and is |
10 | available through the world-wide-web at the following url: |
11 | http://www.php.net/license/3_01.txt |
12 | If you did not receive a copy of the PHP license and are unable to |
13 | obtain it through the world-wide-web, please send a note to |
14 | license@php.net so we can mail you a copy immediately. |
15 +----------------------------------------------------------------------+
16 */
17
18 #include "hphp/runtime/ext/curl/ext_curl.h"
19 #include "hphp/runtime/base/string-buffer.h"
20 #include "hphp/runtime/base/libevent-http-client.h"
21 #include "hphp/runtime/base/curl-tls-workarounds.h"
22 #include "hphp/runtime/base/runtime-option.h"
23 #include "hphp/runtime/server/server-stats.h"
24 #include "hphp/runtime/vm/jit/translator-inline.h"
25 #include <openssl/ssl.h>
26 #include <curl/curl.h>
27 #include <curl/easy.h>
28 #include <curl/multi.h>
29 #include <memory>
30 #include <vector>
31
32 #define CURLOPT_RETURNTRANSFER 19913
33 #define CURLOPT_BINARYTRANSFER 19914
34 #define CURLOPT_MUTE -2
35 #define CURLOPT_PASSWDFUNCTION -3
36 #define PHP_CURL_STDOUT 0
37 #define PHP_CURL_FILE 1
38 #define PHP_CURL_USER 2
39 #define PHP_CURL_DIRECT 3
40 #define PHP_CURL_RETURN 4
41 #define PHP_CURL_ASCII 5
42 #define PHP_CURL_BINARY 6
43 #define PHP_CURL_IGNORE 7
44
45
46 namespace HPHP {
47
48 using std::string;
49 using std::vector;
50
51 const StaticString
52 s_exception("exception"),
53 s_previous("previous");
54
55 ///////////////////////////////////////////////////////////////////////////////
56 // helper data structure
57
58 class CurlResource : public SweepableResourceData {
59 private:
60 DECLARE_RESOURCE_ALLOCATION(CurlResource)
61
62 class WriteHandler {
63 public:
64 WriteHandler() : method(0), type(0) {}
65
66 int method;
67 Variant callback;
68 SmartResource<File> fp;
69 StringBuffer buf;
70 String content;
71 int type;
72 };
73
74 class ReadHandler {
75 public:
76 ReadHandler() : method(0) {}
77
78 int method;
79 Variant callback;
80 SmartResource<File> fp;
81 };
82
83 class ToFree {
84 public:
85 std::vector<char*> str;
86 std::vector<curl_httppost*> post;
87 std::vector<curl_slist*> slist;
88
89 ~ToFree() {
90 for (unsigned int i = 0; i < str.size(); i++) {
91 free(str[i]);
92 }
93 for (unsigned int i = 0; i < post.size(); i++) {
94 curl_formfree(post[i]);
95 }
96 for (unsigned int i = 0; i < slist.size(); i++) {
97 curl_slist_free_all(slist[i]);
98 }
99 }
100 };
101
102 public:
103 CLASSNAME_IS("cURL handle")
104 // overriding ResourceData
105 virtual const String& o_getClassNameHook() const { return classnameof(); }
106
107 explicit CurlResource(const String& url)
108 : m_exception(nullptr), m_phpException(false), m_emptyPost(true) {
109 m_cp = curl_easy_init();
110 m_url = url;
111
112 memset(m_error_str, 0, sizeof(m_error_str));
113 m_error_no = CURLE_OK;
114 m_to_free = std::make_shared<ToFree>();
115
116 m_write.method = PHP_CURL_STDOUT;
117 m_write.type = PHP_CURL_ASCII;
118 m_read.method = PHP_CURL_DIRECT;
119 m_write_header.method = PHP_CURL_IGNORE;
120
121 curl_easy_setopt(m_cp, CURLOPT_NOPROGRESS, 1);
122 curl_easy_setopt(m_cp, CURLOPT_VERBOSE, 0);
123 curl_easy_setopt(m_cp, CURLOPT_ERRORBUFFER, m_error_str);
124 curl_easy_setopt(m_cp, CURLOPT_WRITEFUNCTION, curl_write);
125 curl_easy_setopt(m_cp, CURLOPT_FILE, (void*)this);
126 curl_easy_setopt(m_cp, CURLOPT_READFUNCTION, curl_read);
127 curl_easy_setopt(m_cp, CURLOPT_INFILE, (void*)this);
128 curl_easy_setopt(m_cp, CURLOPT_HEADERFUNCTION, curl_write_header);
129 curl_easy_setopt(m_cp, CURLOPT_WRITEHEADER, (void*)this);
130 curl_easy_setopt(m_cp, CURLOPT_DNS_USE_GLOBAL_CACHE, 0); // for thread-safe
131 curl_easy_setopt(m_cp, CURLOPT_DNS_CACHE_TIMEOUT, 120);
132 curl_easy_setopt(m_cp, CURLOPT_MAXREDIRS, 20); // no infinite redirects
133 curl_easy_setopt(m_cp, CURLOPT_NOSIGNAL, 1); // for multithreading mode
134 curl_easy_setopt(m_cp, CURLOPT_SSL_CTX_FUNCTION,
135 CurlResource::ssl_ctx_callback);
136 curl_easy_setopt(m_cp, CURLOPT_SSL_CTX_DATA, (void*)this);
137
138 curl_easy_setopt(m_cp, CURLOPT_TIMEOUT,
139 RuntimeOption::HttpDefaultTimeout);
140 curl_easy_setopt(m_cp, CURLOPT_CONNECTTIMEOUT,
141 RuntimeOption::HttpDefaultTimeout);
142
143 if (!url.empty()) {
144 #if LIBCURL_VERSION_NUM >= 0x071100
145 /* Strings passed to libcurl as 'char *' arguments, are copied by
146 the library... NOTE: before 7.17.0 strings were not copied. */
147 curl_easy_setopt(m_cp, CURLOPT_URL, url.c_str());
148 #else
149 char *urlcopy = strndup(url.data(), url.size());
150 curl_easy_setopt(m_cp, CURLOPT_URL, urlcopy);
151 m_to_free->str.push_back(urlcopy);
152 #endif
153 }
154 }
155
156 explicit CurlResource(CurlResource *src)
157 : m_exception(nullptr), m_phpException(false) {
158 assert(src && src != this);
159 assert(!src->m_exception);
160
161 m_cp = curl_easy_duphandle(src->get());
162 m_url = src->m_url;
163
164 memset(m_error_str, 0, sizeof(m_error_str));
165 m_error_no = CURLE_OK;
166
167 m_write.method = src->m_write.method;
168 m_write.type = src->m_write.type;
169 m_read.method = src->m_read.method;
170 m_write_header.method = src->m_write_header.method;
171
172 m_write.fp = src->m_write.fp;
173 m_write_header.fp = src->m_write_header.fp;
174 m_read.fp = src->m_read.fp;
175
176 m_write.callback = src->m_write.callback;
177 m_read.callback = src->m_read.callback;
178 m_write_header.callback = src->m_write_header.callback;
179
180 curl_easy_setopt(m_cp, CURLOPT_ERRORBUFFER, m_error_str);
181 curl_easy_setopt(m_cp, CURLOPT_FILE, (void*)this);
182 curl_easy_setopt(m_cp, CURLOPT_INFILE, (void*)this);
183 curl_easy_setopt(m_cp, CURLOPT_WRITEHEADER, (void*)this);
184
185 m_to_free = src->m_to_free;
186 m_emptyPost = src->m_emptyPost;
187 }
188
189 ~CurlResource() {
190 close();
191 }
192
193 virtual bool isInvalid() const {
194 return !m_cp;
195 }
196
197 void closeForSweep() {
198 assert(!m_exception);
199 if (m_cp) {
200 curl_easy_cleanup(m_cp);
201 m_cp = nullptr;
202 }
203 m_to_free.reset();
204 }
205
206 void close() {
207 closeForSweep();
208 m_opts.clear();
209 }
210
211 void check_exception() {
212 if (m_exception) {
213 if (m_phpException) {
214 Object e((ObjectData*)m_exception);
215 m_exception = nullptr;
216 e.get()->decRefCount();
217 throw e;
218 } else {
219 Exception *e = (Exception*)m_exception;
220 m_exception = nullptr;
221 e->throwException();
222 }
223 }
224 }
225
226 ObjectData* getAndClearPhpException() {
227 if (m_exception && m_phpException) {
228 ObjectData* ret = (ObjectData*)m_exception;
229 m_exception = nullptr;
230 return ret;
231 }
232 return nullptr;
233 }
234
235 Exception* getAndClearCppException() {
236 if (!m_phpException) {
237 Exception* e = (Exception*)m_exception;
238 m_exception = nullptr;
239 return e;
240 }
241 return nullptr;
242 }
243
244 Variant execute() {
245 assert(!m_exception);
246 if (m_cp == nullptr) {
247 return false;
248 }
249 if (m_emptyPost) {
250 // As per curl docs, an empty post must set POSTFIELDSIZE to be 0 or
251 // the reader function will be called
252 curl_easy_setopt(m_cp, CURLOPT_POSTFIELDSIZE, 0);
253 }
254 m_write.buf.clear();
255 m_write.content.clear();
256 m_header.clear();
257 memset(m_error_str, 0, sizeof(m_error_str));
258
259 {
260 IOStatusHelper io("curl_easy_perform", m_url.data());
261 SYNC_VM_REGS_SCOPED();
262 m_error_no = curl_easy_perform(m_cp);
263 check_exception();
264 }
265 set_curl_statuses(m_cp, m_url.data());
266
267 /* CURLE_PARTIAL_FILE is returned by HEAD requests */
268 if (m_error_no != CURLE_OK && m_error_no != CURLE_PARTIAL_FILE) {
269 m_write.buf.clear();
270 m_write.content.clear();
271 return false;
272 }
273
274 if (m_write.method == PHP_CURL_RETURN) {
275 if (!m_write.buf.empty()) {
276 m_write.content = m_write.buf.detach();
277 }
278 if (!m_write.content.empty()) {
279 return m_write.content;
280 }
281 }
282 if (m_write.method == PHP_CURL_RETURN) {
283 return String("");
284 }
285 return true;
286 }
287
288 String getUrl() {
289 return m_url;
290 }
291
292 String getHeader() {
293 return m_header;
294 }
295
296 String getContents() {
297 if (m_write.method == PHP_CURL_RETURN) {
298 if (!m_write.buf.empty()) {
299 m_write.content = m_write.buf.detach();
300 }
301 return m_write.content;
302 }
303 return String();
304 }
305
306 bool setOption(long option, const Variant& value) {
307 if (m_cp == nullptr) {
308 return false;
309 }
310 m_error_no = CURLE_OK;
311
312 switch (option) {
313 case CURLOPT_INFILESIZE:
314 case CURLOPT_VERBOSE:
315 case CURLOPT_HEADER:
316 case CURLOPT_NOPROGRESS:
317 case CURLOPT_NOBODY:
318 case CURLOPT_FAILONERROR:
319 case CURLOPT_UPLOAD:
320 case CURLOPT_POST:
321 #if LIBCURL_VERSION_NUM >= 0x071301
322 case CURLOPT_POSTREDIR:
323 #endif
324 case CURLOPT_FTPLISTONLY:
325 case CURLOPT_FTPAPPEND:
326 case CURLOPT_NETRC:
327 case CURLOPT_PUT:
328 case CURLOPT_TIMEOUT:
329 #if LIBCURL_VERSION_NUM >= 0x071002
330 case CURLOPT_TIMEOUT_MS:
331 #endif
332 case CURLOPT_FTP_USE_EPSV:
333 case CURLOPT_LOW_SPEED_LIMIT:
334 case CURLOPT_SSLVERSION:
335 case CURLOPT_LOW_SPEED_TIME:
336 case CURLOPT_RESUME_FROM:
337 case CURLOPT_TIMEVALUE:
338 case CURLOPT_TIMECONDITION:
339 case CURLOPT_TRANSFERTEXT:
340 case CURLOPT_HTTPPROXYTUNNEL:
341 case CURLOPT_FILETIME:
342 case CURLOPT_MAXREDIRS:
343 case CURLOPT_MAXCONNECTS:
344 case CURLOPT_CLOSEPOLICY:
345 case CURLOPT_FRESH_CONNECT:
346 case CURLOPT_FORBID_REUSE:
347 case CURLOPT_CONNECTTIMEOUT:
348 #if LIBCURL_VERSION_NUM >= 0x071002
349 case CURLOPT_CONNECTTIMEOUT_MS:
350 #endif
351 case CURLOPT_SSL_VERIFYHOST:
352 case CURLOPT_SSL_VERIFYPEER:
353 //case CURLOPT_DNS_USE_GLOBAL_CACHE: not thread-safe when set to true
354 case CURLOPT_NOSIGNAL:
355 case CURLOPT_PROXYTYPE:
356 case CURLOPT_BUFFERSIZE:
357 case CURLOPT_HTTPGET:
358 case CURLOPT_HTTP_VERSION:
359 case CURLOPT_CRLF:
360 case CURLOPT_DNS_CACHE_TIMEOUT:
361 case CURLOPT_PROXYPORT:
362 case CURLOPT_FTP_USE_EPRT:
363 case CURLOPT_HTTPAUTH:
364 case CURLOPT_PROXYAUTH:
365 case CURLOPT_FTP_CREATE_MISSING_DIRS:
366 case CURLOPT_FTPSSLAUTH:
367 case CURLOPT_FTP_SSL:
368 case CURLOPT_UNRESTRICTED_AUTH:
369 case CURLOPT_PORT:
370 case CURLOPT_AUTOREFERER:
371 case CURLOPT_COOKIESESSION:
372 case CURLOPT_TCP_NODELAY:
373 case CURLOPT_IPRESOLVE:
374 case CURLOPT_FOLLOWLOCATION:
375 m_error_no = curl_easy_setopt(m_cp, (CURLoption)option, value.toInt64());
376 break;
377 case CURLOPT_RETURNTRANSFER:
378 m_write.method = value.toBoolean() ? PHP_CURL_RETURN : PHP_CURL_STDOUT;
379 break;
380 case CURLOPT_BINARYTRANSFER:
381 m_write.type = value.toBoolean() ? PHP_CURL_BINARY : PHP_CURL_ASCII;
382 break;
383 case CURLOPT_PRIVATE:
384 case CURLOPT_URL:
385 case CURLOPT_PROXY:
386 case CURLOPT_USERPWD:
387 case CURLOPT_PROXYUSERPWD:
388 case CURLOPT_RANGE:
389 case CURLOPT_CUSTOMREQUEST:
390 case CURLOPT_USERAGENT:
391 case CURLOPT_FTPPORT:
392 case CURLOPT_COOKIE:
393 case CURLOPT_REFERER:
394 case CURLOPT_INTERFACE:
395 case CURLOPT_KRB4LEVEL:
396 case CURLOPT_EGDSOCKET:
397 case CURLOPT_CAINFO:
398 case CURLOPT_CAPATH:
399 case CURLOPT_SSL_CIPHER_LIST:
400 case CURLOPT_SSLKEY:
401 case CURLOPT_SSLKEYTYPE:
402 case CURLOPT_SSLKEYPASSWD:
403 case CURLOPT_SSLENGINE:
404 case CURLOPT_SSLENGINE_DEFAULT:
405 case CURLOPT_SSLCERTTYPE:
406 case CURLOPT_ENCODING:
407 case CURLOPT_COOKIEJAR:
408 case CURLOPT_SSLCERT:
409 case CURLOPT_RANDOM_FILE:
410 case CURLOPT_COOKIEFILE:
411 {
412 String svalue = value.toString();
413 #if LIBCURL_VERSION_NUM >= 0x071100
414 /* Strings passed to libcurl as 'char *' arguments, are copied
415 by the library... NOTE: before 7.17.0 strings were not copied. */
416 m_error_no = curl_easy_setopt(m_cp, (CURLoption)option, svalue.c_str());
417 #else
418 char *copystr = strndup(svalue.data(), svalue.size());
419 m_to_free->str.push_back(copystr);
420 m_error_no = curl_easy_setopt(m_cp, (CURLoption)option, copystr);
421 #endif
422 if (option == CURLOPT_URL) m_url = value;
423 }
424 break;
425 case CURLOPT_FILE:
426 case CURLOPT_INFILE:
427 case CURLOPT_WRITEHEADER:
428 case CURLOPT_STDERR:
429 {
430 if (!value.isResource()) {
431 return false;
432 }
433
434 Resource obj = value.toResource();
435 if (obj.isNull() || obj.getTyped<File>(true) == nullptr) {
436 return false;
437 }
438
439 switch (option) {
440 case CURLOPT_FILE:
441 m_write.fp = obj;
442 m_write.method = PHP_CURL_FILE;
443 break;
444 case CURLOPT_WRITEHEADER:
445 m_write_header.fp = obj;
446 m_write_header.method = PHP_CURL_FILE;
447 break;
448 case CURLOPT_INFILE:
449 m_read.fp = obj;
450 m_emptyPost = false;
451 break;
452 default: {
453 if (obj.getTyped<PlainFile>(true) == nullptr) {
454 return false;
455 }
456 FILE *fp = obj.getTyped<PlainFile>()->getStream();
457 if (!fp) {
458 return false;
459 }
460 m_error_no = curl_easy_setopt(m_cp, (CURLoption)option, fp);
461 break;
462 }
463 }
464 }
465 break;
466 case CURLOPT_WRITEFUNCTION:
467 m_write.callback = value;
468 m_write.method = PHP_CURL_USER;
469 break;
470 case CURLOPT_READFUNCTION:
471 m_read.callback = value;
472 m_read.method = PHP_CURL_USER;
473 m_emptyPost = false;
474 break;
475 case CURLOPT_HEADERFUNCTION:
476 m_write_header.callback = value;
477 m_write_header.method = PHP_CURL_USER;
478 break;
479 case CURLOPT_PROGRESSFUNCTION:
480 m_progress_callback = value;
481 curl_easy_setopt(m_cp, CURLOPT_PROGRESSDATA, (void*) this);
482 curl_easy_setopt(m_cp, CURLOPT_PROGRESSFUNCTION, curl_progress);
483 break;
484 case CURLOPT_POSTFIELDS:
485 m_emptyPost = false;
486 if (value.is(KindOfArray) || value.is(KindOfObject)) {
487 Array arr = value.toArray();
488 curl_httppost *first = nullptr;
489 curl_httppost *last = nullptr;
490 for (ArrayIter iter(arr); iter; ++iter) {
491 String key = iter.first().toString();
492 String val = iter.second().toString();
493 const char *postval = val.data();
494
495 if (*postval == '@') {
496 /* Given a string like:
497 * "@/foo/bar;type=herp/derp;filename=ponies\0"
498 * - Temporarily convert to:
499 * "@/foo/bar\0type=herp/derp\0filename=ponies\0"
500 * - Pass pointers to the relevant null-terminated substrings to
501 * curl_formadd
502 * - Revert changes to postval at the end
503 */
504 char* mutablePostval = const_cast<char*>(postval);
505 char* type = strstr(mutablePostval, ";type=");
506 char* filename = strstr(mutablePostval, ";filename=");
507
508 if (type) {
509 *type = '\0';
510 }
511 if (filename) {
512 *filename = '\0';
513 }
514
515 /* The arguments after _NAMELENGTH and _CONTENTSLENGTH
516 * must be explicitly cast to long in curl_formadd
517 * use since curl needs a long not an int. */
518 ++postval;
519 m_error_no = (CURLcode)curl_formadd
520 (&first, &last,
521 CURLFORM_COPYNAME, key.data(),
522 CURLFORM_NAMELENGTH, (long)key.size(),
523 CURLFORM_FILENAME, filename
524 ? filename + sizeof(";filename=") - 1
525 : postval,
526 CURLFORM_CONTENTTYPE, type
527 ? type + sizeof(";type=") - 1
528 : "application/octet-stream",
529 CURLFORM_FILE, postval,
530 CURLFORM_END);
531
532 if (type) {
533 *type = ';';
534 }
535 if (filename) {
536 *filename = ';';
537 }
538 } else {
539 m_error_no = (CURLcode)curl_formadd
540 (&first, &last,
541 CURLFORM_COPYNAME, key.data(),
542 CURLFORM_NAMELENGTH, (long)key.size(),
543 CURLFORM_COPYCONTENTS, postval,
544 CURLFORM_CONTENTSLENGTH,(long)val.size(),
545 CURLFORM_END);
546 }
547 }
548
549 if (m_error_no != CURLE_OK) {
550 return false;
551 }
552
553 m_to_free->post.push_back(first);
554 m_error_no = curl_easy_setopt(m_cp, CURLOPT_HTTPPOST, first);
555
556 } else {
557 String svalue = value.toString();
558 #if LIBCURL_VERSION_NUM >= 0x071100
559 /* with curl 7.17.0 and later, we can use COPYPOSTFIELDS,
560 but we have to provide size before */
561 m_error_no = curl_easy_setopt(m_cp, CURLOPT_POSTFIELDSIZE,
562 svalue.size());
563 m_error_no = curl_easy_setopt(m_cp, CURLOPT_COPYPOSTFIELDS,
564 svalue.c_str());
565 #else
566 char *post = strndup(svalue.data(), svalue.size());
567 m_to_free->str.push_back(post);
568
569 m_error_no = curl_easy_setopt(m_cp, CURLOPT_POSTFIELDS, post);
570 m_error_no = curl_easy_setopt(m_cp, CURLOPT_POSTFIELDSIZE,
571 svalue.size());
572 #endif
573 }
574 break;
575 case CURLOPT_HTTPHEADER:
576 case CURLOPT_QUOTE:
577 case CURLOPT_HTTP200ALIASES:
578 case CURLOPT_POSTQUOTE:
579 if (value.is(KindOfArray) || value.is(KindOfObject)) {
580 Array arr = value.toArray();
581 curl_slist *slist = nullptr;
582 for (ArrayIter iter(arr); iter; ++iter) {
583 String key = iter.first().toString();
584 String val = iter.second().toString();
585
586 slist = curl_slist_append(slist, val.c_str());
587 if (!slist) {
588 raise_warning("Could not build curl_slist");
589 return false;
590 }
591 }
592
593 m_to_free->slist.push_back(slist);
594 m_error_no = curl_easy_setopt(m_cp, (CURLoption)option, slist);
595
596 } else {
597 raise_warning("You must pass either an object or an array with "
598 "the CURLOPT_HTTPHEADER, CURLOPT_QUOTE, "
599 "CURLOPT_HTTP200ALIASES and CURLOPT_POSTQUOTE "
600 "arguments");
601 return false;
602 }
603 break;
604
605 case CURLINFO_HEADER_OUT:
606 if (value.toInt64() == 1) {
607 curl_easy_setopt(m_cp, CURLOPT_DEBUGFUNCTION, curl_debug);
608 curl_easy_setopt(m_cp, CURLOPT_DEBUGDATA, (void *)this);
609 curl_easy_setopt(m_cp, CURLOPT_VERBOSE, 1);
610 } else {
611 curl_easy_setopt(m_cp, CURLOPT_DEBUGFUNCTION, nullptr);
612 curl_easy_setopt(m_cp, CURLOPT_DEBUGDATA, nullptr);
613 curl_easy_setopt(m_cp, CURLOPT_VERBOSE, 0);
614 }
615 break;
616
617 case CURLOPT_FB_TLS_VER_MAX:
618 {
619 int64_t val = value.toInt64();
620 if (value.isInteger() &&
621 (val == CURLOPT_FB_TLS_VER_MAX_1_0 ||
622 val == CURLOPT_FB_TLS_VER_MAX_1_1 ||
623 val == CURLOPT_FB_TLS_VER_MAX_NONE)) {
624 m_opts.set(int64_t(option), value);
625 } else {
626 raise_warning("You must pass CURLOPT_FB_TLS_VER_MAX_1_0, "
627 "CURLOPT_FB_TLS_VER_MAX_1_1 or "
628 "CURLOPT_FB_TLS_VER_MAX_NONE with "
629 "CURLOPT_FB_TLS_VER_MAX");
630 }
631 }
632 break;
633 case CURLOPT_FB_TLS_CIPHER_SPEC:
634 if (value.isString() && !value.toString().empty()) {
635 m_opts.set(int64_t(option), value);
636 } else {
637 raise_warning("CURLOPT_FB_TLS_CIPHER_SPEC requires a non-empty string");
638 }
639 break;
640
641 default:
642 m_error_no = CURLE_FAILED_INIT;
643 throw_invalid_argument("option: %ld", option);
644 break;
645 }
646
647 m_opts.set(int64_t(option), value);
648
649 return m_error_no == CURLE_OK;
650 }
651
652 Variant getOption(long option) {
653
654 if (option != 0) {
655 if (!m_opts.exists(int64_t(option))) {
656 return false;
657 }
658 return m_opts[int64_t(option)];
659 }
660
661 return m_opts;
662 }
663
664 static int curl_debug(CURL *cp, curl_infotype type, char *buf,
665 size_t buf_len, void *ctx) {
666 CurlResource *ch = (CurlResource *)ctx;
667 if (type == CURLINFO_HEADER_OUT && buf_len > 0) {
668 ch->m_header = String(buf, buf_len, CopyString);
669 }
670 return 0;
671 }
672
673 Variant do_callback(const Variant& cb, const Array& args) {
674 assert(!m_exception);
675 try {
676 return vm_call_user_func(cb, args);
677 } catch (Object &e) {
678 ObjectData *od = e.get();
679 od->incRefCount();
680 m_exception = od;
681 m_phpException = true;
682 } catch (Exception &e) {
683 m_exception = e.clone();
684 m_phpException = false;
685 }
686 return uninit_null();
687 }
688
689 static int curl_progress(void* p,
690 double dltotal, double dlnow,
691 double ultotal, double ulnow) {
692 assert(p);
693 CurlResource* curl = static_cast<CurlResource*>(p);
694
695 ArrayInit ai(5);
696 ai.set(Resource(curl));
697 ai.set(dltotal);
698 ai.set(dlnow);
699 ai.set(ultotal);
700 ai.set(ulnow);
701
702 Variant result = vm_call_user_func(
703 curl->m_progress_callback,
704 ai.toArray()
705 );
706 // Both PHP and libcurl are documented as return 0 to continue, non-zero
707 // to abort, however this is what Zend actually implements
708 return result.toInt64() == 0 ? 0 : 1;
709 }
710
711 static size_t curl_read(char *data, size_t size, size_t nmemb, void *ctx) {
712 CurlResource *ch = (CurlResource *)ctx;
713 ReadHandler *t = &ch->m_read;
714
715 int length = -1;
716 switch (t->method) {
717 case PHP_CURL_DIRECT:
718 if (!t->fp.isNull()) {
719 int data_size = size * nmemb;
720 String ret = t->fp->read(data_size);
721 length = ret.size();
722 if (length) {
723 memcpy(data, ret.data(), length);
724 }
725 }
726 break;
727 case PHP_CURL_USER:
728 {
729 int data_size = size * nmemb;
730 Variant ret = ch->do_callback(
731 t->callback, make_packed_array(Resource(ch), t->fp, data_size));
732 if (ret.isString()) {
733 String sret = ret.toString();
734 length = data_size < sret.size() ? data_size : sret.size();
735 memcpy(data, sret.data(), length);
736 }
737 break;
738 }
739 }
740 return length;
741 }
742
743 static size_t curl_write(char *data, size_t size, size_t nmemb, void *ctx) {
744 CurlResource *ch = (CurlResource *)ctx;
745 WriteHandler *t = &ch->m_write;
746 size_t length = size * nmemb;
747
748 switch (t->method) {
749 case PHP_CURL_STDOUT:
750 g_context->write(data, length);
751 break;
752 case PHP_CURL_FILE:
753 return t->fp->write(String(data, length, CopyString), length);
754 case PHP_CURL_RETURN:
755 if (length > 0) {
756 t->buf.append(data, (int)length);
757 }
758 break;
759 case PHP_CURL_USER:
760 {
761 Variant ret = ch->do_callback(
762 t->callback,
763 make_packed_array(Resource(ch), String(data, length, CopyString)));
764 length = ret.toInt64();
765 }
766 break;
767 }
768
769 return length;
770 }
771
772 static size_t curl_write_header(char *data, size_t size, size_t nmemb,
773 void *ctx) {
774 CurlResource *ch = (CurlResource *)ctx;
775 WriteHandler *t = &ch->m_write_header;
776 size_t length = size * nmemb;
777
778 switch (t->method) {
779 case PHP_CURL_STDOUT:
780 // Handle special case write when we're returning the entire transfer
781 if (ch->m_write.method == PHP_CURL_RETURN && length > 0) {
782 ch->m_write.buf.append(data, (int)length);
783 } else {
784 g_context->write(data, length);
785 }
786 break;
787 case PHP_CURL_FILE:
788 return t->fp->write(String(data, length, CopyString), length);
789 case PHP_CURL_USER:
790 {
791 Variant ret = ch->do_callback(
792 t->callback,
793 make_packed_array(Resource(ch), String(data, length, CopyString)));
794 length = ret.toInt64();
795 }
796 break;
797 case PHP_CURL_IGNORE:
798 return length;
799 default:
800 return (size_t)-1;
801 }
802
803 return length;
804 }
805
806 CURL *get(bool nullOkay = false) {
807 if (m_cp == nullptr && !nullOkay) {
808 throw NullPointerException();
809 }
810 return m_cp;
811 }
812
813 int getError() {
814 return m_error_no;
815 }
816
817 String getErrorString() {
818 return String(m_error_str, CopyString);
819 }
820
821 typedef enum {
822 CURLOPT_FB_TLS_VER_MAX = 2147482624,
823 CURLOPT_FB_TLS_VER_MAX_NONE = 2147482625,
824 CURLOPT_FB_TLS_VER_MAX_1_1 = 2147482626,
825 CURLOPT_FB_TLS_VER_MAX_1_0 = 2147482627,
826 CURLOPT_FB_TLS_CIPHER_SPEC = 2147482628
827 } fb_specific_options;
828
829 private:
830 CURL *m_cp;
831 void *m_exception;
832
833 char m_error_str[CURL_ERROR_SIZE + 1];
834 CURLcode m_error_no;
835
836 std::shared_ptr<ToFree> m_to_free;
837
838 String m_url;
839 String m_header;
840 Array m_opts;
841
842 WriteHandler m_write;
843 WriteHandler m_write_header;
844 ReadHandler m_read;
845 Variant m_progress_callback;
846
847 bool m_phpException;
848 bool m_emptyPost;
849
850 static CURLcode ssl_ctx_callback(CURL *curl, void *sslctx, void *parm);
851 };
852
853 void CurlResource::sweep() {
854 m_write.buf.release();
855 m_write_header.buf.release();
856 closeForSweep();
857 }
858
859 CURLcode CurlResource::ssl_ctx_callback(CURL *curl, void *sslctx, void *parm) {
860 // Set defaults from config.hdf
861 CURLcode r = curl_tls_workarounds_cb(curl, sslctx, parm);
862 if (r != CURLE_OK) {
863 return r;
864 }
865
866 // Convert params to proper types.
867 SSL_CTX* ctx = (SSL_CTX*)sslctx;
868 if (ctx == nullptr) {
869 raise_warning("supplied argument is not a valid SSL_CTX");
870 return CURLE_FAILED_INIT;
871 }
872 CurlResource* cp = (CurlResource*)parm;
873 if (cp == nullptr) {
874 raise_warning("supplied argument is not a valid cURL handle resource");
875 return CURLE_FAILED_INIT;
876 }
877
878 // Override cipher specs if necessary.
879 if (cp->m_opts.exists(int64_t(CURLOPT_FB_TLS_CIPHER_SPEC))) {
880 Variant untyped_value = cp->m_opts[int64_t(CURLOPT_FB_TLS_CIPHER_SPEC)];
881 if (untyped_value.isString() && !untyped_value.toString().empty()) {
882 SSL_CTX_set_cipher_list(ctx, untyped_value.toString().c_str());
883 } else {
884 raise_warning("CURLOPT_FB_TLS_CIPHER_SPEC requires a non-empty string");
885 }
886 }
887
888 // Override the maximum client TLS version if necessary.
889 if (cp->m_opts.exists(int64_t(CURLOPT_FB_TLS_VER_MAX))) {
890 // Get current options, unsetting the NO_TLSv1_* bits.
891 long cur_opts = SSL_CTX_get_options(ctx);
892 #ifdef SSL_OP_NO_TLSv1_1
893 cur_opts &= ~SSL_OP_NO_TLSv1_1;
894 #endif
895 #ifdef SSL_OP_NO_TLSv1_2
896 cur_opts &= ~SSL_OP_NO_TLSv1_2;
897 #endif
898 int64_t value = cp->m_opts[int64_t(CURLOPT_FB_TLS_VER_MAX)].toInt64();
899 if (value == CURLOPT_FB_TLS_VER_MAX_1_0) {
900 #if defined (SSL_OP_NO_TLSv1_1) && defined (SSL_OP_NO_TLSv1_2)
901 cur_opts |= SSL_OP_NO_TLSv1_1 | SSL_OP_NO_TLSv1_2;
902 #else
903 raise_notice("Requesting SSL_OP_NO_TLSv1_1, but this version of "
904 "SSL does not support that option");
905 #endif
906 } else if (value == CURLOPT_FB_TLS_VER_MAX_1_1) {
907 #ifdef SSL_OP_NO_TLSv1_2
908 cur_opts |= SSL_OP_NO_TLSv1_2;
909 #else
910 raise_notice("Requesting SSL_OP_NO_TLSv1_2, but this version of "
911 "SSL does not support that option");
912 #endif
913 } else if (value != CURLOPT_FB_TLS_VER_MAX_NONE) {
914 raise_notice("Invalid CURLOPT_FB_TLS_VER_MAX value");
915 }
916 SSL_CTX_set_options(ctx, cur_opts);
917 }
918
919 return CURLE_OK;
920 }
921
922 ///////////////////////////////////////////////////////////////////////////////
923
924 #define CHECK_RESOURCE(curl) \
925 CurlResource *curl = ch.getTyped<CurlResource>(true, true); \
926 if (curl == nullptr) { \
927 raise_warning("supplied argument is not a valid cURL handle resource"); \
928 return false; \
929 } \
930
931 Variant HHVM_FUNCTION(curl_init, const Variant& url /* = null_string */) {
932 if (url.isNull()) {
933 return NEWOBJ(CurlResource)(null_string);
934 } else {
935 return NEWOBJ(CurlResource)(url.toString());
936 }
937 }
938
939 Variant HHVM_FUNCTION(curl_copy_handle, const Resource& ch) {
940 CHECK_RESOURCE(curl);
941 return NEWOBJ(CurlResource)(curl);
942 }
943
944 const StaticString
945 s_version_number("version_number"),
946 s_age("age"),
947 s_features("features"),
948 s_ssl_version_number("ssl_version_number"),
949 s_version("version"),
950 s_host("host"),
951 s_ssl_version("ssl_version"),
952 s_libz_version("libz_version"),
953 s_protocols("protocols");
954
955 Variant HHVM_FUNCTION(curl_version, int uversion /* = k_CURLVERSION_NOW */) {
956 curl_version_info_data *d = curl_version_info((CURLversion)uversion);
957 if (d == nullptr) {
958 return false;
959 }
960
961 ArrayInit ret(9);
962 ret.set(s_version_number, (int)d->version_num);
963 ret.set(s_age, d->age);
964 ret.set(s_features, d->features);
965 ret.set(s_ssl_version_number, d->ssl_version_num);
966 ret.set(s_version, d->version);
967 ret.set(s_host, d->host);
968 ret.set(s_ssl_version, d->ssl_version);
969 ret.set(s_libz_version, d->libz_version);
970
971 // Add an array of protocols
972 char **p = (char **) d->protocols;
973 Array protocol_list;
974 while (*p != nullptr) {
975 protocol_list.append(String(*p++, CopyString));
976 }
977 ret.set(s_protocols, protocol_list);
978 return ret.create();
979 }
980
981 bool HHVM_FUNCTION(curl_setopt, const Resource& ch, int option, const Variant& value) {
982 CHECK_RESOURCE(curl);
983 return curl->setOption(option, value);
984 }
985
986 bool HHVM_FUNCTION(curl_setopt_array, const Resource& ch, const Array& options) {
987 CHECK_RESOURCE(curl);
988 for (ArrayIter iter(options); iter; ++iter) {
989 if (!curl->setOption(iter.first().toInt32(), iter.second())) {
990 return false;
991 }
992 }
993 return true;
994 }
995
996 Variant HHVM_FUNCTION(fb_curl_getopt, const Resource& ch, int64_t opt /* = 0 */) {
997 CHECK_RESOURCE(curl);
998 return curl->getOption(opt);
999 }
1000
1001 Variant HHVM_FUNCTION(curl_exec, const Resource& ch) {
1002 CHECK_RESOURCE(curl);
1003 return curl->execute();
1004 }
1005
1006 const StaticString
1007 s_url("url"),
1008 s_content_type("content_type"),
1009 s_http_code("http_code"),
1010 s_header_size("header_size"),
1011 s_request_size("request_size"),
1012 s_filetime("filetime"),
1013 s_ssl_verify_result("ssl_verify_result"),
1014 s_redirect_count("redirect_count"),
1015 s_local_port("local_port"),
1016 s_total_time("total_time"),
1017 s_namelookup_time("namelookup_time"),
1018 s_connect_time("connect_time"),
1019 s_pretransfer_time("pretransfer_time"),
1020 s_size_upload("size_upload"),
1021 s_size_download("size_download"),
1022 s_speed_download("speed_download"),
1023 s_speed_upload("speed_upload"),
1024 s_download_content_length("download_content_length"),
1025 s_upload_content_length("upload_content_length"),
1026 s_starttransfer_time("starttransfer_time"),
1027 s_redirect_time("redirect_time"),
1028 s_request_header("request_header");
1029
1030 Variant HHVM_FUNCTION(curl_getinfo, const Resource& ch, int opt /* = 0 */) {
1031 CHECK_RESOURCE(curl);
1032 CURL *cp = curl->get();
1033
1034 if (opt == 0) {
1035 char *s_code;
1036 long l_code;
1037 double d_code;
1038
1039 Array ret;
1040 if (curl_easy_getinfo(cp, CURLINFO_EFFECTIVE_URL, &s_code) == CURLE_OK) {
1041 ret.set(s_url, String(s_code, CopyString));
1042 }
1043 if (curl_easy_getinfo(cp, CURLINFO_CONTENT_TYPE, &s_code) == CURLE_OK) {
1044 if (s_code != nullptr) {
1045 ret.set(s_content_type, String(s_code, CopyString));
1046 } else {
1047 ret.set(s_content_type, uninit_null());
1048 }
1049 }
1050 if (curl_easy_getinfo(cp, CURLINFO_HTTP_CODE, &l_code) == CURLE_OK) {
1051 ret.set(s_http_code, l_code);
1052 }
1053 if (curl_easy_getinfo(cp, CURLINFO_HEADER_SIZE, &l_code) == CURLE_OK) {
1054 ret.set(s_header_size, l_code);
1055 }
1056 if (curl_easy_getinfo(cp, CURLINFO_REQUEST_SIZE, &l_code) == CURLE_OK) {
1057 ret.set(s_request_size, l_code);
1058 }
1059 if (curl_easy_getinfo(cp, CURLINFO_FILETIME, &l_code) == CURLE_OK) {
1060 ret.set(s_filetime, l_code);
1061 }
1062 if (curl_easy_getinfo(cp, CURLINFO_SSL_VERIFYRESULT, &l_code) ==
1063 CURLE_OK) {
1064 ret.set(s_ssl_verify_result, l_code);
1065 }
1066 if (curl_easy_getinfo(cp, CURLINFO_REDIRECT_COUNT, &l_code) == CURLE_OK) {
1067 ret.set(s_redirect_count, l_code);
1068 }
1069 #if LIBCURL_VERSION_NUM >= 0x071500
1070 if (curl_easy_getinfo(cp, CURLINFO_LOCAL_PORT, &l_code) == CURLE_OK) {
1071 ret.set(s_local_port, l_code);
1072 }
1073 #endif
1074 if (curl_easy_getinfo(cp, CURLINFO_TOTAL_TIME, &d_code) == CURLE_OK) {
1075 ret.set(s_total_time, d_code);
1076 }
1077 if (curl_easy_getinfo(cp, CURLINFO_NAMELOOKUP_TIME, &d_code) == CURLE_OK) {
1078 ret.set(s_namelookup_time, d_code);
1079 }
1080 if (curl_easy_getinfo(cp, CURLINFO_CONNECT_TIME, &d_code) == CURLE_OK) {
1081 ret.set(s_connect_time, d_code);
1082 }
1083 if (curl_easy_getinfo(cp, CURLINFO_PRETRANSFER_TIME, &d_code) ==
1084 CURLE_OK) {
1085 ret.set(s_pretransfer_time, d_code);
1086 }
1087 if (curl_easy_getinfo(cp, CURLINFO_SIZE_UPLOAD, &d_code) == CURLE_OK) {
1088 ret.set(s_size_upload, d_code);
1089 }
1090 if (curl_easy_getinfo(cp, CURLINFO_SIZE_DOWNLOAD, &d_code) == CURLE_OK) {
1091 ret.set(s_size_download, d_code);
1092 }
1093 if (curl_easy_getinfo(cp, CURLINFO_SPEED_DOWNLOAD, &d_code) == CURLE_OK) {
1094 ret.set(s_speed_download, d_code);
1095 }
1096 if (curl_easy_getinfo(cp, CURLINFO_SPEED_UPLOAD, &d_code) == CURLE_OK) {
1097 ret.set(s_speed_upload, d_code);
1098 }
1099 if (curl_easy_getinfo(cp, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &d_code) ==
1100 CURLE_OK) {
1101 ret.set(s_download_content_length, d_code);
1102 }
1103 if (curl_easy_getinfo(cp, CURLINFO_CONTENT_LENGTH_UPLOAD, &d_code) ==
1104 CURLE_OK) {
1105 ret.set(s_upload_content_length, d_code);
1106 }
1107 if (curl_easy_getinfo(cp, CURLINFO_STARTTRANSFER_TIME, &d_code) ==
1108 CURLE_OK) {
1109 ret.set(s_starttransfer_time, d_code);
1110 }
1111 if (curl_easy_getinfo(cp, CURLINFO_REDIRECT_TIME, &d_code) == CURLE_OK) {
1112 ret.set(s_redirect_time, d_code);
1113 }
1114 String header = curl->getHeader();
1115 if (!header.empty()) {
1116 ret.set(s_request_header, header);
1117 }
1118 return ret;
1119 }
1120
1121 switch (opt) {
1122 case CURLINFO_PRIVATE:
1123 case CURLINFO_EFFECTIVE_URL:
1124 case CURLINFO_CONTENT_TYPE: {
1125 char *s_code = nullptr;
1126 if (curl_easy_getinfo(cp, (CURLINFO)opt, &s_code) == CURLE_OK &&
1127 s_code) {
1128 return String(s_code, CopyString);
1129 }
1130 return false;
1131 }
1132 case CURLINFO_HTTP_CODE:
1133 case CURLINFO_HEADER_SIZE:
1134 case CURLINFO_REQUEST_SIZE:
1135 case CURLINFO_FILETIME:
1136 case CURLINFO_SSL_VERIFYRESULT:
1137 #if LIBCURL_VERSION_NUM >= 0x071500
1138 case CURLINFO_LOCAL_PORT:
1139 #endif
1140 case CURLINFO_REDIRECT_COUNT: {
1141 long code = 0;
1142 if (curl_easy_getinfo(cp, (CURLINFO)opt, &code) == CURLE_OK) {
1143 return code;
1144 }
1145 return false;
1146 }
1147 case CURLINFO_TOTAL_TIME:
1148 case CURLINFO_NAMELOOKUP_TIME:
1149 case CURLINFO_CONNECT_TIME:
1150 case CURLINFO_PRETRANSFER_TIME:
1151 case CURLINFO_SIZE_UPLOAD:
1152 case CURLINFO_SIZE_DOWNLOAD:
1153 case CURLINFO_SPEED_DOWNLOAD:
1154 case CURLINFO_SPEED_UPLOAD:
1155 case CURLINFO_CONTENT_LENGTH_DOWNLOAD:
1156 case CURLINFO_CONTENT_LENGTH_UPLOAD:
1157 case CURLINFO_STARTTRANSFER_TIME:
1158 case CURLINFO_REDIRECT_TIME: {
1159 double code = 0.0;
1160 if (curl_easy_getinfo(cp, (CURLINFO)opt, &code) == CURLE_OK) {
1161 return code;
1162 }
1163 return false;
1164 }
1165 case CURLINFO_HEADER_OUT:
1166 {
1167 String header = curl->getHeader();
1168 if (!header.empty()) {
1169 return header;
1170 }
1171 return false;
1172 }
1173 }
1174
1175 return uninit_null();
1176 }
1177
1178 Variant HHVM_FUNCTION(curl_errno, const Resource& ch) {
1179 CHECK_RESOURCE(curl);
1180 return curl->getError();
1181 }
1182
1183 Variant HHVM_FUNCTION(curl_error, const Resource& ch) {
1184 CHECK_RESOURCE(curl);
1185 return curl->getErrorString();
1186 }
1187
1188 Variant HHVM_FUNCTION(curl_close, const Resource& ch) {
1189 CHECK_RESOURCE(curl);
1190 curl->close();
1191 return uninit_null();
1192 }
1193
1194 ///////////////////////////////////////////////////////////////////////////////
1195
1196 class CurlMultiResource : public SweepableResourceData {
1197 public:
1198 DECLARE_RESOURCE_ALLOCATION(CurlMultiResource)
1199
1200 CLASSNAME_IS("cURL Multi Handle")
1201 // overriding ResourceData
1202 const String& o_getClassNameHook() const { return classnameof(); }
1203
1204 CurlMultiResource() {
1205 m_multi = curl_multi_init();
1206 }
1207
1208 ~CurlMultiResource() {
1209 close();
1210 }
1211
1212 void close() {
1213 if (m_multi) {
1214 curl_multi_cleanup(m_multi);
1215 m_easyh.clear();
1216 m_multi = nullptr;
1217 }
1218 }
1219
1220 void add(const Resource& ch) {
1221 m_easyh.append(ch);
1222 }
1223
1224 void remove(CurlResource *curle) {
1225 for (ArrayIter iter(m_easyh); iter; ++iter) {
1226 if (iter.second().toResource().getTyped<CurlResource>()->get(true) ==
1227 curle->get()) {
1228 m_easyh.remove(iter.first());
1229 return;
1230 }
1231 }
1232 }
1233
1234 Resource find(CURL *cp) {
1235 for (ArrayIter iter(m_easyh); iter; ++iter) {
1236 if (iter.second().toResource().
1237 getTyped<CurlResource>()->get(true) == cp) {
1238 return iter.second().toResource();
1239 }
1240 }
1241 return Resource();
1242 }
1243
1244 void check_exceptions() {
1245 ObjectData* phpException = 0;
1246 Exception* cppException = 0;
1247 for (ArrayIter iter(m_easyh); iter; ++iter) {
1248 CurlResource* curl = iter.second().toResource().getTyped<CurlResource>();
1249 if (ObjectData* e = curl->getAndClearPhpException()) {
1250 if (phpException) {
1251 e->o_set(s_previous, Variant(phpException), s_exception);
1252 phpException->decRefCount();
1253 }
1254 phpException = e;
1255 } else if (Exception *e = curl->getAndClearCppException()) {
1256 delete cppException;
1257 cppException = e;
1258 }
1259 }
1260 if (cppException) {
1261 if (phpException) decRefObj(phpException);
1262 cppException->throwException();
1263 }
1264 if (phpException) {
1265 Object e(phpException);
1266 phpException->decRefCount();
1267 throw e;
1268 }
1269 }
1270
1271 CURLM *get() {
1272 if (m_multi == nullptr) {
1273 throw NullPointerException();
1274 }
1275 return m_multi;
1276 }
1277
1278 private:
1279 CURLM *m_multi;
1280 Array m_easyh;
1281 };
1282
1283 void CurlMultiResource::sweep() {
1284 if (m_multi) {
1285 curl_multi_cleanup(m_multi);
1286 }
1287 }
1288
1289 ///////////////////////////////////////////////////////////////////////////////
1290
1291 #define CHECK_MULTI_RESOURCE(curlm) \
1292 CurlMultiResource *curlm = mh.getTyped<CurlMultiResource>(true, true); \
1293 if (curlm == nullptr) { \
1294 raise_warning("expects parameter 1 to be cURL multi resource"); \
1295 return uninit_null(); \
1296 } \
1297
1298 Resource HHVM_FUNCTION(curl_multi_init) {
1299 return NEWOBJ(CurlMultiResource)();
1300 }
1301
1302 Variant HHVM_FUNCTION(curl_multi_add_handle, const Resource& mh, const Resource& ch) {
1303 CHECK_MULTI_RESOURCE(curlm);
1304 CurlResource *curle = ch.getTyped<CurlResource>();
1305 curlm->add(ch);
1306 return curl_multi_add_handle(curlm->get(), curle->get());
1307 }
1308
1309 Variant HHVM_FUNCTION(curl_multi_remove_handle, const Resource& mh, const Resource& ch) {
1310 CHECK_MULTI_RESOURCE(curlm);
1311 CurlResource *curle = ch.getTyped<CurlResource>();
1312 curlm->remove(curle);
1313 return curl_multi_remove_handle(curlm->get(), curle->get());
1314 }
1315
1316 Variant HHVM_FUNCTION(curl_multi_exec, const Resource& mh, VRefParam still_running) {
1317 CHECK_MULTI_RESOURCE(curlm);
1318 int running = 0;
1319 IOStatusHelper io("curl_multi_exec");
1320 SYNC_VM_REGS_SCOPED();
1321 int result = curl_multi_perform(curlm->get(), &running);
1322 curlm->check_exceptions();
1323 still_running = running;
1324 return result;
1325 }
1326
1327 /* Fallback implementation of curl_multi_select() for
1328 * libcurl < 7.28.0 without FB's curl_multi_select() patch
1329 *
1330 * This allows the OSS build to work with older package
1331 * versions of libcurl, but will fail with file descriptors
1332 * over 1024.
1333 */
1334 UNUSED
1335 static void hphp_curl_multi_select(CURLM *mh, int timeout_ms, int *ret) {
1336 fd_set read_fds, write_fds, except_fds;
1337 int maxfds, nfds = -1;
1338 struct timeval tv;
1339
1340 FD_ZERO(&read_fds);
1341 FD_ZERO(&write_fds);
1342 FD_ZERO(&except_fds);
1343
1344 tv.tv_sec = timeout_ms / 1000;
1345 tv.tv_usec = (timeout_ms * 1000) % 1000000;
1346
1347 curl_multi_fdset(mh, &read_fds, &write_fds, &except_fds, &maxfds);
1348 if (maxfds < 1024) {
1349 nfds = select(maxfds + 1, &read_fds, &write_fds, &except_fds, &tv);
1350 } else {
1351 /* fd_set can only hold sockets from 0 to 1023,
1352 * anything higher is ignored by FD_SET()
1353 * avoid "unexplained" behavior by failing outright
1354 */
1355 raise_warning("libcurl versions < 7.28.0 do not support selecting on "
1356 "file descriptors of 1024 or higher.");
1357 }
1358 if (ret) {
1359 *ret = nfds;
1360 }
1361 }
1362
1363 #ifndef HAVE_CURL_MULTI_SELECT
1364 # ifdef HAVE_CURL_MULTI_WAIT
1365 # define curl_multi_select_func(mh, tm, ret) curl_multi_wait((mh), nullptr, 0, (tm), (ret))
1366 # else
1367 # define curl_multi_select_func hphp_curl_multi_select
1368 # endif
1369 #else
1370 #define curl_multi_select_func curl_multi_select
1371 #endif
1372
1373 Variant HHVM_FUNCTION(curl_multi_select, const Resource& mh,
1374 double timeout /* = 1.0 */) {
1375 CHECK_MULTI_RESOURCE(curlm);
1376 int ret;
1377 unsigned long timeout_ms = (unsigned long)(timeout * 1000.0);
1378 IOStatusHelper io("curl_multi_select");
1379 curl_multi_select_func(curlm->get(), timeout_ms, &ret);
1380 return ret;
1381 }
1382
1383 Variant HHVM_FUNCTION(curl_multi_getcontent, const Resource& ch) {
1384 CHECK_RESOURCE(curl);
1385 return curl->getContents();
1386 }
1387
1388 Array curl_convert_fd_to_stream(fd_set *fd, int max_fd) {
1389 Array ret = Array::Create();
1390 for (int i=0; i<=max_fd; i++) {
1391 if (FD_ISSET(i, fd)) {
1392 BuiltinFile *file = NEWOBJ(BuiltinFile)(i);
1393 ret.append(file);
1394 }
1395 }
1396 return ret;
1397 }
1398
1399 Variant HHVM_FUNCTION(fb_curl_multi_fdset, const Resource& mh,
1400 VRefParam read_fd_set,
1401 VRefParam write_fd_set,
1402 VRefParam exc_fd_set,
1403 VRefParam max_fd /* = null_object */) {
1404 CHECK_MULTI_RESOURCE(curlm);
1405
1406 fd_set read_set;
1407 fd_set write_set;
1408 fd_set exc_set;
1409 int max = 0;
1410
1411 FD_ZERO(&read_set);
1412 FD_ZERO(&write_set);
1413 FD_ZERO(&exc_set);
1414
1415 int r = curl_multi_fdset(curlm->get(), &read_set, &write_set, &exc_set, &max);
1416 read_fd_set = curl_convert_fd_to_stream(&read_set, max);
1417 write_fd_set = curl_convert_fd_to_stream(&write_set, max);
1418 exc_fd_set = curl_convert_fd_to_stream(&exc_set, max);
1419 max_fd = max;
1420
1421 return r;
1422 }
1423
1424 const StaticString
1425 s_msg("msg"),
1426 s_result("result"),
1427 s_handle("handle");
1428
1429 Variant HHVM_FUNCTION(curl_multi_info_read, const Resource& mh,
1430 VRefParam msgs_in_queue /* = null */) {
1431 CHECK_MULTI_RESOURCE(curlm);
1432
1433 int queued_msgs;
1434 CURLMsg *tmp_msg = curl_multi_info_read(curlm->get(), &queued_msgs);
1435 curlm->check_exceptions();
1436 if (tmp_msg == nullptr) {
1437 return false;
1438 }
1439 msgs_in_queue = queued_msgs;
1440
1441 Array ret;
1442 ret.set(s_msg, tmp_msg->msg);
1443 ret.set(s_result, tmp_msg->data.result);
1444 Resource curle = curlm->find(tmp_msg->easy_handle);
1445 if (!curle.isNull()) {
1446 ret.set(s_handle, curle);
1447 }
1448 return ret;
1449 }
1450
1451 Variant HHVM_FUNCTION(curl_multi_close, const Resource& mh) {
1452 CHECK_MULTI_RESOURCE(curlm);
1453 curlm->close();
1454 return uninit_null();
1455 }
1456
1457 ///////////////////////////////////////////////////////////////////////////////
1458
1459 #if LIBCURL_VERSION_NUM >= 0x071500
1460 const int64_t k_CURLINFO_LOCAL_PORT = CURLINFO_LOCAL_PORT;
1461 #endif
1462
1463 #if LIBCURL_VERSION_NUM >= 0x071002
1464 const int64_t k_CURLOPT_TIMEOUT_MS = CURLOPT_TIMEOUT_MS;
1465 const int64_t k_CURLOPT_CONNECTTIMEOUT_MS = CURLOPT_CONNECTTIMEOUT_MS;
1466 #endif
1467
1468 const int64_t k_CURLAUTH_ANY = CURLAUTH_ANY;
1469 const int64_t k_CURLAUTH_ANYSAFE = CURLAUTH_ANYSAFE;
1470 const int64_t k_CURLAUTH_BASIC = CURLAUTH_BASIC;
1471 const int64_t k_CURLAUTH_DIGEST = CURLAUTH_DIGEST;
1472 const int64_t k_CURLAUTH_GSSNEGOTIATE = CURLAUTH_GSSNEGOTIATE;
1473 const int64_t k_CURLAUTH_NTLM = CURLAUTH_NTLM;
1474 const int64_t k_CURLCLOSEPOLICY_CALLBACK = CURLCLOSEPOLICY_CALLBACK;
1475 const int64_t k_CURLCLOSEPOLICY_LEAST_RECENTLY_USED =
1476 CURLCLOSEPOLICY_LEAST_RECENTLY_USED;
1477 const int64_t k_CURLCLOSEPOLICY_LEAST_TRAFFIC = CURLCLOSEPOLICY_LEAST_TRAFFIC;
1478 const int64_t k_CURLCLOSEPOLICY_OLDEST = CURLCLOSEPOLICY_OLDEST;
1479 const int64_t k_CURLCLOSEPOLICY_SLOWEST = CURLCLOSEPOLICY_SLOWEST;
1480 const int64_t k_CURLE_ABORTED_BY_CALLBACK = CURLE_ABORTED_BY_CALLBACK;
1481 const int64_t k_CURLE_BAD_CALLING_ORDER = CURLE_BAD_CALLING_ORDER;
1482 const int64_t k_CURLE_BAD_CONTENT_ENCODING = CURLE_BAD_CONTENT_ENCODING;
1483 const int64_t k_CURLE_BAD_FUNCTION_ARGUMENT = CURLE_BAD_FUNCTION_ARGUMENT;
1484 const int64_t k_CURLE_BAD_PASSWORD_ENTERED = CURLE_BAD_PASSWORD_ENTERED;
1485 const int64_t k_CURLE_COULDNT_CONNECT = CURLE_COULDNT_CONNECT;
1486 const int64_t k_CURLE_COULDNT_RESOLVE_HOST = CURLE_COULDNT_RESOLVE_HOST;
1487 const int64_t k_CURLE_COULDNT_RESOLVE_PROXY = CURLE_COULDNT_RESOLVE_PROXY;
1488 const int64_t k_CURLE_FAILED_INIT = CURLE_FAILED_INIT;
1489 const int64_t k_CURLE_FILESIZE_EXCEEDED = CURLE_FILESIZE_EXCEEDED;
1490 const int64_t k_CURLE_FILE_COULDNT_READ_FILE = CURLE_FILE_COULDNT_READ_FILE;
1491 const int64_t k_CURLE_FTP_ACCESS_DENIED = CURLE_FTP_ACCESS_DENIED;
1492 const int64_t k_CURLE_FTP_BAD_DOWNLOAD_RESUME = CURLE_FTP_BAD_DOWNLOAD_RESUME;
1493 const int64_t k_CURLE_FTP_CANT_GET_HOST = CURLE_FTP_CANT_GET_HOST;
1494 const int64_t k_CURLE_FTP_CANT_RECONNECT = CURLE_FTP_CANT_RECONNECT;
1495 const int64_t k_CURLE_FTP_COULDNT_GET_SIZE = CURLE_FTP_COULDNT_GET_SIZE;
1496 const int64_t k_CURLE_FTP_COULDNT_RETR_FILE = CURLE_FTP_COULDNT_RETR_FILE;
1497 const int64_t k_CURLE_FTP_COULDNT_SET_ASCII = CURLE_FTP_COULDNT_SET_ASCII;
1498 const int64_t k_CURLE_FTP_COULDNT_SET_BINARY = CURLE_FTP_COULDNT_SET_BINARY;
1499 const int64_t k_CURLE_FTP_COULDNT_STOR_FILE = CURLE_FTP_COULDNT_STOR_FILE;
1500 const int64_t k_CURLE_FTP_COULDNT_USE_REST = CURLE_FTP_COULDNT_USE_REST;
1501 const int64_t k_CURLE_FTP_PORT_FAILED = CURLE_FTP_PORT_FAILED;
1502 const int64_t k_CURLE_FTP_QUOTE_ERROR = CURLE_FTP_QUOTE_ERROR;
1503 const int64_t k_CURLE_FTP_SSL_FAILED = CURLE_FTP_SSL_FAILED;
1504 const int64_t k_CURLE_FTP_USER_PASSWORD_INCORRECT =
1505 CURLE_FTP_USER_PASSWORD_INCORRECT;
1506 const int64_t k_CURLE_FTP_WEIRD_227_FORMAT = CURLE_FTP_WEIRD_227_FORMAT;
1507 const int64_t k_CURLE_FTP_WEIRD_PASS_REPLY = CURLE_FTP_WEIRD_PASS_REPLY;
1508 const int64_t k_CURLE_FTP_WEIRD_PASV_REPLY = CURLE_FTP_WEIRD_PASV_REPLY;
1509 const int64_t k_CURLE_FTP_WEIRD_SERVER_REPLY = CURLE_FTP_WEIRD_SERVER_REPLY;
1510 const int64_t k_CURLE_FTP_WEIRD_USER_REPLY = CURLE_FTP_WEIRD_USER_REPLY;
1511 const int64_t k_CURLE_FTP_WRITE_ERROR = CURLE_FTP_WRITE_ERROR;
1512 const int64_t k_CURLE_FUNCTION_NOT_FOUND = CURLE_FUNCTION_NOT_FOUND;
1513 const int64_t k_CURLE_GOT_NOTHING = CURLE_GOT_NOTHING;
1514 const int64_t k_CURLE_HTTP_NOT_FOUND = CURLE_HTTP_NOT_FOUND;
1515 const int64_t k_CURLE_HTTP_PORT_FAILED = CURLE_HTTP_PORT_FAILED;
1516 const int64_t k_CURLE_HTTP_POST_ERROR = CURLE_HTTP_POST_ERROR;
1517 const int64_t k_CURLE_HTTP_RANGE_ERROR = CURLE_HTTP_RANGE_ERROR;
1518 const int64_t k_CURLE_LDAP_CANNOT_BIND = CURLE_LDAP_CANNOT_BIND;
1519 const int64_t k_CURLE_LDAP_INVALID_URL = CURLE_LDAP_INVALID_URL;
1520 const int64_t k_CURLE_LDAP_SEARCH_FAILED = CURLE_LDAP_SEARCH_FAILED;
1521 const int64_t k_CURLE_LIBRARY_NOT_FOUND = CURLE_LIBRARY_NOT_FOUND;
1522 const int64_t k_CURLE_MALFORMAT_USER = CURLE_MALFORMAT_USER;
1523 const int64_t k_CURLE_OBSOLETE = CURLE_OBSOLETE;
1524 const int64_t k_CURLE_OK = CURLE_OK;
1525 const int64_t k_CURLE_OPERATION_TIMEOUTED = CURLE_OPERATION_TIMEOUTED;
1526 const int64_t k_CURLE_OUT_OF_MEMORY = CURLE_OUT_OF_MEMORY;
1527 const int64_t k_CURLE_PARTIAL_FILE = CURLE_PARTIAL_FILE;
1528 const int64_t k_CURLE_READ_ERROR = CURLE_READ_ERROR;
1529 const int64_t k_CURLE_RECV_ERROR = CURLE_RECV_ERROR;
1530 const int64_t k_CURLE_SEND_ERROR = CURLE_SEND_ERROR;
1531 const int64_t k_CURLE_SHARE_IN_USE = CURLE_SHARE_IN_USE;
1532 const int64_t k_CURLE_SSL_CACERT = CURLE_SSL_CACERT;
1533 const int64_t k_CURLE_SSL_CERTPROBLEM = CURLE_SSL_CERTPROBLEM;
1534 const int64_t k_CURLE_SSL_CIPHER = CURLE_SSL_CIPHER;
1535 const int64_t k_CURLE_SSL_CONNECT_ERROR = CURLE_SSL_CONNECT_ERROR;
1536 const int64_t k_CURLE_SSL_ENGINE_NOTFOUND = CURLE_SSL_ENGINE_NOTFOUND;
1537 const int64_t k_CURLE_SSL_ENGINE_SETFAILED = CURLE_SSL_ENGINE_SETFAILED;
1538 const int64_t k_CURLE_SSL_PEER_CERTIFICATE = CURLE_SSL_PEER_CERTIFICATE;
1539 const int64_t k_CURLE_TELNET_OPTION_SYNTAX = CURLE_TELNET_OPTION_SYNTAX;
1540 const int64_t k_CURLE_TOO_MANY_REDIRECTS = CURLE_TOO_MANY_REDIRECTS;
1541 const int64_t k_CURLE_UNKNOWN_TELNET_OPTION = CURLE_UNKNOWN_TELNET_OPTION;
1542 const int64_t k_CURLE_UNSUPPORTED_PROTOCOL = CURLE_UNSUPPORTED_PROTOCOL;
1543 const int64_t k_CURLE_URL_MALFORMAT = CURLE_URL_MALFORMAT;
1544 const int64_t k_CURLE_URL_MALFORMAT_USER = CURLE_URL_MALFORMAT_USER;
1545 const int64_t k_CURLE_WRITE_ERROR = CURLE_WRITE_ERROR;
1546 const int64_t k_CURLFTPAUTH_DEFAULT = CURLFTPAUTH_DEFAULT;
1547 const int64_t k_CURLFTPAUTH_SSL = CURLFTPAUTH_SSL;
1548 const int64_t k_CURLFTPAUTH_TLS = CURLFTPAUTH_TLS;
1549 const int64_t k_CURLFTPSSL_ALL = CURLFTPSSL_ALL;
1550 const int64_t k_CURLFTPSSL_CONTROL = CURLFTPSSL_CONTROL;
1551 const int64_t k_CURLFTPSSL_NONE = CURLFTPSSL_NONE;
1552 const int64_t k_CURLFTPSSL_TRY = CURLFTPSSL_TRY;
1553 const int64_t k_CURLINFO_CONNECT_TIME = CURLINFO_CONNECT_TIME;
1554 const int64_t k_CURLINFO_CONTENT_LENGTH_DOWNLOAD =
1555 CURLINFO_CONTENT_LENGTH_DOWNLOAD;
1556 const int64_t k_CURLINFO_CONTENT_LENGTH_UPLOAD = CURLINFO_CONTENT_LENGTH_UPLOAD;
1557 const int64_t k_CURLINFO_CONTENT_TYPE = CURLINFO_CONTENT_TYPE;
1558 const int64_t k_CURLINFO_EFFECTIVE_URL = CURLINFO_EFFECTIVE_URL;
1559 const int64_t k_CURLINFO_FILETIME = CURLINFO_FILETIME;
1560 const int64_t k_CURLINFO_HEADER_OUT = CURLINFO_HEADER_OUT;
1561 const int64_t k_CURLINFO_HEADER_SIZE = CURLINFO_HEADER_SIZE;
1562 const int64_t k_CURLINFO_HTTP_CODE = CURLINFO_HTTP_CODE;
1563 const int64_t k_CURLINFO_NAMELOOKUP_TIME = CURLINFO_NAMELOOKUP_TIME;
1564 const int64_t k_CURLINFO_PRETRANSFER_TIME = CURLINFO_PRETRANSFER_TIME;
1565 const int64_t k_CURLINFO_PRIVATE = CURLINFO_PRIVATE;
1566 const int64_t k_CURLINFO_REDIRECT_COUNT = CURLINFO_REDIRECT_COUNT;
1567 const int64_t k_CURLINFO_REDIRECT_TIME = CURLINFO_REDIRECT_TIME;
1568 const int64_t k_CURLINFO_REQUEST_SIZE = CURLINFO_REQUEST_SIZE;
1569 const int64_t k_CURLINFO_SIZE_DOWNLOAD = CURLINFO_SIZE_DOWNLOAD;
1570 const int64_t k_CURLINFO_SIZE_UPLOAD = CURLINFO_SIZE_UPLOAD;
1571 const int64_t k_CURLINFO_SPEED_DOWNLOAD = CURLINFO_SPEED_DOWNLOAD;
1572 const int64_t k_CURLINFO_SPEED_UPLOAD = CURLINFO_SPEED_UPLOAD;
1573 const int64_t k_CURLINFO_SSL_VERIFYRESULT = CURLINFO_SSL_VERIFYRESULT;
1574 const int64_t k_CURLINFO_STARTTRANSFER_TIME = CURLINFO_STARTTRANSFER_TIME;
1575 const int64_t k_CURLINFO_TOTAL_TIME = CURLINFO_TOTAL_TIME;
1576 const int64_t k_CURLMSG_DONE = CURLMSG_DONE;
1577 const int64_t k_CURLM_BAD_EASY_HANDLE = CURLM_BAD_EASY_HANDLE;
1578 const int64_t k_CURLM_BAD_HANDLE = CURLM_BAD_HANDLE;
1579 const int64_t k_CURLM_CALL_MULTI_PERFORM = CURLM_CALL_MULTI_PERFORM;
1580 const int64_t k_CURLM_INTERNAL_ERROR = CURLM_INTERNAL_ERROR;
1581 const int64_t k_CURLM_OK = CURLM_OK;
1582 const int64_t k_CURLM_OUT_OF_MEMORY = CURLM_OUT_OF_MEMORY;
1583 const int64_t k_CURLOPT_AUTOREFERER = CURLOPT_AUTOREFERER;
1584 const int64_t k_CURLOPT_BINARYTRANSFER = CURLOPT_BINARYTRANSFER;
1585 const int64_t k_CURLOPT_BUFFERSIZE = CURLOPT_BUFFERSIZE;
1586 const int64_t k_CURLOPT_CAINFO = CURLOPT_CAINFO;
1587 const int64_t k_CURLOPT_CAPATH = CURLOPT_CAPATH;
1588 const int64_t k_CURLOPT_CLOSEPOLICY = CURLOPT_CLOSEPOLICY;
1589 const int64_t k_CURLOPT_CONNECTTIMEOUT = CURLOPT_CONNECTTIMEOUT;
1590 const int64_t k_CURLOPT_COOKIE = CURLOPT_COOKIE;
1591 const int64_t k_CURLOPT_COOKIEFILE = CURLOPT_COOKIEFILE;
1592 const int64_t k_CURLOPT_COOKIEJAR = CURLOPT_COOKIEJAR;
1593 const int64_t k_CURLOPT_COOKIESESSION = CURLOPT_COOKIESESSION;
1594 const int64_t k_CURLOPT_CRLF = CURLOPT_CRLF;
1595 const int64_t k_CURLOPT_CUSTOMREQUEST = CURLOPT_CUSTOMREQUEST;
1596 const int64_t k_CURLOPT_DNS_CACHE_TIMEOUT = CURLOPT_DNS_CACHE_TIMEOUT;
1597 const int64_t k_CURLOPT_DNS_USE_GLOBAL_CACHE = CURLOPT_DNS_USE_GLOBAL_CACHE;
1598 const int64_t k_CURLOPT_EGDSOCKET = CURLOPT_EGDSOCKET;
1599 const int64_t k_CURLOPT_ENCODING = CURLOPT_ENCODING;
1600 const int64_t k_CURLOPT_FAILONERROR = CURLOPT_FAILONERROR;
1601 const int64_t k_CURLOPT_FILE = CURLOPT_FILE;
1602 const int64_t k_CURLOPT_FILETIME = CURLOPT_FILETIME;
1603 const int64_t k_CURLOPT_FOLLOWLOCATION = CURLOPT_FOLLOWLOCATION;
1604 const int64_t k_CURLOPT_FORBID_REUSE = CURLOPT_FORBID_REUSE;
1605 const int64_t k_CURLOPT_FRESH_CONNECT = CURLOPT_FRESH_CONNECT;
1606 const int64_t k_CURLOPT_FTPAPPEND = CURLOPT_FTPAPPEND;
1607 const int64_t k_CURLOPT_FTPLISTONLY = CURLOPT_FTPLISTONLY;
1608 const int64_t k_CURLOPT_FTPPORT = CURLOPT_FTPPORT;
1609 const int64_t k_CURLOPT_FTPSSLAUTH = CURLOPT_FTPSSLAUTH;
1610 const int64_t k_CURLOPT_FTP_CREATE_MISSING_DIRS =
1611 CURLOPT_FTP_CREATE_MISSING_DIRS;
1612 const int64_t k_CURLOPT_FTP_SSL = CURLOPT_FTP_SSL;
1613 const int64_t k_CURLOPT_FTP_USE_EPRT = CURLOPT_FTP_USE_EPRT;
1614 const int64_t k_CURLOPT_FTP_USE_EPSV = CURLOPT_FTP_USE_EPSV;
1615 const int64_t k_CURLOPT_HEADER = CURLOPT_HEADER;
1616 const int64_t k_CURLOPT_HEADERFUNCTION = CURLOPT_HEADERFUNCTION;
1617 const int64_t k_CURLOPT_HTTP200ALIASES = CURLOPT_HTTP200ALIASES;
1618 const int64_t k_CURLOPT_HTTPAUTH = CURLOPT_HTTPAUTH;
1619 const int64_t k_CURLOPT_HTTPGET = CURLOPT_HTTPGET;
1620 const int64_t k_CURLOPT_HTTPHEADER = CURLOPT_HTTPHEADER;
1621 const int64_t k_CURLOPT_HTTPPROXYTUNNEL = CURLOPT_HTTPPROXYTUNNEL;
1622 const int64_t k_CURLOPT_HTTP_VERSION = CURLOPT_HTTP_VERSION;
1623 const int64_t k_CURLOPT_INFILE = CURLOPT_INFILE;
1624 const int64_t k_CURLOPT_INFILESIZE = CURLOPT_INFILESIZE;
1625 const int64_t k_CURLOPT_INTERFACE = CURLOPT_INTERFACE;
1626 const int64_t k_CURLOPT_IPRESOLVE = CURLOPT_IPRESOLVE;
1627 const int64_t k_CURLOPT_KRB4LEVEL = CURLOPT_KRB4LEVEL;
1628 const int64_t k_CURLOPT_LOW_SPEED_LIMIT = CURLOPT_LOW_SPEED_LIMIT;
1629 const int64_t k_CURLOPT_LOW_SPEED_TIME = CURLOPT_LOW_SPEED_TIME;
1630 const int64_t k_CURLOPT_MAXCONNECTS = CURLOPT_MAXCONNECTS;
1631 const int64_t k_CURLOPT_MAXREDIRS = CURLOPT_MAXREDIRS;
1632 const int64_t k_CURLOPT_MUTE = CURLOPT_MUTE;
1633 const int64_t k_CURLOPT_NETRC = CURLOPT_NETRC;
1634 const int64_t k_CURLOPT_NOBODY = CURLOPT_NOBODY;
1635 const int64_t k_CURLOPT_NOPROGRESS = CURLOPT_NOPROGRESS;
1636 const int64_t k_CURLOPT_NOSIGNAL = CURLOPT_NOSIGNAL;
1637 const int64_t k_CURLOPT_PASSWDFUNCTION = CURLOPT_PASSWDFUNCTION;
1638 const int64_t k_CURLOPT_PORT = CURLOPT_PORT;
1639 const int64_t k_CURLOPT_POST = CURLOPT_POST;
1640 const int64_t k_CURLOPT_POSTFIELDS = CURLOPT_POSTFIELDS;
1641 const int64_t k_CURLOPT_POSTREDIR = CURLOPT_POSTREDIR;
1642 const int64_t k_CURLOPT_POSTQUOTE = CURLOPT_POSTQUOTE;
1643 const int64_t k_CURLOPT_PRIVATE = CURLOPT_PRIVATE;
1644 const int64_t k_CURLOPT_PROGRESSDATA = CURLOPT_PROGRESSDATA;
1645 const int64_t k_CURLOPT_PROGRESSFUNCTION = CURLOPT_PROGRESSFUNCTION;
1646 const int64_t k_CURLOPT_PROXY = CURLOPT_PROXY;
1647 const int64_t k_CURLOPT_PROXYAUTH = CURLOPT_PROXYAUTH;
1648 const int64_t k_CURLOPT_PROXYPORT = CURLOPT_PROXYPORT;
1649 const int64_t k_CURLOPT_PROXYTYPE = CURLOPT_PROXYTYPE;
1650 const int64_t k_CURLOPT_PROXYUSERPWD = CURLOPT_PROXYUSERPWD;
1651 const int64_t k_CURLOPT_PUT = CURLOPT_PUT;
1652 const int64_t k_CURLOPT_QUOTE = CURLOPT_QUOTE;
1653 const int64_t k_CURLOPT_RANDOM_FILE = CURLOPT_RANDOM_FILE;
1654 const int64_t k_CURLOPT_RANGE = CURLOPT_RANGE;
1655 const int64_t k_CURLOPT_READDATA = CURLOPT_READDATA;
1656 const int64_t k_CURLOPT_READFUNCTION = CURLOPT_READFUNCTION;
1657 const int64_t k_CURLOPT_REFERER = CURLOPT_REFERER;
1658 const int64_t k_CURLOPT_RESUME_FROM = CURLOPT_RESUME_FROM;
1659 const int64_t k_CURLOPT_RETURNTRANSFER = CURLOPT_RETURNTRANSFER;
1660 const int64_t k_CURLOPT_SSLCERT = CURLOPT_SSLCERT;
1661 const int64_t k_CURLOPT_SSLCERTPASSWD = CURLOPT_SSLCERTPASSWD;
1662 const int64_t k_CURLOPT_SSLCERTTYPE = CURLOPT_SSLCERTTYPE;
1663 const int64_t k_CURLOPT_SSLENGINE = CURLOPT_SSLENGINE;
1664 const int64_t k_CURLOPT_SSLENGINE_DEFAULT = CURLOPT_SSLENGINE_DEFAULT;
1665 const int64_t k_CURLOPT_SSLKEY = CURLOPT_SSLKEY;
1666 const int64_t k_CURLOPT_SSLKEYPASSWD = CURLOPT_SSLKEYPASSWD;
1667 const int64_t k_CURLOPT_SSLKEYTYPE = CURLOPT_SSLKEYTYPE;
1668 const int64_t k_CURLOPT_SSLVERSION = CURLOPT_SSLVERSION;
1669 const int64_t k_CURLOPT_SSL_CIPHER_LIST = CURLOPT_SSL_CIPHER_LIST;
1670 const int64_t k_CURLOPT_SSL_VERIFYHOST = CURLOPT_SSL_VERIFYHOST;
1671 const int64_t k_CURLOPT_SSL_VERIFYPEER = CURLOPT_SSL_VERIFYPEER;
1672 const int64_t k_CURLOPT_STDERR = CURLOPT_STDERR;
1673 const int64_t k_CURLOPT_TCP_NODELAY = CURLOPT_TCP_NODELAY;
1674 const int64_t k_CURLOPT_TIMECONDITION = CURLOPT_TIMECONDITION;
1675 const int64_t k_CURLOPT_TIMEOUT = CURLOPT_TIMEOUT;
1676 const int64_t k_CURLOPT_TIMEVALUE = CURLOPT_TIMEVALUE;
1677 const int64_t k_CURLOPT_TRANSFERTEXT = CURLOPT_TRANSFERTEXT;
1678 const int64_t k_CURLOPT_UNRESTRICTED_AUTH = CURLOPT_UNRESTRICTED_AUTH;
1679 const int64_t k_CURLOPT_UPLOAD = CURLOPT_UPLOAD;
1680 const int64_t k_CURLOPT_URL = CURLOPT_URL;
1681 const int64_t k_CURLOPT_USERAGENT = CURLOPT_USERAGENT;
1682 const int64_t k_CURLOPT_USERPWD = CURLOPT_USERPWD;
1683 const int64_t k_CURLOPT_VERBOSE = CURLOPT_VERBOSE;
1684 const int64_t k_CURLOPT_WRITEFUNCTION = CURLOPT_WRITEFUNCTION;
1685 const int64_t k_CURLOPT_WRITEHEADER = CURLOPT_WRITEHEADER;
1686 const int64_t k_CURLOPT_FB_TLS_VER_MAX =
1687 CurlResource::fb_specific_options::CURLOPT_FB_TLS_VER_MAX;
1688 const int64_t k_CURLOPT_FB_TLS_VER_MAX_NONE =
1689 CurlResource::fb_specific_options::CURLOPT_FB_TLS_VER_MAX_NONE;
1690 const int64_t k_CURLOPT_FB_TLS_VER_MAX_1_1 =
1691 CurlResource::fb_specific_options::CURLOPT_FB_TLS_VER_MAX_1_1;
1692 const int64_t k_CURLOPT_FB_TLS_VER_MAX_1_0 =
1693 CurlResource::fb_specific_options::CURLOPT_FB_TLS_VER_MAX_1_0;
1694 const int64_t k_CURLOPT_FB_TLS_CIPHER_SPEC =
1695 CurlResource::fb_specific_options::CURLOPT_FB_TLS_CIPHER_SPEC;
1696 const int64_t k_CURLPROXY_HTTP = CURLPROXY_HTTP;
1697 const int64_t k_CURLPROXY_SOCKS5 = CURLPROXY_SOCKS5;
1698 const int64_t k_CURLVERSION_NOW = CURLVERSION_NOW;
1699 const int64_t k_CURL_HTTP_VERSION_1_0 = CURL_HTTP_VERSION_1_0;
1700 const int64_t k_CURL_HTTP_VERSION_1_1 = CURL_HTTP_VERSION_1_1;
1701 const int64_t k_CURL_HTTP_VERSION_NONE = CURL_HTTP_VERSION_NONE;
1702 const int64_t k_CURL_IPRESOLVE_V4 = CURL_IPRESOLVE_V4;
1703 const int64_t k_CURL_IPRESOLVE_V6 = CURL_IPRESOLVE_V6;
1704 const int64_t k_CURL_IPRESOLVE_WHATEVER = CURL_IPRESOLVE_WHATEVER;
1705 const int64_t k_CURL_NETRC_IGNORED = CURL_NETRC_IGNORED;
1706 const int64_t k_CURL_NETRC_OPTIONAL = CURL_NETRC_OPTIONAL;
1707 const int64_t k_CURL_NETRC_REQUIRED = CURL_NETRC_REQUIRED;
1708 const int64_t k_CURL_TIMECOND_IFMODSINCE = CURL_TIMECOND_IFMODSINCE;
1709 const int64_t k_CURL_TIMECOND_IFUNMODSINCE = CURL_TIMECOND_IFUNMODSINCE;
1710 const int64_t k_CURL_TIMECOND_LASTMOD = CURL_TIMECOND_LASTMOD;
1711 const int64_t k_CURL_VERSION_IPV6 = CURL_VERSION_IPV6;
1712 const int64_t k_CURL_VERSION_KERBEROS4 = CURL_VERSION_KERBEROS4;
1713 const int64_t k_CURL_VERSION_LIBZ = CURL_VERSION_LIBZ;
1714 const int64_t k_CURL_VERSION_SSL = CURL_VERSION_SSL;
1715
1716 ///////////////////////////////////////////////////////////////////////////////
1717
1718 #if LIBCURL_VERSION_NUM >= 0x071500
1719 const StaticString s_CURLINFO_LOCAL_PORT("CURLINFO_LOCAL_PORT");
1720 #endif
1721 #if LIBCURL_VERSION_NUM >= 0x071002
1722 const StaticString s_CURLOPT_TIMEOUT_MS("CURLOPT_TIMEOUT_MS");
1723 const StaticString s_CURLOPT_CONNECTTIMEOUT_MS("CURLOPT_CONNECTTIMEOUT_MS");
1724 #endif
1725 const StaticString s_CURLAUTH_ANY("CURLAUTH_ANY");
1726 const StaticString s_CURLAUTH_ANYSAFE("CURLAUTH_ANYSAFE");
1727 const StaticString s_CURLAUTH_BASIC("CURLAUTH_BASIC");
1728 const StaticString s_CURLAUTH_DIGEST("CURLAUTH_DIGEST");
1729 const StaticString s_CURLAUTH_GSSNEGOTIATE("CURLAUTH_GSSNEGOTIATE");
1730 const StaticString s_CURLAUTH_NTLM("CURLAUTH_NTLM");
1731 const StaticString s_CURLCLOSEPOLICY_CALLBACK("CURLCLOSEPOLICY_CALLBACK");
1732 const StaticString
1733 s_CURLCLOSEPOLICY_LEAST_RECENTLY_USED("CURLCLOSEPOLICY_LEAST_RECENTLY_USED");
1734 const StaticString
1735 s_CURLCLOSEPOLICY_LEAST_TRAFFIC("CURLCLOSEPOLICY_LEAST_TRAFFIC");
1736 const StaticString s_CURLCLOSEPOLICY_OLDEST("CURLCLOSEPOLICY_OLDEST");
1737 const StaticString s_CURLCLOSEPOLICY_SLOWEST("CURLCLOSEPOLICY_SLOWEST");
1738 const StaticString s_CURLE_ABORTED_BY_CALLBACK("CURLE_ABORTED_BY_CALLBACK");
1739 const StaticString s_CURLE_BAD_CALLING_ORDER("CURLE_BAD_CALLING_ORDER");
1740 const StaticString s_CURLE_BAD_CONTENT_ENCODING("CURLE_BAD_CONTENT_ENCODING");
1741 const StaticString s_CURLE_BAD_FUNCTION_ARGUMENT("CURLE_BAD_FUNCTION_ARGUMENT");
1742 const StaticString s_CURLE_BAD_PASSWORD_ENTERED("CURLE_BAD_PASSWORD_ENTERED");
1743 const StaticString s_CURLE_COULDNT_CONNECT("CURLE_COULDNT_CONNECT");
1744 const StaticString s_CURLE_COULDNT_RESOLVE_HOST("CURLE_COULDNT_RESOLVE_HOST");
1745 const StaticString s_CURLE_COULDNT_RESOLVE_PROXY("CURLE_COULDNT_RESOLVE_PROXY");
1746 const StaticString s_CURLE_FAILED_INIT("CURLE_FAILED_INIT");
1747 const StaticString s_CURLE_FILESIZE_EXCEEDED("CURLE_FILESIZE_EXCEEDED");
1748 const StaticString
1749 s_CURLE_FILE_COULDNT_READ_FILE("CURLE_FILE_COULDNT_READ_FILE");
1750 const StaticString s_CURLE_FTP_ACCESS_DENIED("CURLE_FTP_ACCESS_DENIED");
1751 const StaticString
1752 s_CURLE_FTP_BAD_DOWNLOAD_RESUME("CURLE_FTP_BAD_DOWNLOAD_RESUME");
1753 const StaticString s_CURLE_FTP_CANT_GET_HOST("CURLE_FTP_CANT_GET_HOST");
1754 const StaticString s_CURLE_FTP_CANT_RECONNECT("CURLE_FTP_CANT_RECONNECT");
1755 const StaticString s_CURLE_FTP_COULDNT_GET_SIZE("CURLE_FTP_COULDNT_GET_SIZE");
1756 const StaticString s_CURLE_FTP_COULDNT_RETR_FILE("CURLE_FTP_COULDNT_RETR_FILE");
1757 const StaticString s_CURLE_FTP_COULDNT_SET_ASCII("CURLE_FTP_COULDNT_SET_ASCII");
1758 const StaticString
1759 s_CURLE_FTP_COULDNT_SET_BINARY("CURLE_FTP_COULDNT_SET_BINARY");
1760 const StaticString s_CURLE_FTP_COULDNT_STOR_FILE("CURLE_FTP_COULDNT_STOR_FILE");
1761 const StaticString s_CURLE_FTP_COULDNT_USE_REST("CURLE_FTP_COULDNT_USE_REST");
1762 const StaticString s_CURLE_FTP_PORT_FAILED("CURLE_FTP_PORT_FAILED");
1763 const StaticString s_CURLE_FTP_QUOTE_ERROR("CURLE_FTP_QUOTE_ERROR");
1764 const StaticString s_CURLE_FTP_SSL_FAILED("CURLE_FTP_SSL_FAILED");
1765 const StaticString
1766 s_CURLE_FTP_USER_PASSWORD_INCORRECT("CURLE_FTP_USER_PASSWORD_INCORRECT");
1767 const StaticString s_CURLE_FTP_WEIRD_227_FORMAT("CURLE_FTP_WEIRD_227_FORMAT");
1768 const StaticString s_CURLE_FTP_WEIRD_PASS_REPLY("CURLE_FTP_WEIRD_PASS_REPLY");
1769 const StaticString s_CURLE_FTP_WEIRD_PASV_REPLY("CURLE_FTP_WEIRD_PASV_REPLY");
1770 const StaticString
1771 s_CURLE_FTP_WEIRD_SERVER_REPLY("CURLE_FTP_WEIRD_SERVER_REPLY");
1772 const StaticString s_CURLE_FTP_WEIRD_USER_REPLY("CURLE_FTP_WEIRD_USER_REPLY");
1773 const StaticString s_CURLE_FTP_WRITE_ERROR("CURLE_FTP_WRITE_ERROR");
1774 const StaticString s_CURLE_FUNCTION_NOT_FOUND("CURLE_FUNCTION_NOT_FOUND");
1775 const StaticString s_CURLE_GOT_NOTHING("CURLE_GOT_NOTHING");
1776 const StaticString s_CURLE_HTTP_NOT_FOUND("CURLE_HTTP_NOT_FOUND");
1777 const StaticString s_CURLE_HTTP_PORT_FAILED("CURLE_HTTP_PORT_FAILED");
1778 const StaticString s_CURLE_HTTP_POST_ERROR("CURLE_HTTP_POST_ERROR");
1779 const StaticString s_CURLE_HTTP_RANGE_ERROR("CURLE_HTTP_RANGE_ERROR");
1780 const StaticString s_CURLE_LDAP_CANNOT_BIND("CURLE_LDAP_CANNOT_BIND");
1781 const StaticString s_CURLE_LDAP_INVALID_URL("CURLE_LDAP_INVALID_URL");
1782 const StaticString s_CURLE_LDAP_SEARCH_FAILED("CURLE_LDAP_SEARCH_FAILED");
1783 const StaticString s_CURLE_LIBRARY_NOT_FOUND("CURLE_LIBRARY_NOT_FOUND");
1784 const StaticString s_CURLE_MALFORMAT_USER("CURLE_MALFORMAT_USER");
1785 const StaticString s_CURLE_OBSOLETE("CURLE_OBSOLETE");
1786 const StaticString s_CURLE_OK("CURLE_OK");
1787 const StaticString s_CURLE_OPERATION_TIMEOUTED("CURLE_OPERATION_TIMEOUTED");
1788 const StaticString s_CURLE_OUT_OF_MEMORY("CURLE_OUT_OF_MEMORY");
1789 const StaticString s_CURLE_PARTIAL_FILE("CURLE_PARTIAL_FILE");
1790 const StaticString s_CURLE_READ_ERROR("CURLE_READ_ERROR");
1791 const StaticString s_CURLE_RECV_ERROR("CURLE_RECV_ERROR");
1792 const StaticString s_CURLE_SEND_ERROR("CURLE_SEND_ERROR");
1793 const StaticString s_CURLE_SHARE_IN_USE("CURLE_SHARE_IN_USE");
1794 const StaticString s_CURLE_SSL_CACERT("CURLE_SSL_CACERT");
1795 const StaticString s_CURLE_SSL_CERTPROBLEM("CURLE_SSL_CERTPROBLEM");
1796 const StaticString s_CURLE_SSL_CIPHER("CURLE_SSL_CIPHER");
1797 const StaticString s_CURLE_SSL_CONNECT_ERROR("CURLE_SSL_CONNECT_ERROR");
1798 const StaticString s_CURLE_SSL_ENGINE_NOTFOUND("CURLE_SSL_ENGINE_NOTFOUND");
1799 const StaticString s_CURLE_SSL_ENGINE_SETFAILED("CURLE_SSL_ENGINE_SETFAILED");
1800 const StaticString s_CURLE_SSL_PEER_CERTIFICATE("CURLE_SSL_PEER_CERTIFICATE");
1801 const StaticString s_CURLE_TELNET_OPTION_SYNTAX("CURLE_TELNET_OPTION_SYNTAX");
1802 const StaticString s_CURLE_TOO_MANY_REDIRECTS("CURLE_TOO_MANY_REDIRECTS");
1803 const StaticString s_CURLE_UNKNOWN_TELNET_OPTION("CURLE_UNKNOWN_TELNET_OPTION");
1804 const StaticString s_CURLE_UNSUPPORTED_PROTOCOL("CURLE_UNSUPPORTED_PROTOCOL");
1805 const StaticString s_CURLE_URL_MALFORMAT("CURLE_URL_MALFORMAT");
1806 const StaticString s_CURLE_URL_MALFORMAT_USER("CURLE_URL_MALFORMAT_USER");
1807 const StaticString s_CURLE_WRITE_ERROR("CURLE_WRITE_ERROR");
1808 const StaticString s_CURLFTPAUTH_DEFAULT("CURLFTPAUTH_DEFAULT");
1809 const StaticString s_CURLFTPAUTH_SSL("CURLFTPAUTH_SSL");
1810 const StaticString s_CURLFTPAUTH_TLS("CURLFTPAUTH_TLS");
1811 const StaticString s_CURLFTPSSL_ALL("CURLFTPSSL_ALL");
1812 const StaticString s_CURLFTPSSL_CONTROL("CURLFTPSSL_CONTROL");
1813 const StaticString s_CURLFTPSSL_NONE("CURLFTPSSL_NONE");
1814 const StaticString s_CURLFTPSSL_TRY("CURLFTPSSL_TRY");
1815 const StaticString s_CURLINFO_CONNECT_TIME("CURLINFO_CONNECT_TIME");
1816 const StaticString
1817 s_CURLINFO_CONTENT_LENGTH_DOWNLOAD("CURLINFO_CONTENT_LENGTH_DOWNLOAD");
1818 const StaticString
1819 s_CURLINFO_CONTENT_LENGTH_UPLOAD("CURLINFO_CONTENT_LENGTH_UPLOAD");
1820 const StaticString s_CURLINFO_CONTENT_TYPE("CURLINFO_CONTENT_TYPE");
1821 const StaticString s_CURLINFO_EFFECTIVE_URL("CURLINFO_EFFECTIVE_URL");
1822 const StaticString s_CURLINFO_FILETIME("CURLINFO_FILETIME");
1823 const StaticString s_CURLINFO_HEADER_OUT("CURLINFO_HEADER_OUT");
1824 const StaticString s_CURLINFO_HEADER_SIZE("CURLINFO_HEADER_SIZE");
1825 const StaticString s_CURLINFO_HTTP_CODE("CURLINFO_HTTP_CODE");
1826 const StaticString s_CURLINFO_NAMELOOKUP_TIME("CURLINFO_NAMELOOKUP_TIME");
1827 const StaticString s_CURLINFO_PRETRANSFER_TIME("CURLINFO_PRETRANSFER_TIME");
1828 const StaticString s_CURLINFO_PRIVATE("CURLINFO_PRIVATE");
1829 const StaticString s_CURLINFO_REDIRECT_COUNT("CURLINFO_REDIRECT_COUNT");
1830 const StaticString s_CURLINFO_REDIRECT_TIME("CURLINFO_REDIRECT_TIME");
1831 const StaticString s_CURLINFO_REQUEST_SIZE("CURLINFO_REQUEST_SIZE");
1832 const StaticString s_CURLINFO_SIZE_DOWNLOAD("CURLINFO_SIZE_DOWNLOAD");
1833 const StaticString s_CURLINFO_SIZE_UPLOAD("CURLINFO_SIZE_UPLOAD");
1834 const StaticString s_CURLINFO_SPEED_DOWNLOAD("CURLINFO_SPEED_DOWNLOAD");
1835 const StaticString s_CURLINFO_SPEED_UPLOAD("CURLINFO_SPEED_UPLOAD");
1836 const StaticString s_CURLINFO_SSL_VERIFYRESULT("CURLINFO_SSL_VERIFYRESULT");
1837 const StaticString s_CURLINFO_STARTTRANSFER_TIME("CURLINFO_STARTTRANSFER_TIME");
1838 const StaticString s_CURLINFO_TOTAL_TIME("CURLINFO_TOTAL_TIME");
1839 const StaticString s_CURLMSG_DONE("CURLMSG_DONE");
1840 const StaticString s_CURLM_BAD_EASY_HANDLE("CURLM_BAD_EASY_HANDLE");
1841 const StaticString s_CURLM_BAD_HANDLE("CURLM_BAD_HANDLE");
1842 const StaticString s_CURLM_CALL_MULTI_PERFORM("CURLM_CALL_MULTI_PERFORM");
1843 const StaticString s_CURLM_INTERNAL_ERROR("CURLM_INTERNAL_ERROR");
1844 const StaticString s_CURLM_OK("CURLM_OK");
1845 const StaticString s_CURLM_OUT_OF_MEMORY("CURLM_OUT_OF_MEMORY");
1846 const StaticString s_CURLOPT_AUTOREFERER("CURLOPT_AUTOREFERER");
1847 const StaticString s_CURLOPT_BINARYTRANSFER("CURLOPT_BINARYTRANSFER");
1848 const StaticString s_CURLOPT_BUFFERSIZE("CURLOPT_BUFFERSIZE");
1849 const StaticString s_CURLOPT_CAINFO("CURLOPT_CAINFO");
1850 const StaticString s_CURLOPT_CAPATH("CURLOPT_CAPATH");
1851 const StaticString s_CURLOPT_CLOSEPOLICY("CURLOPT_CLOSEPOLICY");
1852 const StaticString s_CURLOPT_CONNECTTIMEOUT("CURLOPT_CONNECTTIMEOUT");
1853 const StaticString s_CURLOPT_COOKIE("CURLOPT_COOKIE");
1854 const StaticString s_CURLOPT_COOKIEFILE("CURLOPT_COOKIEFILE");
1855 const StaticString s_CURLOPT_COOKIEJAR("CURLOPT_COOKIEJAR");
1856 const StaticString s_CURLOPT_COOKIESESSION("CURLOPT_COOKIESESSION");
1857 const StaticString s_CURLOPT_CRLF("CURLOPT_CRLF");
1858 const StaticString s_CURLOPT_CUSTOMREQUEST("CURLOPT_CUSTOMREQUEST");
1859 const StaticString s_CURLOPT_DNS_CACHE_TIMEOUT("CURLOPT_DNS_CACHE_TIMEOUT");
1860 const StaticString
1861 s_CURLOPT_DNS_USE_GLOBAL_CACHE("CURLOPT_DNS_USE_GLOBAL_CACHE");
1862 const StaticString s_CURLOPT_EGDSOCKET("CURLOPT_EGDSOCKET");
1863 const StaticString s_CURLOPT_ENCODING("CURLOPT_ENCODING");
1864 const StaticString s_CURLOPT_FAILONERROR("CURLOPT_FAILONERROR");
1865 const StaticString s_CURLOPT_FILE("CURLOPT_FILE");
1866 const StaticString s_CURLOPT_FILETIME("CURLOPT_FILETIME");
1867 const StaticString s_CURLOPT_FOLLOWLOCATION("CURLOPT_FOLLOWLOCATION");
1868 const StaticString s_CURLOPT_FORBID_REUSE("CURLOPT_FORBID_REUSE");
1869 const StaticString s_CURLOPT_FRESH_CONNECT("CURLOPT_FRESH_CONNECT");
1870 const StaticString s_CURLOPT_FTPAPPEND("CURLOPT_FTPAPPEND");
1871 const StaticString s_CURLOPT_FTPLISTONLY("CURLOPT_FTPLISTONLY");
1872 const StaticString s_CURLOPT_FTPPORT("CURLOPT_FTPPORT");
1873 const StaticString s_CURLOPT_FTPSSLAUTH("CURLOPT_FTPSSLAUTH");
1874 const StaticString
1875 s_CURLOPT_FTP_CREATE_MISSING_DIRS("CURLOPT_FTP_CREATE_MISSING_DIRS");
1876 const StaticString s_CURLOPT_FTP_SSL("CURLOPT_FTP_SSL");
1877 const StaticString s_CURLOPT_FTP_USE_EPRT("CURLOPT_FTP_USE_EPRT");
1878 const StaticString s_CURLOPT_FTP_USE_EPSV("CURLOPT_FTP_USE_EPSV");
1879 const StaticString s_CURLOPT_HEADER("CURLOPT_HEADER");
1880 const StaticString s_CURLOPT_HEADERFUNCTION("CURLOPT_HEADERFUNCTION");
1881 const StaticString s_CURLOPT_HTTP200ALIASES("CURLOPT_HTTP200ALIASES");
1882 const StaticString s_CURLOPT_HTTPAUTH("CURLOPT_HTTPAUTH");
1883 const StaticString s_CURLOPT_HTTPGET("CURLOPT_HTTPGET");
1884 const StaticString s_CURLOPT_HTTPHEADER("CURLOPT_HTTPHEADER");
1885 const StaticString s_CURLOPT_HTTPPROXYTUNNEL("CURLOPT_HTTPPROXYTUNNEL");
1886 const StaticString s_CURLOPT_HTTP_VERSION("CURLOPT_HTTP_VERSION");
1887 const StaticString s_CURLOPT_INFILE("CURLOPT_INFILE");
1888 const StaticString s_CURLOPT_INFILESIZE("CURLOPT_INFILESIZE");
1889 const StaticString s_CURLOPT_INTERFACE("CURLOPT_INTERFACE");
1890 const StaticString s_CURLOPT_IPRESOLVE("CURLOPT_IPRESOLVE");
1891 const StaticString s_CURLOPT_KRB4LEVEL("CURLOPT_KRB4LEVEL");
1892 const StaticString s_CURLOPT_LOW_SPEED_LIMIT("CURLOPT_LOW_SPEED_LIMIT");
1893 const StaticString s_CURLOPT_LOW_SPEED_TIME("CURLOPT_LOW_SPEED_TIME");
1894 const StaticString s_CURLOPT_MAXCONNECTS("CURLOPT_MAXCONNECTS");
1895 const StaticString s_CURLOPT_MAXREDIRS("CURLOPT_MAXREDIRS");
1896 const StaticString s_CURLOPT_MUTE("CURLOPT_MUTE");
1897 const StaticString s_CURLOPT_NETRC("CURLOPT_NETRC");
1898 const StaticString s_CURLOPT_NOBODY("CURLOPT_NOBODY");
1899 const StaticString s_CURLOPT_NOPROGRESS("CURLOPT_NOPROGRESS");
1900 const StaticString s_CURLOPT_NOSIGNAL("CURLOPT_NOSIGNAL");
1901 const StaticString s_CURLOPT_PASSWDFUNCTION("CURLOPT_PASSWDFUNCTION");
1902 const StaticString s_CURLOPT_PORT("CURLOPT_PORT");
1903 const StaticString s_CURLOPT_POST("CURLOPT_POST");
1904 const StaticString s_CURLOPT_POSTFIELDS("CURLOPT_POSTFIELDS");
1905 const StaticString s_CURLOPT_POSTREDIR("CURLOPT_POSTREDIR");
1906 const StaticString s_CURLOPT_POSTQUOTE("CURLOPT_POSTQUOTE");
1907 const StaticString s_CURLOPT_PRIVATE("CURLOPT_PRIVATE");
1908 const StaticString s_CURLOPT_PROGRESSFUNCTION("CURLOPT_PROGRESSFUNCTION");
1909 const StaticString s_CURLOPT_PROXY("CURLOPT_PROXY");
1910 const StaticString s_CURLOPT_PROXYAUTH("CURLOPT_PROXYAUTH");
1911 const StaticString s_CURLOPT_PROXYPORT("CURLOPT_PROXYPORT");
1912 const StaticString s_CURLOPT_PROXYTYPE("CURLOPT_PROXYTYPE");
1913 const StaticString s_CURLOPT_PROXYUSERPWD("CURLOPT_PROXYUSERPWD");
1914 const StaticString s_CURLOPT_PUT("CURLOPT_PUT");
1915 const StaticString s_CURLOPT_QUOTE("CURLOPT_QUOTE");
1916 const StaticString s_CURLOPT_RANDOM_FILE("CURLOPT_RANDOM_FILE");
1917 const StaticString s_CURLOPT_RANGE("CURLOPT_RANGE");
1918 const StaticString s_CURLOPT_READDATA("CURLOPT_READDATA");
1919 const StaticString s_CURLOPT_READFUNCTION("CURLOPT_READFUNCTION");
1920 const StaticString s_CURLOPT_REFERER("CURLOPT_REFERER");
1921 const StaticString s_CURLOPT_RESUME_FROM("CURLOPT_RESUME_FROM");
1922 const StaticString s_CURLOPT_RETURNTRANSFER("CURLOPT_RETURNTRANSFER");
1923 const StaticString s_CURLOPT_SSLCERT("CURLOPT_SSLCERT");
1924 const StaticString s_CURLOPT_SSLCERTPASSWD("CURLOPT_SSLCERTPASSWD");
1925 const StaticString s_CURLOPT_SSLCERTTYPE("CURLOPT_SSLCERTTYPE");
1926 const StaticString s_CURLOPT_SSLENGINE("CURLOPT_SSLENGINE");
1927 const StaticString s_CURLOPT_SSLENGINE_DEFAULT("CURLOPT_SSLENGINE_DEFAULT");
1928 const StaticString s_CURLOPT_SSLKEY("CURLOPT_SSLKEY");
1929 const StaticString s_CURLOPT_SSLKEYPASSWD("CURLOPT_SSLKEYPASSWD");
1930 const StaticString s_CURLOPT_SSLKEYTYPE("CURLOPT_SSLKEYTYPE");
1931 const StaticString s_CURLOPT_SSLVERSION("CURLOPT_SSLVERSION");
1932 const StaticString s_CURLOPT_SSL_CIPHER_LIST("CURLOPT_SSL_CIPHER_LIST");
1933 const StaticString s_CURLOPT_SSL_VERIFYHOST("CURLOPT_SSL_VERIFYHOST");
1934 const StaticString s_CURLOPT_SSL_VERIFYPEER("CURLOPT_SSL_VERIFYPEER");
1935 const StaticString s_CURLOPT_STDERR("CURLOPT_STDERR");
1936 const StaticString s_CURLOPT_TCP_NODELAY("CURLOPT_TCP_NODELAY");
1937 const StaticString s_CURLOPT_TIMECONDITION("CURLOPT_TIMECONDITION");
1938 const StaticString s_CURLOPT_TIMEOUT("CURLOPT_TIMEOUT");
1939 const StaticString s_CURLOPT_TIMEVALUE("CURLOPT_TIMEVALUE");
1940 const StaticString s_CURLOPT_TRANSFERTEXT("CURLOPT_TRANSFERTEXT");
1941 const StaticString s_CURLOPT_UNRESTRICTED_AUTH("CURLOPT_UNRESTRICTED_AUTH");
1942 const StaticString s_CURLOPT_UPLOAD("CURLOPT_UPLOAD");
1943 const StaticString s_CURLOPT_URL("CURLOPT_URL");
1944 const StaticString s_CURLOPT_USERAGENT("CURLOPT_USERAGENT");
1945 const StaticString s_CURLOPT_USERPWD("CURLOPT_USERPWD");
1946 const StaticString s_CURLOPT_VERBOSE("CURLOPT_VERBOSE");
1947 const StaticString s_CURLOPT_WRITEFUNCTION("CURLOPT_WRITEFUNCTION");
1948 const StaticString s_CURLOPT_WRITEHEADER("CURLOPT_WRITEHEADER");
1949 const StaticString s_CURLOPT_FB_TLS_VER_MAX("CURLOPT_FB_TLS_VER_MAX");
1950 const StaticString s_CURLOPT_FB_TLS_VER_MAX_NONE("CURLOPT_FB_TLS_VER_MAX_NONE");
1951 const StaticString s_CURLOPT_FB_TLS_VER_MAX_1_1("CURLOPT_FB_TLS_VER_MAX_1_1");
1952 const StaticString s_CURLOPT_FB_TLS_VER_MAX_1_0("CURLOPT_FB_TLS_VER_MAX_1_0");
1953 const StaticString s_CURLOPT_FB_TLS_CIPHER_SPEC("CURLOPT_FB_TLS_CIPHER_SPEC");
1954 const StaticString s_CURLPROXY_HTTP("CURLPROXY_HTTP");
1955 const StaticString s_CURLPROXY_SOCKS5("CURLPROXY_SOCKS5");
1956 const StaticString s_CURLVERSION_NOW("CURLVERSION_NOW");
1957 const StaticString s_CURL_HTTP_VERSION_1_0("CURL_HTTP_VERSION_1_0");
1958 const StaticString s_CURL_HTTP_VERSION_1_1("CURL_HTTP_VERSION_1_1");
1959 const StaticString s_CURL_HTTP_VERSION_NONE("CURL_HTTP_VERSION_NONE");
1960 const StaticString s_CURL_IPRESOLVE_V4("CURL_IPRESOLVE_V4");
1961 const StaticString s_CURL_IPRESOLVE_V6("CURL_IPRESOLVE_V6");
1962 const StaticString s_CURL_IPRESOLVE_WHATEVER("CURL_IPRESOLVE_WHATEVER");
1963 const StaticString s_CURL_NETRC_IGNORED("CURL_NETRC_IGNORED");
1964 const StaticString s_CURL_NETRC_OPTIONAL("CURL_NETRC_OPTIONAL");
1965 const StaticString s_CURL_NETRC_REQUIRED("CURL_NETRC_REQUIRED");
1966 const StaticString s_CURL_TIMECOND_IFMODSINCE("CURL_TIMECOND_IFMODSINCE");
1967 const StaticString s_CURL_TIMECOND_IFUNMODSINCE("CURL_TIMECOND_IFUNMODSINCE");
1968 const StaticString s_CURL_TIMECOND_LASTMOD("CURL_TIMECOND_LASTMOD");
1969 const StaticString s_CURL_VERSION_IPV6("CURL_VERSION_IPV6");
1970 const StaticString s_CURL_VERSION_KERBEROS4("CURL_VERSION_KERBEROS4");
1971 const StaticString s_CURL_VERSION_LIBZ("CURL_VERSION_LIBZ");
1972 const StaticString s_CURL_VERSION_SSL("CURL_VERSION_SSL");
1973
1974 class CurlExtension : public Extension {
1975 public:
1976 CurlExtension() : Extension("curl") {}
1977 virtual void moduleInit() {
1978 #if LIBCURL_VERSION_NUM >= 0x071500
1979 Native::registerConstant<KindOfInt64>(
1980 s_CURLINFO_LOCAL_PORT.get(), k_CURLINFO_LOCAL_PORT
1981 );
1982 #endif
1983 #if LIBCURL_VERSION_NUM >= 0x071002
1984 Native::registerConstant<KindOfInt64>(
1985 s_CURLOPT_TIMEOUT_MS.get(), k_CURLOPT_TIMEOUT_MS
1986 );
1987 Native::registerConstant<KindOfInt64>(
1988 s_CURLOPT_CONNECTTIMEOUT_MS.get(), k_CURLOPT_CONNECTTIMEOUT_MS
1989 );
1990 #endif
1991 Native::registerConstant<KindOfInt64>(
1992 s_CURLAUTH_ANY.get(), k_CURLAUTH_ANY
1993 );
1994 Native::registerConstant<KindOfInt64>(
1995 s_CURLAUTH_ANYSAFE.get(), k_CURLAUTH_ANYSAFE
1996 );
1997 Native::registerConstant<KindOfInt64>(
1998 s_CURLAUTH_BASIC.get(), k_CURLAUTH_BASIC
1999 );
2000 Native::registerConstant<KindOfInt64>(
2001 s_CURLAUTH_DIGEST.get(), k_CURLAUTH_DIGEST
2002 );
2003 Native::registerConstant<KindOfInt64>(
2004 s_CURLAUTH_GSSNEGOTIATE.get(), k_CURLAUTH_GSSNEGOTIATE
2005 );
2006 Native::registerConstant<KindOfInt64>(
2007 s_CURLAUTH_NTLM.get(), k_CURLAUTH_NTLM
2008 );
2009 Native::registerConstant<KindOfInt64>(
2010 s_CURLCLOSEPOLICY_CALLBACK.get(), k_CURLCLOSEPOLICY_CALLBACK
2011 );
2012 Native::registerConstant<KindOfInt64>(
2013 s_CURLCLOSEPOLICY_LEAST_RECENTLY_USED.get(),
2014 k_CURLCLOSEPOLICY_LEAST_RECENTLY_USED
2015 );
2016 Native::registerConstant<KindOfInt64>(
2017 s_CURLCLOSEPOLICY_LEAST_TRAFFIC.get(), k_CURLCLOSEPOLICY_LEAST_TRAFFIC
2018 );
2019 Native::registerConstant<KindOfInt64>(
2020 s_CURLCLOSEPOLICY_OLDEST.get(), k_CURLCLOSEPOLICY_OLDEST
2021 );
2022 Native::registerConstant<KindOfInt64>(
2023 s_CURLCLOSEPOLICY_SLOWEST.get(), k_CURLCLOSEPOLICY_SLOWEST
2024 );
2025 Native::registerConstant<KindOfInt64>(
2026 s_CURLE_ABORTED_BY_CALLBACK.get(), k_CURLE_ABORTED_BY_CALLBACK
2027 );
2028 Native::registerConstant<KindOfInt64>(
2029 s_CURLE_BAD_CALLING_ORDER.get(), k_CURLE_BAD_CALLING_ORDER
2030 );
2031 Native::registerConstant<KindOfInt64>(
2032 s_CURLE_BAD_CONTENT_ENCODING.get(), k_CURLE_BAD_CONTENT_ENCODING
2033 );
2034 Native::registerConstant<KindOfInt64>(
2035 s_CURLE_BAD_FUNCTION_ARGUMENT.get(), k_CURLE_BAD_FUNCTION_ARGUMENT
2036 );
2037 Native::registerConstant<KindOfInt64>(
2038 s_CURLE_BAD_PASSWORD_ENTERED.get(), k_CURLE_BAD_PASSWORD_ENTERED
2039 );
2040 Native::registerConstant<KindOfInt64>(
2041 s_CURLE_COULDNT_CONNECT.get(), k_CURLE_COULDNT_CONNECT
2042 );
2043 Native::registerConstant<KindOfInt64>(
2044 s_CURLE_COULDNT_RESOLVE_HOST.get(), k_CURLE_COULDNT_RESOLVE_HOST
2045 );
2046 Native::registerConstant<KindOfInt64>(
2047 s_CURLE_COULDNT_RESOLVE_PROXY.get(), k_CURLE_COULDNT_RESOLVE_PROXY
2048 );
2049 Native::registerConstant<KindOfInt64>(
2050 s_CURLE_FAILED_INIT.get(), k_CURLE_FAILED_INIT
2051 );
2052 Native::registerConstant<KindOfInt64>(
2053 s_CURLE_FILESIZE_EXCEEDED.get(), k_CURLE_FILESIZE_EXCEEDED
2054 );
2055 Native::registerConstant<KindOfInt64>(
2056 s_CURLE_FILE_COULDNT_READ_FILE.get(), k_CURLE_FILE_COULDNT_READ_FILE
2057 );
2058 Native::registerConstant<KindOfInt64>(
2059 s_CURLE_FTP_ACCESS_DENIED.get(), k_CURLE_FTP_ACCESS_DENIED
2060 );
2061 Native::registerConstant<KindOfInt64>(
2062 s_CURLE_FTP_BAD_DOWNLOAD_RESUME.get(), k_CURLE_FTP_BAD_DOWNLOAD_RESUME
2063 );
2064 Native::registerConstant<KindOfInt64>(
2065 s_CURLE_FTP_CANT_GET_HOST.get(), k_CURLE_FTP_CANT_GET_HOST
2066 );
2067 Native::registerConstant<KindOfInt64>(
2068 s_CURLE_FTP_CANT_RECONNECT.get(), k_CURLE_FTP_CANT_RECONNECT
2069 );
2070 Native::registerConstant<KindOfInt64>(
2071 s_CURLE_FTP_COULDNT_GET_SIZE.get(), k_CURLE_FTP_COULDNT_GET_SIZE
2072 );
2073 Native::registerConstant<KindOfInt64>(
2074 s_CURLE_FTP_COULDNT_RETR_FILE.get(), k_CURLE_FTP_COULDNT_RETR_FILE
2075 );
2076 Native::registerConstant<KindOfInt64>(
2077 s_CURLE_FTP_COULDNT_SET_ASCII.get(), k_CURLE_FTP_COULDNT_SET_ASCII
2078 );
2079 Native::registerConstant<KindOfInt64>(
2080 s_CURLE_FTP_COULDNT_SET_BINARY.get(), k_CURLE_FTP_COULDNT_SET_BINARY
2081 );
2082 Native::registerConstant<KindOfInt64>(
2083 s_CURLE_FTP_COULDNT_STOR_FILE.get(), k_CURLE_FTP_COULDNT_STOR_FILE
2084 );
2085 Native::registerConstant<KindOfInt64>(
2086 s_CURLE_FTP_COULDNT_USE_REST.get(), k_CURLE_FTP_COULDNT_USE_REST
2087 );
2088 Native::registerConstant<KindOfInt64>(
2089 s_CURLE_FTP_PORT_FAILED.get(), k_CURLE_FTP_PORT_FAILED
2090 );
2091 Native::registerConstant<KindOfInt64>(
2092 s_CURLE_FTP_QUOTE_ERROR.get(), k_CURLE_FTP_QUOTE_ERROR
2093 );
2094 Native::registerConstant<KindOfInt64>(
2095 s_CURLE_FTP_SSL_FAILED.get(), k_CURLE_FTP_SSL_FAILED
2096 );
2097 Native::registerConstant<KindOfInt64>(
2098 s_CURLE_FTP_USER_PASSWORD_INCORRECT.get(),
2099 k_CURLE_FTP_USER_PASSWORD_INCORRECT
2100 );
2101 Native::registerConstant<KindOfInt64>(
2102 s_CURLE_FTP_WEIRD_227_FORMAT.get(), k_CURLE_FTP_WEIRD_227_FORMAT
2103 );
2104 Native::registerConstant<KindOfInt64>(
2105 s_CURLE_FTP_WEIRD_PASS_REPLY.get(), k_CURLE_FTP_WEIRD_PASS_REPLY
2106 );
2107 Native::registerConstant<KindOfInt64>(
2108 s_CURLE_FTP_WEIRD_PASV_REPLY.get(), k_CURLE_FTP_WEIRD_PASV_REPLY
2109 );
2110 Native::registerConstant<KindOfInt64>(
2111 s_CURLE_FTP_WEIRD_SERVER_REPLY.get(), k_CURLE_FTP_WEIRD_SERVER_REPLY
2112 );
2113 Native::registerConstant<KindOfInt64>(
2114 s_CURLE_FTP_WEIRD_USER_REPLY.get(), k_CURLE_FTP_WEIRD_USER_REPLY
2115 );
2116 Native::registerConstant<KindOfInt64>(
2117 s_CURLE_FTP_WRITE_ERROR.get(), k_CURLE_FTP_WRITE_ERROR
2118 );
2119 Native::registerConstant<KindOfInt64>(
2120 s_CURLE_FUNCTION_NOT_FOUND.get(), k_CURLE_FUNCTION_NOT_FOUND
2121 );
2122 Native::registerConstant<KindOfInt64>(
2123 s_CURLE_GOT_NOTHING.get(), k_CURLE_GOT_NOTHING
2124 );
2125 Native::registerConstant<KindOfInt64>(
2126 s_CURLE_HTTP_NOT_FOUND.get(), k_CURLE_HTTP_NOT_FOUND
2127 );
2128 Native::registerConstant<KindOfInt64>(
2129 s_CURLE_HTTP_PORT_FAILED.get(), k_CURLE_HTTP_PORT_FAILED
2130 );
2131 Native::registerConstant<KindOfInt64>(
2132 s_CURLE_HTTP_POST_ERROR.get(), k_CURLE_HTTP_POST_ERROR
2133 );
2134 Native::registerConstant<KindOfInt64>(
2135 s_CURLE_HTTP_RANGE_ERROR.get(), k_CURLE_HTTP_RANGE_ERROR
2136 );
2137 Native::registerConstant<KindOfInt64>(
2138 s_CURLE_LDAP_CANNOT_BIND.get(), k_CURLE_LDAP_CANNOT_BIND
2139 );
2140 Native::registerConstant<KindOfInt64>(
2141 s_CURLE_LDAP_INVALID_URL.get(), k_CURLE_LDAP_INVALID_URL
2142 );
2143 Native::registerConstant<KindOfInt64>(
2144 s_CURLE_LDAP_SEARCH_FAILED.get(), k_CURLE_LDAP_SEARCH_FAILED
2145 );
2146 Native::registerConstant<KindOfInt64>(
2147 s_CURLE_LIBRARY_NOT_FOUND.get(), k_CURLE_LIBRARY_NOT_FOUND
2148 );
2149 Native::registerConstant<KindOfInt64>(
2150 s_CURLE_MALFORMAT_USER.get(), k_CURLE_MALFORMAT_USER
2151 );
2152 Native::registerConstant<KindOfInt64>(
2153 s_CURLE_OBSOLETE.get(), k_CURLE_OBSOLETE
2154 );
2155 Native::registerConstant<KindOfInt64>(
2156 s_CURLE_OK.get(), k_CURLE_OK
2157 );
2158 Native::registerConstant<KindOfInt64>(
2159 s_CURLE_OPERATION_TIMEOUTED.get(), k_CURLE_OPERATION_TIMEOUTED
2160 );
2161 Native::registerConstant<KindOfInt64>(
2162 s_CURLE_OUT_OF_MEMORY.get(), k_CURLE_OUT_OF_MEMORY
2163 );
2164 Native::registerConstant<KindOfInt64>(
2165 s_CURLE_PARTIAL_FILE.get(), k_CURLE_PARTIAL_FILE
2166 );
2167 Native::registerConstant<KindOfInt64>(
2168 s_CURLE_READ_ERROR.get(), k_CURLE_READ_ERROR
2169 );
2170 Native::registerConstant<KindOfInt64>(
2171 s_CURLE_RECV_ERROR.get(), k_CURLE_RECV_ERROR
2172 );
2173 Native::registerConstant<KindOfInt64>(
2174 s_CURLE_SEND_ERROR.get(), k_CURLE_SEND_ERROR
2175 );
2176 Native::registerConstant<KindOfInt64>(
2177 s_CURLE_SHARE_IN_USE.get(), k_CURLE_SHARE_IN_USE
2178 );
2179 Native::registerConstant<KindOfInt64>(
2180 s_CURLE_SSL_CACERT.get(), k_CURLE_SSL_CACERT
2181 );
2182 Native::registerConstant<KindOfInt64>(
2183 s_CURLE_SSL_CERTPROBLEM.get(), k_CURLE_SSL_CERTPROBLEM
2184 );
2185 Native::registerConstant<KindOfInt64>(
2186 s_CURLE_SSL_CIPHER.get(), k_CURLE_SSL_CIPHER
2187 );
2188 Native::registerConstant<KindOfInt64>(
2189 s_CURLE_SSL_CONNECT_ERROR.get(), k_CURLE_SSL_CONNECT_ERROR
2190 );
2191 Native::registerConstant<KindOfInt64>(
2192 s_CURLE_SSL_ENGINE_NOTFOUND.get(), k_CURLE_SSL_ENGINE_NOTFOUND
2193 );
2194 Native::registerConstant<KindOfInt64>(
2195 s_CURLE_SSL_ENGINE_SETFAILED.get(), k_CURLE_SSL_ENGINE_SETFAILED
2196 );
2197 Native::registerConstant<KindOfInt64>(
2198 s_CURLE_SSL_PEER_CERTIFICATE.get(), k_CURLE_SSL_PEER_CERTIFICATE
2199 );
2200 Native::registerConstant<KindOfInt64>(
2201 s_CURLE_TELNET_OPTION_SYNTAX.get(), k_CURLE_TELNET_OPTION_SYNTAX
2202 );
2203 Native::registerConstant<KindOfInt64>(
2204 s_CURLE_TOO_MANY_REDIRECTS.get(), k_CURLE_TOO_MANY_REDIRECTS
2205 );
2206 Native::registerConstant<KindOfInt64>(
2207 s_CURLE_UNKNOWN_TELNET_OPTION.get(), k_CURLE_UNKNOWN_TELNET_OPTION
2208 );
2209 Native::registerConstant<KindOfInt64>(
2210 s_CURLE_UNSUPPORTED_PROTOCOL.get(), k_CURLE_UNSUPPORTED_PROTOCOL
2211 );
2212 Native::registerConstant<KindOfInt64>(
2213 s_CURLE_URL_MALFORMAT.get(), k_CURLE_URL_MALFORMAT
2214 );
2215 Native::registerConstant<KindOfInt64>(
2216 s_CURLE_URL_MALFORMAT_USER.get(), k_CURLE_URL_MALFORMAT_USER
2217 );
2218 Native::registerConstant<KindOfInt64>(
2219 s_CURLE_WRITE_ERROR.get(), k_CURLE_WRITE_ERROR
2220 );
2221 Native::registerConstant<KindOfInt64>(
2222 s_CURLFTPAUTH_DEFAULT.get(), k_CURLFTPAUTH_DEFAULT
2223 );
2224 Native::registerConstant<KindOfInt64>(
2225 s_CURLFTPAUTH_SSL.get(), k_CURLFTPAUTH_SSL
2226 );
2227 Native::registerConstant<KindOfInt64>(
2228 s_CURLFTPAUTH_TLS.get(), k_CURLFTPAUTH_TLS
2229 );
2230 Native::registerConstant<KindOfInt64>(
2231 s_CURLFTPSSL_ALL.get(), k_CURLFTPSSL_ALL
2232 );
2233 Native::registerConstant<KindOfInt64>(
2234 s_CURLFTPSSL_CONTROL.get(), k_CURLFTPSSL_CONTROL
2235 );
2236 Native::registerConstant<KindOfInt64>(
2237 s_CURLFTPSSL_NONE.get(), k_CURLFTPSSL_NONE
2238 );
2239 Native::registerConstant<KindOfInt64>(
2240 s_CURLFTPSSL_TRY.get(), k_CURLFTPSSL_TRY
2241 );
2242 Native::registerConstant<KindOfInt64>(
2243 s_CURLINFO_CONNECT_TIME.get(), k_CURLINFO_CONNECT_TIME
2244 );
2245 Native::registerConstant<KindOfInt64>(
2246 s_CURLINFO_CONTENT_LENGTH_DOWNLOAD.get(),
2247 k_CURLINFO_CONTENT_LENGTH_DOWNLOAD
2248 );
2249 Native::registerConstant<KindOfInt64>(
2250 s_CURLINFO_CONTENT_LENGTH_UPLOAD.get(), k_CURLINFO_CONTENT_LENGTH_UPLOAD
2251 );
2252 Native::registerConstant<KindOfInt64>(
2253 s_CURLINFO_CONTENT_TYPE.get(), k_CURLINFO_CONTENT_TYPE
2254 );
2255 Native::registerConstant<KindOfInt64>(
2256 s_CURLINFO_EFFECTIVE_URL.get(), k_CURLINFO_EFFECTIVE_URL
2257 );
2258 Native::registerConstant<KindOfInt64>(
2259 s_CURLINFO_FILETIME.get(), k_CURLINFO_FILETIME
2260 );
2261 Native::registerConstant<KindOfInt64>(
2262 s_CURLINFO_HEADER_OUT.get(), k_CURLINFO_HEADER_OUT
2263 );
2264 Native::registerConstant<KindOfInt64>(
2265 s_CURLINFO_HEADER_SIZE.get(), k_CURLINFO_HEADER_SIZE
2266 );
2267 Native::registerConstant<KindOfInt64>(
2268 s_CURLINFO_HTTP_CODE.get(), k_CURLINFO_HTTP_CODE
2269 );
2270 Native::registerConstant<KindOfInt64>(
2271 s_CURLINFO_NAMELOOKUP_TIME.get(), k_CURLINFO_NAMELOOKUP_TIME
2272 );
2273 Native::registerConstant<KindOfInt64>(
2274 s_CURLINFO_PRETRANSFER_TIME.get(), k_CURLINFO_PRETRANSFER_TIME
2275 );
2276 Native::registerConstant<KindOfInt64>(
2277 s_CURLINFO_PRIVATE.get(), k_CURLINFO_PRIVATE
2278 );
2279 Native::registerConstant<KindOfInt64>(
2280 s_CURLINFO_REDIRECT_COUNT.get(), k_CURLINFO_REDIRECT_COUNT
2281 );
2282 Native::registerConstant<KindOfInt64>(
2283 s_CURLINFO_REDIRECT_TIME.get(), k_CURLINFO_REDIRECT_TIME
2284 );
2285 Native::registerConstant<KindOfInt64>(
2286 s_CURLINFO_REQUEST_SIZE.get(), k_CURLINFO_REQUEST_SIZE
2287 );
2288 Native::registerConstant<KindOfInt64>(
2289 s_CURLINFO_SIZE_DOWNLOAD.get(), k_CURLINFO_SIZE_DOWNLOAD
2290 );
2291 Native::registerConstant<KindOfInt64>(
2292 s_CURLINFO_SIZE_UPLOAD.get(), k_CURLINFO_SIZE_UPLOAD
2293 );
2294 Native::registerConstant<KindOfInt64>(
2295 s_CURLINFO_SPEED_DOWNLOAD.get(), k_CURLINFO_SPEED_DOWNLOAD
2296 );
2297 Native::registerConstant<KindOfInt64>(
2298 s_CURLINFO_SPEED_UPLOAD.get(), k_CURLINFO_SPEED_UPLOAD
2299 );
2300 Native::registerConstant<KindOfInt64>(
2301 s_CURLINFO_SSL_VERIFYRESULT.get(), k_CURLINFO_SSL_VERIFYRESULT
2302 );
2303 Native::registerConstant<KindOfInt64>(
2304 s_CURLINFO_STARTTRANSFER_TIME.get(), k_CURLINFO_STARTTRANSFER_TIME
2305 );
2306 Native::registerConstant<KindOfInt64>(
2307 s_CURLINFO_TOTAL_TIME.get(), k_CURLINFO_TOTAL_TIME
2308 );
2309 Native::registerConstant<KindOfInt64>(
2310 s_CURLMSG_DONE.get(), k_CURLMSG_DONE
2311 );
2312 Native::registerConstant<KindOfInt64>(
2313 s_CURLM_BAD_EASY_HANDLE.get(), k_CURLM_BAD_EASY_HANDLE
2314 );
2315 Native::registerConstant<KindOfInt64>(
2316 s_CURLM_BAD_HANDLE.get(), k_CURLM_BAD_HANDLE
2317 );
2318 Native::registerConstant<KindOfInt64>(
2319 s_CURLM_CALL_MULTI_PERFORM.get(), k_CURLM_CALL_MULTI_PERFORM
2320 );
2321 Native::registerConstant<KindOfInt64>(
2322 s_CURLM_INTERNAL_ERROR.get(), k_CURLM_INTERNAL_ERROR
2323 );
2324 Native::registerConstant<KindOfInt64>(
2325 s_CURLM_OK.get(), k_CURLM_OK
2326 );
2327 Native::registerConstant<KindOfInt64>(
2328 s_CURLM_OUT_OF_MEMORY.get(), k_CURLM_OUT_OF_MEMORY
2329 );
2330 Native::registerConstant<KindOfInt64>(
2331 s_CURLOPT_AUTOREFERER.get(), k_CURLOPT_AUTOREFERER
2332 );
2333 Native::registerConstant<KindOfInt64>(
2334 s_CURLOPT_BINARYTRANSFER.get(), k_CURLOPT_BINARYTRANSFER
2335 );
2336 Native::registerConstant<KindOfInt64>(
2337 s_CURLOPT_BUFFERSIZE.get(), k_CURLOPT_BUFFERSIZE
2338 );
2339 Native::registerConstant<KindOfInt64>(
2340 s_CURLOPT_CAINFO.get(), k_CURLOPT_CAINFO
2341 );
2342 Native::registerConstant<KindOfInt64>(
2343 s_CURLOPT_CAPATH.get(), k_CURLOPT_CAPATH
2344 );
2345 Native::registerConstant<KindOfInt64>(
2346 s_CURLOPT_CLOSEPOLICY.get(), k_CURLOPT_CLOSEPOLICY
2347 );
2348 Native::registerConstant<KindOfInt64>(
2349 s_CURLOPT_CONNECTTIMEOUT.get(), k_CURLOPT_CONNECTTIMEOUT
2350 );
2351 Native::registerConstant<KindOfInt64>(
2352 s_CURLOPT_COOKIE.get(), k_CURLOPT_COOKIE
2353 );
2354 Native::registerConstant<KindOfInt64>(
2355 s_CURLOPT_COOKIEFILE.get(), k_CURLOPT_COOKIEFILE
2356 );
2357 Native::registerConstant<KindOfInt64>(
2358 s_CURLOPT_COOKIEJAR.get(), k_CURLOPT_COOKIEJAR
2359 );
2360 Native::registerConstant<KindOfInt64>(
2361 s_CURLOPT_COOKIESESSION.get(), k_CURLOPT_COOKIESESSION
2362 );
2363 Native::registerConstant<KindOfInt64>(
2364 s_CURLOPT_CRLF.get(), k_CURLOPT_CRLF
2365 );
2366 Native::registerConstant<KindOfInt64>(
2367 s_CURLOPT_CUSTOMREQUEST.get(), k_CURLOPT_CUSTOMREQUEST
2368 );
2369 Native::registerConstant<KindOfInt64>(
2370 s_CURLOPT_DNS_CACHE_TIMEOUT.get(), k_CURLOPT_DNS_CACHE_TIMEOUT
2371 );
2372 Native::registerConstant<KindOfInt64>(
2373 s_CURLOPT_DNS_USE_GLOBAL_CACHE.get(), k_CURLOPT_DNS_USE_GLOBAL_CACHE
2374 );
2375 Native::registerConstant<KindOfInt64>(
2376 s_CURLOPT_EGDSOCKET.get(), k_CURLOPT_EGDSOCKET
2377 );
2378 Native::registerConstant<KindOfInt64>(
2379 s_CURLOPT_ENCODING.get(), k_CURLOPT_ENCODING
2380 );
2381 Native::registerConstant<KindOfInt64>(
2382 s_CURLOPT_FAILONERROR.get(), k_CURLOPT_FAILONERROR
2383 );
2384 Native::registerConstant<KindOfInt64>(
2385 s_CURLOPT_FILE.get(), k_CURLOPT_FILE
2386 );
2387 Native::registerConstant<KindOfInt64>(
2388 s_CURLOPT_FILETIME.get(), k_CURLOPT_FILETIME
2389 );
2390 Native::registerConstant<KindOfInt64>(
2391 s_CURLOPT_FOLLOWLOCATION.get(), k_CURLOPT_FOLLOWLOCATION
2392 );
2393 Native::registerConstant<KindOfInt64>(
2394 s_CURLOPT_FORBID_REUSE.get(), k_CURLOPT_FORBID_REUSE
2395 );
2396 Native::registerConstant<KindOfInt64>(
2397 s_CURLOPT_FRESH_CONNECT.get(), k_CURLOPT_FRESH_CONNECT
2398 );
2399 Native::registerConstant<KindOfInt64>(
2400 s_CURLOPT_FTPAPPEND.get(), k_CURLOPT_FTPAPPEND
2401 );
2402 Native::registerConstant<KindOfInt64>(
2403 s_CURLOPT_FTPLISTONLY.get(), k_CURLOPT_FTPLISTONLY
2404 );
2405 Native::registerConstant<KindOfInt64>(
2406 s_CURLOPT_FTPPORT.get(), k_CURLOPT_FTPPORT
2407 );
2408 Native::registerConstant<KindOfInt64>(
2409 s_CURLOPT_FTPSSLAUTH.get(), k_CURLOPT_FTPSSLAUTH
2410 );
2411 Native::registerConstant<KindOfInt64>(
2412 s_CURLOPT_FTP_CREATE_MISSING_DIRS.get(), k_CURLOPT_FTP_CREATE_MISSING_DIRS
2413 );
2414 Native::registerConstant<KindOfInt64>(
2415 s_CURLOPT_FTP_SSL.get(), k_CURLOPT_FTP_SSL
2416 );
2417 Native::registerConstant<KindOfInt64>(
2418 s_CURLOPT_FTP_USE_EPRT.get(), k_CURLOPT_FTP_USE_EPRT
2419 );
2420 Native::registerConstant<KindOfInt64>(
2421 s_CURLOPT_FTP_USE_EPSV.get(), k_CURLOPT_FTP_USE_EPSV
2422 );
2423 Native::registerConstant<KindOfInt64>(
2424 s_CURLOPT_HEADER.get(), k_CURLOPT_HEADER
2425 );
2426 Native::registerConstant<KindOfInt64>(
2427 s_CURLOPT_HEADERFUNCTION.get(), k_CURLOPT_HEADERFUNCTION
2428 );
2429 Native::registerConstant<KindOfInt64>(
2430 s_CURLOPT_HTTP200ALIASES.get(), k_CURLOPT_HTTP200ALIASES
2431 );
2432 Native::registerConstant<KindOfInt64>(
2433 s_CURLOPT_HTTPAUTH.get(), k_CURLOPT_HTTPAUTH
2434 );
2435 Native::registerConstant<KindOfInt64>(
2436 s_CURLOPT_HTTPGET.get(), k_CURLOPT_HTTPGET
2437 );
2438 Native::registerConstant<KindOfInt64>(
2439 s_CURLOPT_HTTPHEADER.get(), k_CURLOPT_HTTPHEADER
2440 );
2441 Native::registerConstant<KindOfInt64>(
2442 s_CURLOPT_HTTPPROXYTUNNEL.get(), k_CURLOPT_HTTPPROXYTUNNEL
2443 );
2444 Native::registerConstant<KindOfInt64>(
2445 s_CURLOPT_HTTP_VERSION.get(), k_CURLOPT_HTTP_VERSION
2446 );
2447 Native::registerConstant<KindOfInt64>(
2448 s_CURLOPT_INFILE.get(), k_CURLOPT_INFILE
2449 );
2450 Native::registerConstant<KindOfInt64>(
2451 s_CURLOPT_INFILESIZE.get(), k_CURLOPT_INFILESIZE
2452 );
2453 Native::registerConstant<KindOfInt64>(
2454 s_CURLOPT_INTERFACE.get(), k_CURLOPT_INTERFACE
2455 );
2456 Native::registerConstant<KindOfInt64>(
2457 s_CURLOPT_IPRESOLVE.get(), k_CURLOPT_IPRESOLVE
2458 );
2459 Native::registerConstant<KindOfInt64>(
2460 s_CURLOPT_KRB4LEVEL.get(), k_CURLOPT_KRB4LEVEL
2461 );
2462 Native::registerConstant<KindOfInt64>(
2463 s_CURLOPT_LOW_SPEED_LIMIT.get(), k_CURLOPT_LOW_SPEED_LIMIT
2464 );
2465 Native::registerConstant<KindOfInt64>(
2466 s_CURLOPT_LOW_SPEED_TIME.get(), k_CURLOPT_LOW_SPEED_TIME
2467 );
2468 Native::registerConstant<KindOfInt64>(
2469 s_CURLOPT_MAXCONNECTS.get(), k_CURLOPT_MAXCONNECTS
2470 );
2471 Native::registerConstant<KindOfInt64>(
2472 s_CURLOPT_MAXREDIRS.get(), k_CURLOPT_MAXREDIRS
2473 );
2474 Native::registerConstant<KindOfInt64>(
2475 s_CURLOPT_MUTE.get(), k_CURLOPT_MUTE
2476 );
2477 Native::registerConstant<KindOfInt64>(
2478 s_CURLOPT_NETRC.get(), k_CURLOPT_NETRC
2479 );
2480 Native::registerConstant<KindOfInt64>(
2481 s_CURLOPT_NOBODY.get(), k_CURLOPT_NOBODY
2482 );
2483 Native::registerConstant<KindOfInt64>(
2484 s_CURLOPT_NOPROGRESS.get(), k_CURLOPT_NOPROGRESS
2485 );
2486 Native::registerConstant<KindOfInt64>(
2487 s_CURLOPT_NOSIGNAL.get(), k_CURLOPT_NOSIGNAL
2488 );
2489 Native::registerConstant<KindOfInt64>(
2490 s_CURLOPT_PASSWDFUNCTION.get(), k_CURLOPT_PASSWDFUNCTION
2491 );
2492 Native::registerConstant<KindOfInt64>(
2493 s_CURLOPT_PORT.get(), k_CURLOPT_PORT
2494 );
2495 Native::registerConstant<KindOfInt64>(
2496 s_CURLOPT_POST.get(), k_CURLOPT_POST
2497 );
2498 Native::registerConstant<KindOfInt64>(
2499 s_CURLOPT_POSTFIELDS.get(), k_CURLOPT_POSTFIELDS
2500 );
2501 Native::registerConstant<KindOfInt64>(
2502 s_CURLOPT_POSTREDIR.get(), k_CURLOPT_POSTREDIR
2503 );
2504 Native::registerConstant<KindOfInt64>(
2505 s_CURLOPT_POSTQUOTE.get(), k_CURLOPT_POSTQUOTE
2506 );
2507 Native::registerConstant<KindOfInt64>(
2508 s_CURLOPT_PRIVATE.get(), k_CURLOPT_PRIVATE
2509 );
2510 Native::registerConstant<KindOfInt64>(
2511 s_CURLOPT_PROGRESSFUNCTION.get(), k_CURLOPT_PROGRESSFUNCTION
2512 );
2513 Native::registerConstant<KindOfInt64>(
2514 s_CURLOPT_PROXY.get(), k_CURLOPT_PROXY
2515 );
2516 Native::registerConstant<KindOfInt64>(
2517 s_CURLOPT_PROXYAUTH.get(), k_CURLOPT_PROXYAUTH
2518 );
2519 Native::registerConstant<KindOfInt64>(
2520 s_CURLOPT_PROXYPORT.get(), k_CURLOPT_PROXYPORT
2521 );
2522 Native::registerConstant<KindOfInt64>(
2523 s_CURLOPT_PROXYTYPE.get(), k_CURLOPT_PROXYTYPE
2524 );
2525 Native::registerConstant<KindOfInt64>(
2526 s_CURLOPT_PROXYUSERPWD.get(), k_CURLOPT_PROXYUSERPWD
2527 );
2528 Native::registerConstant<KindOfInt64>(
2529 s_CURLOPT_PUT.get(), k_CURLOPT_PUT
2530 );
2531 Native::registerConstant<KindOfInt64>(
2532 s_CURLOPT_QUOTE.get(), k_CURLOPT_QUOTE
2533 );
2534 Native::registerConstant<KindOfInt64>(
2535 s_CURLOPT_RANDOM_FILE.get(), k_CURLOPT_RANDOM_FILE
2536 );
2537 Native::registerConstant<KindOfInt64>(
2538 s_CURLOPT_RANGE.get(), k_CURLOPT_RANGE
2539 );
2540 Native::registerConstant<KindOfInt64>(
2541 s_CURLOPT_READDATA.get(), k_CURLOPT_READDATA
2542 );
2543 Native::registerConstant<KindOfInt64>(
2544 s_CURLOPT_READFUNCTION.get(), k_CURLOPT_READFUNCTION
2545 );
2546 Native::registerConstant<KindOfInt64>(
2547 s_CURLOPT_REFERER.get(), k_CURLOPT_REFERER
2548 );
2549 Native::registerConstant<KindOfInt64>(
2550 s_CURLOPT_RESUME_FROM.get(), k_CURLOPT_RESUME_FROM
2551 );
2552 Native::registerConstant<KindOfInt64>(
2553 s_CURLOPT_RETURNTRANSFER.get(), k_CURLOPT_RETURNTRANSFER
2554 );
2555 Native::registerConstant<KindOfInt64>(
2556 s_CURLOPT_SSLCERT.get(), k_CURLOPT_SSLCERT
2557 );
2558 Native::registerConstant<KindOfInt64>(
2559 s_CURLOPT_SSLCERTPASSWD.get(), k_CURLOPT_SSLCERTPASSWD
2560 );
2561 Native::registerConstant<KindOfInt64>(
2562 s_CURLOPT_SSLCERTTYPE.get(), k_CURLOPT_SSLCERTTYPE
2563 );
2564 Native::registerConstant<KindOfInt64>(
2565 s_CURLOPT_SSLENGINE.get(), k_CURLOPT_SSLENGINE
2566 );
2567 Native::registerConstant<KindOfInt64>(
2568 s_CURLOPT_SSLENGINE_DEFAULT.get(), k_CURLOPT_SSLENGINE_DEFAULT
2569 );
2570 Native::registerConstant<KindOfInt64>(
2571 s_CURLOPT_SSLKEY.get(), k_CURLOPT_SSLKEY
2572 );
2573 Native::registerConstant<KindOfInt64>(
2574 s_CURLOPT_SSLKEYPASSWD.get(), k_CURLOPT_SSLKEYPASSWD
2575 );
2576 Native::registerConstant<KindOfInt64>(
2577 s_CURLOPT_SSLKEYTYPE.get(), k_CURLOPT_SSLKEYTYPE
2578 );
2579 Native::registerConstant<KindOfInt64>(
2580 s_CURLOPT_SSLVERSION.get(), k_CURLOPT_SSLVERSION
2581 );
2582 Native::registerConstant<KindOfInt64>(
2583 s_CURLOPT_SSL_CIPHER_LIST.get(), k_CURLOPT_SSL_CIPHER_LIST
2584 );
2585 Native::registerConstant<KindOfInt64>(
2586 s_CURLOPT_SSL_VERIFYHOST.get(), k_CURLOPT_SSL_VERIFYHOST
2587 );
2588 Native::registerConstant<KindOfInt64>(
2589 s_CURLOPT_SSL_VERIFYPEER.get(), k_CURLOPT_SSL_VERIFYPEER
2590 );
2591 Native::registerConstant<KindOfInt64>(
2592 s_CURLOPT_STDERR.get(), k_CURLOPT_STDERR
2593 );
2594 Native::registerConstant<KindOfInt64>(
2595 s_CURLOPT_TCP_NODELAY.get(), k_CURLOPT_TCP_NODELAY
2596 );
2597 Native::registerConstant<KindOfInt64>(
2598 s_CURLOPT_TIMECONDITION.get(), k_CURLOPT_TIMECONDITION
2599 );
2600 Native::registerConstant<KindOfInt64>(
2601 s_CURLOPT_TIMEOUT.get(), k_CURLOPT_TIMEOUT
2602 );
2603 Native::registerConstant<KindOfInt64>(
2604 s_CURLOPT_TIMEVALUE.get(), k_CURLOPT_TIMEVALUE
2605 );
2606 Native::registerConstant<KindOfInt64>(
2607 s_CURLOPT_TRANSFERTEXT.get(), k_CURLOPT_TRANSFERTEXT
2608 );
2609 Native::registerConstant<KindOfInt64>(
2610 s_CURLOPT_UNRESTRICTED_AUTH.get(), k_CURLOPT_UNRESTRICTED_AUTH
2611 );
2612 Native::registerConstant<KindOfInt64>(
2613 s_CURLOPT_UPLOAD.get(), k_CURLOPT_UPLOAD
2614 );
2615 Native::registerConstant<KindOfInt64>(
2616 s_CURLOPT_URL.get(), k_CURLOPT_URL
2617 );
2618 Native::registerConstant<KindOfInt64>(
2619 s_CURLOPT_USERAGENT.get(), k_CURLOPT_USERAGENT
2620 );
2621 Native::registerConstant<KindOfInt64>(
2622 s_CURLOPT_USERPWD.get(), k_CURLOPT_USERPWD
2623 );
2624 Native::registerConstant<KindOfInt64>(
2625 s_CURLOPT_VERBOSE.get(), k_CURLOPT_VERBOSE
2626 );
2627 Native::registerConstant<KindOfInt64>(
2628 s_CURLOPT_WRITEFUNCTION.get(), k_CURLOPT_WRITEFUNCTION
2629 );
2630 Native::registerConstant<KindOfInt64>(
2631 s_CURLOPT_WRITEHEADER.get(), k_CURLOPT_WRITEHEADER
2632 );
2633 Native::registerConstant<KindOfInt64>(
2634 s_CURLOPT_FB_TLS_VER_MAX.get(), k_CURLOPT_FB_TLS_VER_MAX
2635 );
2636 Native::registerConstant<KindOfInt64>(
2637 s_CURLOPT_FB_TLS_VER_MAX_NONE.get(), k_CURLOPT_FB_TLS_VER_MAX_NONE
2638 );
2639 Native::registerConstant<KindOfInt64>(
2640 s_CURLOPT_FB_TLS_VER_MAX_1_1.get(), k_CURLOPT_FB_TLS_VER_MAX_1_1
2641 );
2642 Native::registerConstant<KindOfInt64>(
2643 s_CURLOPT_FB_TLS_VER_MAX_1_0.get(), k_CURLOPT_FB_TLS_VER_MAX_1_0
2644 );
2645 Native::registerConstant<KindOfInt64>(
2646 s_CURLOPT_FB_TLS_CIPHER_SPEC.get(), k_CURLOPT_FB_TLS_CIPHER_SPEC
2647 );
2648 Native::registerConstant<KindOfInt64>(
2649 s_CURLPROXY_HTTP.get(), k_CURLPROXY_HTTP
2650 );
2651 Native::registerConstant<KindOfInt64>(
2652 s_CURLPROXY_SOCKS5.get(), k_CURLPROXY_SOCKS5
2653 );
2654 Native::registerConstant<KindOfInt64>(
2655 s_CURLVERSION_NOW.get(), k_CURLVERSION_NOW
2656 );
2657 Native::registerConstant<KindOfInt64>(
2658 s_CURL_HTTP_VERSION_1_0.get(), k_CURL_HTTP_VERSION_1_0
2659 );
2660 Native::registerConstant<KindOfInt64>(
2661 s_CURL_HTTP_VERSION_1_1.get(), k_CURL_HTTP_VERSION_1_1
2662 );
2663 Native::registerConstant<KindOfInt64>(
2664 s_CURL_HTTP_VERSION_NONE.get(), k_CURL_HTTP_VERSION_NONE
2665 );
2666 Native::registerConstant<KindOfInt64>(
2667 s_CURL_IPRESOLVE_V4.get(), k_CURL_IPRESOLVE_V4
2668 );
2669 Native::registerConstant<KindOfInt64>(
2670 s_CURL_IPRESOLVE_V6.get(), k_CURL_IPRESOLVE_V6
2671 );
2672 Native::registerConstant<KindOfInt64>(
2673 s_CURL_IPRESOLVE_WHATEVER.get(), k_CURL_IPRESOLVE_WHATEVER
2674 );
2675 Native::registerConstant<KindOfInt64>(
2676 s_CURL_NETRC_IGNORED.get(), k_CURL_NETRC_IGNORED
2677 );
2678 Native::registerConstant<KindOfInt64>(
2679 s_CURL_NETRC_OPTIONAL.get(), k_CURL_NETRC_OPTIONAL
2680 );
2681 Native::registerConstant<KindOfInt64>(
2682 s_CURL_NETRC_REQUIRED.get(), k_CURL_NETRC_REQUIRED
2683 );
2684 Native::registerConstant<KindOfInt64>(
2685 s_CURL_TIMECOND_IFMODSINCE.get(), k_CURL_TIMECOND_IFMODSINCE
2686 );
2687 Native::registerConstant<KindOfInt64>(
2688 s_CURL_TIMECOND_IFUNMODSINCE.get(), k_CURL_TIMECOND_IFUNMODSINCE
2689 );
2690 Native::registerConstant<KindOfInt64>(
2691 s_CURL_TIMECOND_LASTMOD.get(), k_CURL_TIMECOND_LASTMOD
2692 );
2693 Native::registerConstant<KindOfInt64>(
2694 s_CURL_VERSION_IPV6.get(), k_CURL_VERSION_IPV6
2695 );
2696 Native::registerConstant<KindOfInt64>(
2697 s_CURL_VERSION_KERBEROS4.get(), k_CURL_VERSION_KERBEROS4
2698 );
2699 Native::registerConstant<KindOfInt64>(
2700 s_CURL_VERSION_LIBZ.get(), k_CURL_VERSION_LIBZ
2701 );
2702 Native::registerConstant<KindOfInt64>(
2703 s_CURL_VERSION_SSL.get(), k_CURL_VERSION_SSL
2704 );
2705
2706 HHVM_FE(curl_init);
2707 HHVM_FE(curl_copy_handle);
2708 HHVM_FE(curl_version);
2709 HHVM_FE(curl_setopt);
2710 HHVM_FE(curl_setopt_array);
2711 HHVM_FE(fb_curl_getopt);
2712 HHVM_FE(curl_exec);
2713 HHVM_FE(curl_getinfo);
2714 HHVM_FE(curl_errno);
2715 HHVM_FE(curl_error);
2716 HHVM_FE(curl_close);
2717 HHVM_FE(curl_multi_init);
2718 HHVM_FE(curl_multi_add_handle);
2719 HHVM_FE(curl_multi_remove_handle);
2720 HHVM_FE(curl_multi_exec);
2721 HHVM_FE(curl_multi_select);
2722 HHVM_FE(curl_multi_getcontent);
2723 HHVM_FE(fb_curl_multi_fdset);
2724 HHVM_FE(curl_multi_info_read);
2725 HHVM_FE(curl_multi_close);
2726
2727 loadSystemlib();
2728 }
2729 } s_curl_extension;
2730
2731 }