curl-helper.c

   1 /***
   2  ***  curl-helper.c
   3  ***
   4  ***  Copyright (c) 2003-2008, Lars Nilsson, <lars@quantumchamaeleon.com>
   5  ***  Copyright (c) 2009, ygrek, <ygrek@autistici.org>
   6  ***/
   7
   8 #include <stdio.h>
   9 #include <string.h>
  10 #include <stdlib.h>
  11 #include <stdarg.h>
  12 #include <unistd.h>
  13 /* suppress false gcc warning on seekFunction */
  14 #define CURL_DISABLE_TYPECHECK
  15 #include <curl/curl.h>
  16
  17 #define CAML_NAME_SPACE
  18 #include <caml/alloc.h>
  19 #include <caml/memory.h>
  20 #include <caml/mlvalues.h>
  21 #include <caml/callback.h>
  22 #include <caml/fail.h>
  23 #include <caml/unixsupport.h>
  24 #include <caml/custom.h>
  25 #include <caml/threads.h>
  26
  27 #ifndef CAMLdrop
  28 #define CAMLdrop caml_local_roots = caml__frame
  29 #endif
  30
  31 #ifdef HAVE_CONFIG_H
  32 #include "config.h"
  33 #else
  34 #pragma message("No config file given.")
  35 #endif
  36
  37 #define Val_none Val_int(0)
  38
  39 static __inline value
  40 Val_some( value v )
  41 {
  42     CAMLparam1( v );
  43     CAMLlocal1( some );
  44     some = caml_alloc(1, 0);
  45     Store_field( some, 0, v );
  46     CAMLreturn( some );
  47 }
  48
  49 static value Val_pair(value v1, value v2)
  50 {
  51   CAMLparam2(v1,v2);
  52   CAMLlocal1(pair);
  53   pair = caml_alloc_small(2,0);
  54   Field(pair,0) = v1;
  55   Field(pair,1) = v2;
  56   CAMLreturn(pair);
  57 }
  58
  59 static value Val_cons(value list, value v) { return Val_pair(v,list); }
  60
  61 typedef struct Connection Connection;
  62 typedef struct ConnectionList ConnectionList;
  63
  64 #define Connection_val(v) (*(Connection**)Data_custom_val(v))
  65
  66 typedef enum OcamlValues
  67 {
  68     Ocaml_WRITEFUNCTION,
  69     Ocaml_READFUNCTION,
  70     Ocaml_ERRORBUFFER,
  71     Ocaml_POSTFIELDS,
  72     Ocaml_HTTPHEADER,
  73     Ocaml_HTTPPOST,
  74     Ocaml_QUOTE,
  75     Ocaml_POSTQUOTE,
  76     Ocaml_HEADERFUNCTION,
  77     Ocaml_PROGRESSFUNCTION,
  78     Ocaml_DEBUGFUNCTION,
  79     Ocaml_HTTP200ALIASES,
  80     Ocaml_IOCTLFUNCTION,
  81     Ocaml_SEEKFUNCTION,
  82     Ocaml_OPENSOCKETFUNCTION,
  83
  84     Ocaml_URL,
  85     Ocaml_PROXY,
  86     Ocaml_USERPWD,
  87     Ocaml_PROXYUSERPWD,
  88     Ocaml_RANGE,
  89     Ocaml_REFERER,
  90     Ocaml_USERAGENT,
  91     Ocaml_FTPPORT,
  92     Ocaml_COOKIE,
  93     Ocaml_HTTPPOSTSTRINGS,
  94     Ocaml_SSLCERT,
  95     Ocaml_SSLCERTTYPE,
  96     Ocaml_SSLCERTPASSWD,
  97     Ocaml_SSLKEY,
  98     Ocaml_SSLKEYTYPE,
  99     Ocaml_SSLKEYPASSWD,
 100     Ocaml_SSLENGINE,
 101     Ocaml_COOKIEFILE,
 102     Ocaml_CUSTOMREQUEST,
 103     Ocaml_INTERFACE,
 104     Ocaml_CAINFO,
 105     Ocaml_CAPATH,
 106     Ocaml_RANDOM_FILE,
 107     Ocaml_EGDSOCKET,
 108     Ocaml_COOKIEJAR,
 109     Ocaml_SSL_CIPHER_LIST,
 110     Ocaml_PRIVATE,
 111     Ocaml_NETRC_FILE,
 112     Ocaml_FTP_ACCOUNT,
 113     Ocaml_COOKIELIST,
 114     Ocaml_FTP_ALTERNATIVE_TO_USER,
 115     Ocaml_SSH_PUBLIC_KEYFILE,
 116     Ocaml_SSH_PRIVATE_KEYFILE,
 117     Ocaml_SSH_HOST_PUBLIC_KEY_MD5,
 118     Ocaml_COPYPOSTFIELDS,
 119     Ocaml_DNS_SERVERS,
 120     Ocaml_MAIL_FROM,
 121     Ocaml_MAIL_RCPT,
 122     Ocaml_RESOLVE,
 123
 124     /* Not used, last for size */
 125     OcamlValuesSize
 126 } OcamlValue;
 127
 128 struct Connection
 129 {
 130     CURL *handle;
 131
 132     value ocamlValues;
 133
 134     size_t refcount; /* number of references to this structure */
 135
 136     char *curl_URL;
 137     char *curl_PROXY;
 138     char *curl_USERPWD;
 139     char *curl_PROXYUSERPWD;
 140     char *curl_RANGE;
 141     char *curl_ERRORBUFFER;
 142     char *curl_POSTFIELDS;
 143     int curl_POSTFIELDSIZE;
 144     char *curl_REFERER;
 145     char *curl_USERAGENT;
 146     char *curl_FTPPORT;
 147     char *curl_COOKIE;
 148     struct curl_slist *curl_HTTPHEADER;
 149     struct curl_slist *httpPostBuffers;
 150     struct curl_httppost *httpPostFirst;
 151     struct curl_httppost *httpPostLast;
 152     struct curl_slist *curl_RESOLVE;
 153     char *curl_SSLCERT;
 154     char *curl_SSLCERTTYPE;
 155     char *curl_SSLCERTPASSWD;
 156     char *curl_SSLKEY;
 157     char *curl_SSLKEYTYPE;
 158     char *curl_SSLKEYPASSWD;
 159     char *curl_SSLENGINE;
 160     struct curl_slist *curl_QUOTE;
 161     struct curl_slist *curl_POSTQUOTE;
 162     char *curl_COOKIEFILE;
 163     char *curl_CUSTOMREQUEST;
 164     char *curl_INTERFACE;
 165     char *curl_CAINFO;
 166     char *curl_CAPATH;
 167     char *curl_RANDOM_FILE;
 168     char *curl_EGDSOCKET;
 169     char *curl_COOKIEJAR;
 170     char *curl_SSL_CIPHER_LIST;
 171     struct curl_slist *curl_HTTP200ALIASES;
 172     char *curl_NETRC_FILE;
 173     char *curl_FTP_ACCOUNT;
 174     char *curl_COOKIELIST;
 175     char *curl_FTP_ALTERNATIVE_TO_USER;
 176     char *curl_SSH_PUBLIC_KEYFILE;
 177     char *curl_SSH_PRIVATE_KEYFILE;
 178     char *curl_SSH_HOST_PUBLIC_KEY_MD5;
 179     char *curl_COPYPOSTFIELDS;
 180     char *curl_DNS_SERVERS;
 181     char *curl_MAIL_FROM;
 182     struct curl_slist *curl_MAIL_RCPT;
 183 };
 184
 185 typedef struct CURLErrorMapping CURLErrorMapping;
 186
 187 struct CURLErrorMapping
 188 {
 189     char *name;
 190     CURLcode error;
 191 };
 192
 193 CURLErrorMapping errorMap[] =
 194 {
 195     {"CURLE_OK", CURLE_OK},
 196 #if HAVE_DECL_CURLE_UNSUPPORTED_PROTOCOL
 197     {"CURLE_UNSUPPORTED_PROTOCOL", CURLE_UNSUPPORTED_PROTOCOL},
 198 #else
 199     {"CURLE_UNSUPPORTED_PROTOCOL", -1},
 200 #endif
 201 #if HAVE_DECL_CURLE_FAILED_INIT
 202     {"CURLE_FAILED_INIT", CURLE_FAILED_INIT},
 203 #else
 204     {"CURLE_FAILED_INIT", -1},
 205 #endif
 206 #if HAVE_DECL_CURLE_URL_MALFORMAT
 207     {"CURLE_URL_MALFORMAT", CURLE_URL_MALFORMAT},
 208 #else
 209     {"CURLE_URL_MALFORMAT", -1},
 210 #endif
 211 #if HAVE_DECL_CURLE_URL_MALFORMAT_USER
 212     {"CURLE_URL_MALFORMAT_USER", CURLE_URL_MALFORMAT_USER},
 213 #else
 214     {"CURLE_URL_MALFORMAT_USER", -1},
 215 #endif
 216 #if HAVE_DECL_CURLE_COULDNT_RESOLVE_PROXY
 217     {"CURLE_COULDNT_RESOLVE_PROXY", CURLE_COULDNT_RESOLVE_PROXY},
 218 #else
 219     {"CURLE_COULDNT_RESOLVE_PROXY", -1},
 220 #endif
 221 #if HAVE_DECL_CURLE_COULDNT_RESOLVE_HOST
 222     {"CURLE_COULDNT_RESOLVE_HOST", CURLE_COULDNT_RESOLVE_HOST},
 223 #else
 224     {"CURLE_COULDNT_RESOLVE_HOST", -1},
 225 #endif
 226 #if HAVE_DECL_CURLE_COULDNT_CONNECT
 227     {"CURLE_COULDNT_CONNECT", CURLE_COULDNT_CONNECT},
 228 #else
 229     {"CURLE_COULDNT_CONNECT", -1},
 230 #endif
 231 #if HAVE_DECL_CURLE_FTP_WEIRD_SERVER_REPLY
 232     {"CURLE_FTP_WEIRD_SERVER_REPLY", CURLE_FTP_WEIRD_SERVER_REPLY},
 233 #else
 234     {"CURLE_FTP_WEIRD_SERVER_REPLY", -1},
 235 #endif
 236 #if HAVE_DECL_CURLE_FTP_ACCESS_DENIED
 237     {"CURLE_FTP_ACCESS_DENIED", CURLE_FTP_ACCESS_DENIED},
 238 #else
 239     {"CURLE_FTP_ACCESS_DENIED", -1},
 240 #endif
 241 #if HAVE_DECL_CURLE_FTP_USER_PASSWORD_INCORRECT
 242     {"CURLE_FTP_USER_PASSWORD_INCORRECT", CURLE_FTP_USER_PASSWORD_INCORRECT},
 243 #else
 244     {"CURLE_FTP_USER_PASSWORD_INCORRECT", -1},
 245 #endif
 246 #if HAVE_DECL_CURLE_FTP_WEIRD_PASS_REPLY
 247     {"CURLE_FTP_WEIRD_PASS_REPLY", CURLE_FTP_WEIRD_PASS_REPLY},
 248 #else
 249     {"CURLE_FTP_WEIRD_PASS_REPLY", -1},
 250 #endif
 251 #if HAVE_DECL_CURLE_FTP_WEIRD_USER_REPLY
 252     {"CURLE_FTP_WEIRD_USER_REPLY", CURLE_FTP_WEIRD_USER_REPLY},
 253 #else
 254     {"CURLE_FTP_WEIRD_USER_REPLY", -1},
 255 #endif
 256 #if HAVE_DECL_CURLE_FTP_WEIRD_PASV_REPLY
 257     {"CURLE_FTP_WEIRD_PASV_REPLY", CURLE_FTP_WEIRD_PASV_REPLY},
 258 #else
 259     {"CURLE_FTP_WEIRD_PASV_REPLY", -1},
 260 #endif
 261 #if HAVE_DECL_CURLE_FTP_WEIRD_227_FORMAT
 262     {"CURLE_FTP_WEIRD_227_FORMAT", CURLE_FTP_WEIRD_227_FORMAT},
 263 #else
 264     {"CURLE_FTP_WEIRD_227_FORMAT", -1},
 265 #endif
 266 #if HAVE_DECL_CURLE_FTP_CANT_GET_HOST
 267     {"CURLE_FTP_CANT_GET_HOST", CURLE_FTP_CANT_GET_HOST},
 268 #else
 269     {"CURLE_FTP_CANT_GET_HOST", -1},
 270 #endif
 271 #if HAVE_DECL_CURLE_FTP_CANT_RECONNECT
 272     {"CURLE_FTP_CANT_RECONNECT", CURLE_FTP_CANT_RECONNECT},
 273 #else
 274     {"CURLE_FTP_CANT_RECONNECT", -1},
 275 #endif
 276 #if HAVE_DECL_CURLE_FTP_COULDNT_SET_BINARY
 277     {"CURLE_FTP_COULDNT_SET_BINARY", CURLE_FTP_COULDNT_SET_BINARY},
 278 #else
 279     {"CURLE_FTP_COULDNT_SET_BINARY", -1},
 280 #endif
 281 #if HAVE_DECL_CURLE_PARTIAL_FILE
 282     {"CURLE_PARTIAL_FILE", CURLE_PARTIAL_FILE},
 283 #else
 284     {"CURLE_PARTIAL_FILE", -1},
 285 #endif
 286 #if HAVE_DECL_CURLE_FTP_COULDNT_RETR_FILE
 287     {"CURLE_FTP_COULDNT_RETR_FILE", CURLE_FTP_COULDNT_RETR_FILE},
 288 #else
 289     {"CURLE_FTP_COULDNT_RETR_FILE", -1},
 290 #endif
 291 #if HAVE_DECL_CURLE_FTP_WRITE_ERROR
 292     {"CURLE_FTP_WRITE_ERROR", CURLE_FTP_WRITE_ERROR},
 293 #else
 294     {"CURLE_FTP_WRITE_ERROR", -1},
 295 #endif
 296 #if HAVE_DECL_CURLE_FTP_QUOTE_ERROR
 297     {"CURLE_FTP_QUOTE_ERROR", CURLE_FTP_QUOTE_ERROR},
 298 #else
 299     {"CURLE_FTP_QUOTE_ERROR", -1},
 300 #endif
 301 #if HAVE_DECL_CURLE_HTTP_RETURNED_ERROR
 302     {"CURLE_HTTP_RETURNED_ERROR", CURLE_HTTP_RETURNED_ERROR},
 303 #else
 304     {"CURLE_HTTP_RETURNED_ERROR", -1},
 305 #endif
 306 #if HAVE_DECL_CURLE_WRITE_ERROR
 307     {"CURLE_WRITE_ERROR", CURLE_WRITE_ERROR},
 308 #else
 309     {"CURLE_WRITE_ERROR", -1},
 310 #endif
 311 #if HAVE_DECL_CURLE_MALFORMAT_USER
 312     {"CURLE_MALFORMAT_USER", CURLE_MALFORMAT_USER},
 313 #else
 314     {"CURLE_MALFORMAT_USER", -1},
 315 #endif
 316 #if HAVE_DECL_CURLE_FTP_COULDNT_STOR_FILE
 317     {"CURLE_FTP_COULDNT_STOR_FILE", CURLE_FTP_COULDNT_STOR_FILE},
 318 #else
 319     {"CURLE_FTP_COULDNT_STOR_FILE", -1},
 320 #endif
 321 #if HAVE_DECL_CURLE_READ_ERROR
 322     {"CURLE_READ_ERROR", CURLE_READ_ERROR},
 323 #else
 324     {"CURLE_READ_ERROR", -1},
 325 #endif
 326 #if HAVE_DECL_CURLE_OUT_OF_MEMORY
 327     {"CURLE_OUT_OF_MEMORY", CURLE_OUT_OF_MEMORY},
 328 #else
 329     {"CURLE_OUT_OF_MEMORY", -1},
 330 #endif
 331 #if HAVE_DECL_CURLE_OPERATION_TIMEOUTED
 332     {"CURLE_OPERATION_TIMEOUTED", CURLE_OPERATION_TIMEOUTED},
 333 #else
 334     {"CURLE_OPERATION_TIMEOUTED", -1},
 335 #endif
 336 #if HAVE_DECL_CURLE_FTP_COULDNT_SET_ASCII
 337     {"CURLE_FTP_COULDNT_SET_ASCII", CURLE_FTP_COULDNT_SET_ASCII},
 338 #else
 339     {"CURLE_FTP_COULDNT_SET_ASCII", -1},
 340 #endif
 341 #if HAVE_DECL_CURLE_FTP_PORT_FAILED
 342     {"CURLE_FTP_PORT_FAILED", CURLE_FTP_PORT_FAILED},
 343 #else
 344     {"CURLE_FTP_PORT_FAILED", -1},
 345 #endif
 346 #if HAVE_DECL_CURLE_FTP_COULDNT_USE_REST
 347     {"CURLE_FTP_COULDNT_USE_REST", CURLE_FTP_COULDNT_USE_REST},
 348 #else
 349     {"CURLE_FTP_COULDNT_USE_REST", -1},
 350 #endif
 351 #if HAVE_DECL_CURLE_FTP_COULDNT_GET_SIZE
 352     {"CURLE_FTP_COULDNT_GET_SIZE", CURLE_FTP_COULDNT_GET_SIZE},
 353 #else
 354     {"CURLE_FTP_COULDNT_GET_SIZE", -1},
 355 #endif
 356 #if HAVE_DECL_CURLE_HTTP_RANGE_ERROR
 357     {"CURLE_HTTP_RANGE_ERROR", CURLE_HTTP_RANGE_ERROR},
 358 #else
 359     {"CURLE_HTTP_RANGE_ERROR", -1},
 360 #endif
 361 #if HAVE_DECL_CURLE_HTTP_POST_ERROR
 362     {"CURLE_HTTP_POST_ERROR", CURLE_HTTP_POST_ERROR},
 363 #else
 364     {"CURLE_HTTP_POST_ERROR", -1},
 365 #endif
 366 #if HAVE_DECL_CURLE_SSL_CONNECT_ERROR
 367     {"CURLE_SSL_CONNECT_ERROR", CURLE_SSL_CONNECT_ERROR},
 368 #else
 369     {"CURLE_SSL_CONNECT_ERROR", -1},
 370 #endif
 371 #if HAVE_DECL_CURLE_BAD_DOWNLOAD_RESUME
 372     {"CURLE_BAD_DOWNLOAD_RESUME", CURLE_BAD_DOWNLOAD_RESUME},
 373 #else
 374     {"CURLE_BAD_DOWNLOAD_RESUME", -1},
 375 #endif
 376 #if HAVE_DECL_CURLE_FILE_COULDNT_READ_FILE
 377     {"CURLE_FILE_COULDNT_READ_FILE", CURLE_FILE_COULDNT_READ_FILE},
 378 #else
 379     {"CURLE_FILE_COULDNT_READ_FILE", -1},
 380 #endif
 381 #if HAVE_DECL_CURLE_LDAP_CANNOT_BIND
 382     {"CURLE_LDAP_CANNOT_BIND", CURLE_LDAP_CANNOT_BIND},
 383 #else
 384     {"CURLE_LDAP_CANNOT_BIND", -1},
 385 #endif
 386 #if HAVE_DECL_CURLE_LDAP_SEARCH_FAILED
 387     {"CURLE_LDAP_SEARCH_FAILED", CURLE_LDAP_SEARCH_FAILED},
 388 #else
 389     {"CURLE_LDAP_SEARCH_FAILED", -1},
 390 #endif
 391 #if HAVE_DECL_CURLE_LIBRARY_NOT_FOUND
 392     {"CURLE_LIBRARY_NOT_FOUND", CURLE_LIBRARY_NOT_FOUND},
 393 #else
 394     {"CURLE_LIBRARY_NOT_FOUND", -1},
 395 #endif
 396 #if HAVE_DECL_CURLE_FUNCTION_NOT_FOUND
 397     {"CURLE_FUNCTION_NOT_FOUND", CURLE_FUNCTION_NOT_FOUND},
 398 #else
 399     {"CURLE_FUNCTION_NOT_FOUND", -1},
 400 #endif
 401 #if HAVE_DECL_CURLE_ABORTED_BY_CALLBACK
 402     {"CURLE_ABORTED_BY_CALLBACK", CURLE_ABORTED_BY_CALLBACK},
 403 #else
 404     {"CURLE_ABORTED_BY_CALLBACK", -1},
 405 #endif
 406 #if HAVE_DECL_CURLE_BAD_FUNCTION_ARGUMENT
 407     {"CURLE_BAD_FUNCTION_ARGUMENT", CURLE_BAD_FUNCTION_ARGUMENT},
 408 #else
 409     {"CURLE_BAD_FUNCTION_ARGUMENT", -1},
 410 #endif
 411 #if HAVE_DECL_CURLE_BAD_CALLING_ORDER
 412     {"CURLE_BAD_CALLING_ORDER", CURLE_BAD_CALLING_ORDER},
 413 #else
 414     {"CURLE_BAD_CALLING_ORDER", -1},
 415 #endif
 416 #if HAVE_DECL_CURLE_INTERFACE_FAILED
 417     {"CURLE_INTERFACE_FAILED", CURLE_INTERFACE_FAILED},
 418 #else
 419     {"CURLE_INTERFACE_FAILED", -1},
 420 #endif
 421 #if HAVE_DECL_CURLE_BAD_PASSWORD_ENTERED
 422     {"CURLE_BAD_PASSWORD_ENTERED", CURLE_BAD_PASSWORD_ENTERED},
 423 #else
 424     {"CURLE_BAD_PASSWORD_ENTERED", -1},
 425 #endif
 426 #if HAVE_DECL_CURLE_TOO_MANY_REDIRECTS
 427     {"CURLE_TOO_MANY_REDIRECTS", CURLE_TOO_MANY_REDIRECTS},
 428 #else
 429     {"CURLE_TOO_MANY_REDIRECTS", -1},
 430 #endif
 431 #if HAVE_DECL_CURLE_UNKNOWN_TELNET_OPTION
 432     {"CURLE_UNKNOWN_TELNET_OPTION", CURLE_UNKNOWN_TELNET_OPTION},
 433 #else
 434     {"CURLE_UNKNOWN_TELNET_OPTION", -1},
 435 #endif
 436 #if HAVE_DECL_CURLE_TELNET_OPTION_SYNTAX
 437     {"CURLE_TELNET_OPTION_SYNTAX", CURLE_TELNET_OPTION_SYNTAX},
 438 #else
 439     {"CURLE_TELNET_OPTION_SYNTAX", -1},
 440 #endif
 441 #if HAVE_DECL_CURLE_SSL_PEER_CERTIFICATE
 442     {"CURLE_SSL_PEER_CERTIFICATE", CURLE_SSL_PEER_CERTIFICATE},
 443 #else
 444     {"CURLE_SSL_PEER_CERTIFICATE", -1},
 445 #endif
 446 #if HAVE_DECL_CURLE_GOT_NOTHING
 447     {"CURLE_GOT_NOTHING", CURLE_GOT_NOTHING},
 448 #else
 449     {"CURLE_GOT_NOTHING", -1},
 450 #endif
 451 #if HAVE_DECL_CURLE_SSL_ENGINE_NOTFOUND
 452     {"CURLE_SSL_ENGINE_NOTFOUND", CURLE_SSL_ENGINE_NOTFOUND},
 453 #else
 454     {"CURLE_SSL_ENGINE_NOTFOUND", -1},
 455 #endif
 456 #if HAVE_DECL_CURLE_SSL_ENGINE_SETFAILED
 457     {"CURLE_SSL_ENGINE_SETFAILED", CURLE_SSL_ENGINE_SETFAILED},
 458 #else
 459     {"CURLE_SSL_ENGINE_SETFAILED", -1},
 460 #endif
 461 #if HAVE_DECL_CURLE_SEND_ERROR
 462     {"CURLE_SEND_ERROR", CURLE_SEND_ERROR},
 463 #else
 464     {"CURLE_SEND_ERROR", -1},
 465 #endif
 466 #if HAVE_DECL_CURLE_RECV_ERROR
 467     {"CURLE_RECV_ERROR", CURLE_RECV_ERROR},
 468 #else
 469     {"CURLE_RECV_ERROR", -1},
 470 #endif
 471 #if HAVE_DECL_CURLE_SHARE_IN_USE
 472     {"CURLE_SHARE_IN_USE", CURLE_SHARE_IN_USE},
 473 #else
 474     {"CURLE_SHARE_IN_USE", -1},
 475 #endif
 476 #if HAVE_DECL_CURLE_SSL_CERTPROBLEM
 477     {"CURLE_SSL_CERTPROBLEM", CURLE_SSL_CERTPROBLEM},
 478 #else
 479     {"CURLE_SSL_CERTPROBLEM", -1},
 480 #endif
 481 #if HAVE_DECL_CURLE_SSL_CIPHER
 482     {"CURLE_SSL_CIPHER", CURLE_SSL_CIPHER},
 483 #else
 484     {"CURLE_SSL_CIPHER", -1},
 485 #endif
 486 #if HAVE_DECL_CURLE_SSL_CACERT
 487     {"CURLE_SSL_CACERT", CURLE_SSL_CACERT},
 488 #else
 489     {"CURLE_SSL_CACERT", -1},
 490 #endif
 491 #if HAVE_DECL_CURLE_BAD_CONTENT_ENCODING
 492     {"CURLE_BAD_CONTENT_ENCODING", CURLE_BAD_CONTENT_ENCODING},
 493 #else
 494     {"CURLE_BAD_CONTENT_ENCODING", -1},
 495 #endif
 496 #if HAVE_DECL_CURLE_LDAP_INVALID_URL
 497     {"CURLE_LDAP_INVALID_URL", CURLE_LDAP_INVALID_URL},
 498 #else
 499     {"CURLE_LDAP_INVALID_URL", -1},
 500 #endif
 501 #if HAVE_DECL_CURLE_FILESIZE_EXCEEDED
 502     {"CURLE_FILESIZE_EXCEEDED", CURLE_FILESIZE_EXCEEDED},
 503 #else
 504     {"CURLE_FILESIZE_EXCEEDED", -1},
 505 #endif
 506 #if HAVE_DECL_CURLE_FTP_SSL_FAILED
 507     {"CURLE_FTP_SSL_FAILED", CURLE_FTP_SSL_FAILED},
 508 #else
 509     {"CURLE_FTP_SSL_FAILED", -1},
 510 #endif
 511 #if HAVE_DECL_CURLE_SEND_FAIL_REWIND
 512     {"CURLE_SEND_FAIL_REWIND", CURLE_SEND_FAIL_REWIND},
 513 #else
 514     {"CURLE_SEND_FAIL_REWIND", -1},
 515 #endif
 516 #if HAVE_DECL_CURLE_SSL_ENGINE_INITFAILED
 517     {"CURLE_SSL_ENGINE_INITFAILED", CURLE_SSL_ENGINE_INITFAILED},
 518 #else
 519     {"CURLE_SSL_ENGINE_INITFAILED", -1},
 520 #endif
 521 #if HAVE_DECL_CURLE_LOGIN_DENIED
 522     {"CURLE_LOGIN_DENIED", CURLE_LOGIN_DENIED},
 523 #else
 524     {"CURLE_LOGIN_DENIED", -1},
 525 #endif
 526 #if HAVE_DECL_CURLE_TFTP_NOTFOUND
 527     {"CURLE_TFTP_NOTFOUND", CURLE_TFTP_NOTFOUND},
 528 #else
 529     {"CURLE_TFTP_NOTFOUND", -1},
 530 #endif
 531 #if HAVE_DECL_CURLE_TFTP_PERM
 532     {"CURLE_TFTP_PERM", CURLE_TFTP_PERM},
 533 #else
 534     {"CURLE_TFTP_PERM", -1},
 535 #endif
 536 #if HAVE_DECL_CURLE_REMOTE_DISK_FULL
 537     {"CURLE_REMOTE_DISK_FULL", CURLE_REMOTE_DISK_FULL},
 538 #else
 539     {"CURLE_REMOTE_DISK_FULL", -1},
 540 #endif
 541 #if HAVE_DECL_CURLE_TFTP_ILLEGAL
 542     {"CURLE_TFTP_ILLEGAL", CURLE_TFTP_ILLEGAL},
 543 #else
 544     {"CURLE_TFTP_ILLEGAL", -1},
 545 #endif
 546 #if HAVE_DECL_CURLE_TFTP_UNKNOWNID
 547     {"CURLE_TFTP_UNKNOWNID", CURLE_TFTP_UNKNOWNID},
 548 #else
 549     {"CURLE_TFTP_UNKNOWNID", -1},
 550 #endif
 551 #if HAVE_DECL_CURLE_REMOTE_FILE_EXISTS
 552     {"CURLE_REMOTE_FILE_EXISTS", CURLE_REMOTE_FILE_EXISTS},
 553 #else
 554     {"CURLE_REMOTE_FILE_EXISTS", -1},
 555 #endif
 556 #if HAVE_DECL_CURLE_TFTP_NOSUCHUSER
 557     {"CURLE_TFTP_NOSUCHUSER", CURLE_TFTP_NOSUCHUSER},
 558 #else
 559     {"CURLE_TFTP_NOSUCHUSER", -1},
 560 #endif
 561 #if HAVE_DECL_CURLE_CONV_FAILED
 562     {"CURLE_CONV_FAILED", CURLE_CONV_FAILED},
 563 #else
 564     {"CURLE_CONV_FAILED", -1},
 565 #endif
 566 #if HAVE_DECL_CURLE_CONV_REQD
 567     {"CURLE_CONV_REQD", CURLE_CONV_REQD},
 568 #else
 569     {"CURLE_CONV_REQD", -1},
 570 #endif
 571 #if HAVE_DECL_CURLE_SSL_CACERT_BADFILE
 572     {"CURLE_SSL_CACERT_BADFILE", CURLE_SSL_CACERT_BADFILE},
 573 #else
 574     {"CURLE_SSL_CACERT_BADFILE", -1},
 575 #endif
 576 #if HAVE_DECL_CURLE_REMOTE_FILE_NOT_FOUND
 577     {"CURLE_REMOTE_FILE_NOT_FOUND", CURLE_REMOTE_FILE_NOT_FOUND},
 578 #else
 579     {"CURLE_REMOTE_FILE_NOT_FOUND", -1},
 580 #endif
 581 #if HAVE_DECL_CURLE_SSH
 582     {"CURLE_SSH", CURLE_SSH},
 583 #else
 584     {"CURLE_SSH", -1},
 585 #endif
 586 #if HAVE_DECL_CURLE_SSL_SHUTDOWN_FAILED
 587     {"CURLE_SSL_SHUTDOWN_FAILED", CURLE_SSL_SHUTDOWN_FAILED},
 588 #else
 589     {"CURLE_SSL_SHUTDOWN_FAILED", -1},
 590 #endif
 591 #if HAVE_DECL_CURLE_AGAIN
 592     {"CURLE_AGAIN", CURLE_AGAIN},
 593 #else
 594     {"CURLE_AGAIN", -1},
 595 #endif
 596     {NULL, 0}
 597 };
 598
 599 typedef struct CURLOptionMapping CURLOptionMapping;
 600
 601 struct CURLOptionMapping
 602 {
 603     void (*optionHandler)(Connection *, value);
 604     char *name;
 605     OcamlValue ocamlValue;
 606 };
 607
 608 static char* strdup_ml(value v)
 609 {
 610   char* p = NULL;
 611   p = malloc(caml_string_length(v)+1);
 612   memcpy(p,String_val(v),caml_string_length(v)+1); // caml strings have terminating zero
 613   return p;
 614 }
 615
 616 /* prepends to the beginning of list */
 617 static struct curl_slist* curl_slist_prepend_ml(struct curl_slist* list, value v)
 618 {
 619   /* FIXME check NULLs */
 620   struct curl_slist* new_item = malloc(sizeof(struct curl_slist));
 621
 622   new_item->next = list;
 623   new_item->data = strdup_ml(v);
 624
 625   return new_item;
 626 }
 627
 628 static void free_curl_slist(struct curl_slist *slist)
 629 {
 630     if (NULL == slist)
 631       return;
 632
 633     curl_slist_free_all(slist);
 634 }
 635
 636 static void raiseError(Connection *conn, CURLcode code)
 637 {
 638     CAMLparam0();
 639     CAMLlocal1(exceptionData);
 640     value *exception;
 641     char *errorString = "Unknown Error";
 642     int i;
 643
 644     for (i = 0; errorMap[i].name != NULL; i++)
 645     {
 646         if (errorMap[i].error == code)
 647         {
 648             errorString = errorMap[i].name;
 649             break;
 650         }
 651     }
 652
 653     exceptionData = caml_alloc_tuple(3);
 654
 655     Store_field(exceptionData, 0, Val_int(code));
 656     Store_field(exceptionData, 1, Val_int(code));
 657     Store_field(exceptionData, 2, caml_copy_string(errorString));
 658
 659     if (conn != NULL && conn->curl_ERRORBUFFER != NULL)
 660     {
 661         Store_field(Field(conn->ocamlValues, Ocaml_ERRORBUFFER), 0, caml_copy_string(conn->curl_ERRORBUFFER));
 662     }
 663
 664     exception = caml_named_value("CurlException");
 665
 666     if (exception == NULL)
 667         caml_failwith("CurlException not registered");
 668
 669     caml_raise_with_arg(*exception, exceptionData);
 670
 671     CAMLreturn0;
 672 }
 673
 674 static void resetOcamlValues(Connection* connection)
 675 {
 676     int i;
 677
 678     for (i = 0; i < OcamlValuesSize; i++)
 679         Store_field(connection->ocamlValues, i, Val_unit);
 680 }
 681
 682 static Connection* allocConnection(CURL* h)
 683 {
 684     Connection* connection = (Connection *)malloc(sizeof(Connection));
 685
 686     connection->ocamlValues = caml_alloc(OcamlValuesSize, 0);
 687     resetOcamlValues(connection);
 688     caml_register_global_root(&connection->ocamlValues);
 689
 690     connection->handle = h;
 691     curl_easy_setopt(h, CURLOPT_PRIVATE, connection);
 692
 693     connection->refcount = 0;
 694
 695     connection->curl_URL = NULL;
 696     connection->curl_PROXY = NULL;
 697     connection->curl_USERPWD = NULL;
 698     connection->curl_PROXYUSERPWD = NULL;
 699     connection->curl_RANGE = NULL;
 700     connection->curl_ERRORBUFFER = NULL;
 701     connection->curl_POSTFIELDS = NULL;
 702     connection->curl_POSTFIELDSIZE = -1;
 703     connection->curl_REFERER = NULL;
 704     connection->curl_USERAGENT = NULL;
 705     connection->curl_FTPPORT = NULL;
 706     connection->curl_COOKIE = NULL;
 707     connection->curl_HTTPHEADER = NULL;
 708     connection->httpPostBuffers = NULL;
 709     connection->httpPostFirst = NULL;
 710     connection->httpPostLast = NULL;
 711     connection->curl_SSLCERT = NULL;
 712     connection->curl_SSLCERTTYPE = NULL;
 713     connection->curl_SSLCERTPASSWD = NULL;
 714     connection->curl_SSLKEY = NULL;
 715     connection->curl_SSLKEYTYPE = NULL;
 716     connection->curl_SSLKEYPASSWD = NULL;
 717     connection->curl_SSLENGINE = NULL;
 718     connection->curl_QUOTE = NULL;
 719     connection->curl_POSTQUOTE = NULL;
 720     connection->curl_COOKIEFILE = NULL;
 721     connection->curl_CUSTOMREQUEST = NULL;
 722     connection->curl_INTERFACE = NULL;
 723     connection->curl_CAINFO = NULL;
 724     connection->curl_CAPATH = NULL;
 725     connection->curl_RANDOM_FILE = NULL;
 726     connection->curl_EGDSOCKET = NULL;
 727     connection->curl_COOKIEJAR = NULL;
 728     connection->curl_SSL_CIPHER_LIST = NULL;
 729     connection->curl_HTTP200ALIASES = NULL;
 730     connection->curl_NETRC_FILE = NULL;
 731     connection->curl_FTP_ACCOUNT = NULL;
 732     connection->curl_COOKIELIST = NULL;
 733     connection->curl_FTP_ALTERNATIVE_TO_USER = NULL;
 734     connection->curl_SSH_PUBLIC_KEYFILE = NULL;
 735     connection->curl_SSH_PRIVATE_KEYFILE = NULL;
 736     connection->curl_COPYPOSTFIELDS = NULL;
 737     connection->curl_RESOLVE = NULL;
 738     connection->curl_DNS_SERVERS = NULL;
 739     connection->curl_MAIL_FROM = NULL;
 740     connection->curl_MAIL_RCPT = NULL;
 741
 742     return connection;
 743 }
 744
 745 static Connection *newConnection(void)
 746 {
 747     CURL* h;
 748
 749     caml_enter_blocking_section();
 750     h = curl_easy_init();
 751     caml_leave_blocking_section();
 752
 753     return allocConnection(h);
 754 }
 755
 756 static void free_if(void* p) { if (NULL != p) free(p); }
 757
 758 static void removeConnection(Connection *connection, int finalization)
 759 {
 760     const char* fin_url = NULL;
 761
 762     if (!connection->handle)
 763     {
 764       return; /* already cleaned up */
 765     }
 766
 767     if (finalization)
 768     {
 769       /* cannot engage OCaml runtime at finalization, just report leak */
 770       if (CURLE_OK != curl_easy_getinfo(connection->handle, CURLINFO_EFFECTIVE_URL, &fin_url) || NULL == fin_url)
 771       {
 772         fin_url = "unknown";
 773       }
 774       fprintf(stderr,"Curl: handle %p leaked, conn %p, url %s\n", connection->handle, connection, fin_url);
 775       fflush(stderr);
 776     }
 777     else
 778     {
 779       caml_enter_blocking_section();
 780       curl_easy_cleanup(connection->handle);
 781       caml_leave_blocking_section();
 782     }
 783
 784     connection->handle = NULL;
 785
 786     caml_remove_global_root(&connection->ocamlValues);
 787
 788     free_if(connection->curl_URL);
 789     free_if(connection->curl_PROXY);
 790     free_if(connection->curl_USERPWD);
 791     free_if(connection->curl_PROXYUSERPWD);
 792     free_if(connection->curl_RANGE);
 793     free_if(connection->curl_ERRORBUFFER);
 794     free_if(connection->curl_POSTFIELDS);
 795     free_if(connection->curl_REFERER);
 796     free_if(connection->curl_USERAGENT);
 797     free_if(connection->curl_FTPPORT);
 798     free_if(connection->curl_COOKIE);
 799     free_curl_slist(connection->curl_HTTPHEADER);
 800     free_curl_slist(connection->httpPostBuffers);
 801     if (connection->httpPostFirst != NULL)
 802         curl_formfree(connection->httpPostFirst);
 803     free_curl_slist(connection->curl_RESOLVE);
 804     free_if(connection->curl_SSLCERT);
 805     free_if(connection->curl_SSLCERTTYPE);
 806     free_if(connection->curl_SSLCERTPASSWD);
 807     free_if(connection->curl_SSLKEY);
 808     free_if(connection->curl_SSLKEYTYPE);
 809     free_if(connection->curl_SSLKEYPASSWD);
 810     free_if(connection->curl_SSLENGINE);
 811     free_curl_slist(connection->curl_QUOTE);
 812     free_curl_slist(connection->curl_POSTQUOTE);
 813     free_if(connection->curl_COOKIEFILE);
 814     free_if(connection->curl_CUSTOMREQUEST);
 815     free_if(connection->curl_INTERFACE);
 816     free_if(connection->curl_CAINFO);
 817     free_if(connection->curl_CAPATH);
 818     free_if(connection->curl_RANDOM_FILE);
 819     free_if(connection->curl_EGDSOCKET);
 820     free_if(connection->curl_COOKIEJAR);
 821     free_if(connection->curl_SSL_CIPHER_LIST);
 822     free_curl_slist(connection->curl_HTTP200ALIASES);
 823     free_if(connection->curl_NETRC_FILE);
 824     free_if(connection->curl_FTP_ACCOUNT);
 825     free_if(connection->curl_COOKIELIST);
 826     free_if(connection->curl_FTP_ALTERNATIVE_TO_USER);
 827     free_if(connection->curl_SSH_PUBLIC_KEYFILE);
 828     free_if(connection->curl_SSH_PRIVATE_KEYFILE);
 829     free_if(connection->curl_COPYPOSTFIELDS);
 830     free_if(connection->curl_DNS_SERVERS);
 831     free_if(connection->curl_MAIL_FROM);
 832     free_curl_slist(connection->curl_MAIL_RCPT);
 833 }
 834
 835 static Connection* getConnection(CURL* h)
 836 {
 837   Connection* p = NULL;
 838
 839   if (CURLE_OK != curl_easy_getinfo(h, CURLINFO_PRIVATE, &p) || NULL == p)
 840   {
 841     caml_failwith("Unknown handle");
 842   }
 843
 844   return p;
 845 }
 846
 847 #if 1
 848 static void checkConnection(Connection * connection)
 849 {
 850   (void)connection;
 851 }
 852 #else
 853 static void checkConnection(Connection *connection)
 854 {
 855   if (connection != getConnection(connection->handle))
 856   {
 857     caml_failwith("Invalid Connection");
 858   }
 859 }
 860 #endif
 861
 862 void op_curl_easy_finalize(value v)
 863 {
 864   Connection* conn = Connection_val(v);
 865   /* same connection may be referenced by several different
 866      OCaml values, see e.g. caml_curl_multi_remove_finished */
 867   conn->refcount--;
 868   if (0 == conn->refcount)
 869   {
 870     removeConnection(conn, 1);
 871     free(conn);
 872   }
 873 }
 874
 875 int op_curl_easy_compare(value v1, value v2)
 876 {
 877   size_t p1 = (size_t)Connection_val(v1);
 878   size_t p2 = (size_t)Connection_val(v2);
 879   return (p1 == p2 ? 0 : (p1 > p2 ? 1 : -1)); /* compare addresses */
 880 }
 881
 882 intnat op_curl_easy_hash(value v)
 883 {
 884   return (size_t)Connection_val(v); /* address */
 885 }
 886
 887 static struct custom_operations curl_easy_ops = {
 888   "ygrek.curl_easy",
 889   op_curl_easy_finalize,
 890   op_curl_easy_compare,
 891   op_curl_easy_hash,
 892   custom_serialize_default,
 893   custom_deserialize_default,
 894 #if defined(custom_compare_ext_default)
 895   custom_compare_ext_default,
 896 #endif
 897 };
 898
 899 value caml_curl_alloc(Connection* conn)
 900 {
 901   value v = caml_alloc_custom(&curl_easy_ops, sizeof(Connection*), 0, 1);
 902   Connection_val(v) = conn;
 903   conn->refcount++;
 904   return v;
 905 }
 906
 907 static size_t cb_WRITEFUNCTION(char *ptr, size_t size, size_t nmemb, void *data)
 908 {
 909     caml_leave_blocking_section();
 910
 911     CAMLparam0();
 912     CAMLlocal2(result, str);
 913     Connection *conn = (Connection *)data;
 914     size_t i;
 915
 916     checkConnection(conn);
 917
 918     str = caml_alloc_string(size*nmemb);
 919
 920     for (i = 0; i < size*nmemb; i++)
 921         Byte(str, i) = ptr[i];
 922
 923     result = caml_callback_exn(Field(conn->ocamlValues, Ocaml_WRITEFUNCTION), str);
 924
 925     size_t r = Is_exception_result(result) ? 0 : Int_val(result);
 926     CAMLdrop;
 927
 928     caml_enter_blocking_section();
 929     return r;
 930 }
 931
 932 static size_t cb_READFUNCTION(void *ptr, size_t size, size_t nmemb, void *data)
 933 {
 934     caml_leave_blocking_section();
 935
 936     CAMLparam0();
 937     CAMLlocal1(result);
 938     Connection *conn = (Connection *)data;
 939     size_t length;
 940
 941     checkConnection(conn);
 942
 943     result = caml_callback_exn(Field(conn->ocamlValues, Ocaml_READFUNCTION),
 944                       Val_int(size*nmemb));
 945
 946     if (Is_exception_result(result))
 947     {
 948       CAMLreturnT(size_t,CURL_READFUNC_ABORT);
 949     }
 950
 951     length = caml_string_length(result);
 952
 953     size_t r;
 954
 955     if (length <= size*nmemb)
 956     {
 957       memcpy(ptr, String_val(result), length);
 958       r = length;
 959     }
 960     else
 961     {
 962       r = CURL_READFUNC_ABORT;
 963     }
 964     CAMLdrop;
 965
 966     caml_enter_blocking_section();
 967     return r;
 968 }
 969
 970 static size_t cb_HEADERFUNCTION(char *ptr, size_t size, size_t nmemb, void *data)
 971 {
 972     caml_leave_blocking_section();
 973
 974     CAMLparam0();
 975     CAMLlocal2(result,str);
 976     Connection *conn = (Connection *)data;
 977     size_t i;
 978
 979     checkConnection(conn);
 980
 981     str = caml_alloc_string(size*nmemb);
 982
 983     for (i = 0; i < size*nmemb; i++)
 984         Byte(str, i) = ptr[i];
 985
 986     result = caml_callback_exn(Field(conn->ocamlValues, Ocaml_HEADERFUNCTION), str);
 987
 988     size_t r = Is_exception_result(result) ? 0 : Int_val(result);
 989     CAMLdrop;
 990
 991     caml_enter_blocking_section();
 992     return r;
 993 }
 994
 995 static int cb_PROGRESSFUNCTION(void *data,
 996                             double dlTotal,
 997                             double dlNow,
 998                             double ulTotal,
 999                             double ulNow)
1000 {
1001     caml_leave_blocking_section();
1002
1003     CAMLparam0();
1004     CAMLlocal1(result);
1005     CAMLlocalN(callbackData, 4);
1006     Connection *conn = (Connection *)data;
1007
1008     checkConnection(conn);
1009
1010     callbackData[0] = caml_copy_double(dlTotal);
1011     callbackData[1] = caml_copy_double(dlNow);
1012     callbackData[2] = caml_copy_double(ulTotal);
1013     callbackData[3] = caml_copy_double(ulNow);
1014
1015     result = caml_callbackN_exn(Field(conn->ocamlValues, Ocaml_PROGRESSFUNCTION),
1016                        4, callbackData);
1017
1018     int r = Is_exception_result(result) ? 1 : Bool_val(result);
1019     CAMLdrop;
1020
1021     caml_enter_blocking_section();
1022     return r;
1023 }
1024
1025 static int cb_DEBUGFUNCTION(CURL *debugConnection,
1026                          curl_infotype infoType,
1027                          char *buffer,
1028                          size_t bufferLength,
1029                          void *data)
1030 {
1031     caml_leave_blocking_section();
1032
1033     CAMLparam0();
1034     CAMLlocal3(camlDebugConnection, camlInfoType, camlMessage);
1035     size_t i;
1036     Connection *conn = (Connection *)data;
1037     (void)debugConnection; /* not used */
1038
1039     checkConnection(conn);
1040
1041     camlDebugConnection = (value)conn;
1042     camlInfoType = Val_long(infoType);
1043     camlMessage = caml_alloc_string(bufferLength);
1044
1045     for (i = 0; i < bufferLength; i++)
1046         Byte(camlMessage, i) = buffer[i];
1047
1048     caml_callback3_exn(Field(conn->ocamlValues, Ocaml_DEBUGFUNCTION),
1049               camlDebugConnection,
1050               camlInfoType,
1051               camlMessage);
1052
1053     CAMLdrop;
1054
1055     caml_enter_blocking_section();
1056     return 0;
1057 }
1058
1059 static curlioerr cb_IOCTLFUNCTION(CURL *ioctl,
1060                                int cmd,
1061                                void *data)
1062 {
1063     caml_leave_blocking_section();
1064
1065     CAMLparam0();
1066     CAMLlocal3(camlResult, camlConnection, camlCmd);
1067     Connection *conn = (Connection *)data;
1068     curlioerr result = CURLIOE_OK;
1069     (void)ioctl; /* not used */
1070
1071     checkConnection(conn);
1072
1073     if (cmd == CURLIOCMD_NOP)
1074         camlCmd = Val_long(0);
1075     else if (cmd == CURLIOCMD_RESTARTREAD)
1076         camlCmd = Val_long(1);
1077     else
1078         caml_failwith("Invalid IOCTL Cmd!");
1079
1080     camlConnection = caml_curl_alloc(conn);
1081
1082     camlResult = caml_callback2_exn(Field(conn->ocamlValues, Ocaml_IOCTLFUNCTION),
1083                            camlConnection,
1084                            camlCmd);
1085
1086     if (Is_exception_result(camlResult))
1087     {
1088       result = CURLIOE_FAILRESTART;
1089     }
1090     else
1091     switch (Long_val(camlResult))
1092     {
1093     case 0: /* CURLIOE_OK */
1094         result = CURLIOE_OK;
1095         break;
1096
1097     case 1: /* CURLIOE_UNKNOWNCMD */
1098         result = CURLIOE_UNKNOWNCMD;
1099         break;
1100
1101     case 2: /* CURLIOE_FAILRESTART */
1102         result = CURLIOE_FAILRESTART;
1103         break;
1104
1105     default: /* Incorrect return value, but let's handle it */
1106         result = CURLIOE_FAILRESTART;
1107         break;
1108     }
1109     CAMLdrop;
1110
1111     caml_enter_blocking_section();
1112     return result;
1113 }
1114
1115 #if HAVE_DECL_CURLOPT_SEEKFUNCTION
1116 static int cb_SEEKFUNCTION(void *data,
1117                         curl_off_t offset,
1118                         int origin)
1119 {
1120     caml_leave_blocking_section();
1121
1122     CAMLparam0();
1123     CAMLlocal3(camlResult, camlOffset, camlOrigin);
1124     Connection *conn = (Connection *)data;
1125
1126     camlOffset = caml_copy_int64(offset);
1127
1128     if (origin == SEEK_SET)
1129         camlOrigin = Val_long(0);
1130     else if (origin == SEEK_CUR)
1131         camlOrigin = Val_long(1);
1132     else if (origin == SEEK_END)
1133         camlOrigin = Val_long(2);
1134     else
1135         caml_failwith("Invalid seek code");
1136
1137     camlResult = caml_callback2_exn(Field(conn->ocamlValues,
1138                                  Ocaml_SEEKFUNCTION),
1139                            camlOffset,
1140                            camlOrigin);
1141
1142     int result;
1143     if (Is_exception_result(camlResult))
1144       result = CURL_SEEKFUNC_FAIL;
1145     else
1146     switch (Int_val(camlResult))
1147     {
1148       case 0: result = CURL_SEEKFUNC_OK; break;
1149       case 1: result = CURL_SEEKFUNC_FAIL; break;
1150       case 2: result = CURL_SEEKFUNC_CANTSEEK; break;
1151       default: caml_failwith("Invalid seek result");
1152     }
1153     CAMLdrop;
1154
1155     caml_enter_blocking_section();
1156     return result;
1157 }
1158 #endif
1159
1160 #if HAVE_DECL_CURLOPT_OPENSOCKETFUNCTION
1161 static int cb_OPENSOCKETFUNCTION(void *data,
1162                         curlsocktype purpose,
1163                         struct curl_sockaddr *addr)
1164 {
1165     caml_leave_blocking_section();
1166
1167     CAMLparam0();
1168     CAMLlocal1(result);
1169     Connection *conn = (Connection *)data;
1170     int sock = -1;
1171     (void)purpose; /* not used */
1172
1173     sock = socket(addr->family, addr->socktype, addr->protocol);
1174
1175     if (-1 != sock)
1176     {
1177       /* FIXME windows */
1178       result = caml_callback_exn(Field(conn->ocamlValues, Ocaml_OPENSOCKETFUNCTION), Val_int(sock));
1179       if (Is_exception_result(result))
1180       {
1181         close(sock);
1182         sock = -1;
1183       }
1184     }
1185     CAMLdrop;
1186
1187     caml_enter_blocking_section();
1188     return ((sock == -1) ? CURL_SOCKET_BAD : sock);
1189 }
1190 #endif
1191
1192 /**
1193  **  curl_global_init helper function
1194  **/
1195
1196 CAMLprim value helper_curl_global_init(value initOption)
1197 {
1198     CAMLparam1(initOption);
1199
1200     switch (Long_val(initOption))
1201     {
1202     case 0: /* CURLINIT_GLOBALALL */
1203         CAMLreturn(Val_long(curl_global_init(CURL_GLOBAL_ALL)));
1204         break;
1205
1206     case 1: /* CURLINIT_GLOBALSSL */
1207         CAMLreturn(Val_long(curl_global_init(CURL_GLOBAL_SSL)));
1208         break;
1209
1210     case 2: /* CURLINIT_GLOBALWIN32 */
1211         CAMLreturn(Val_long(curl_global_init(CURL_GLOBAL_WIN32)));
1212         break;
1213
1214     case 3: /* CURLINIT_GLOBALNOTHING */
1215         CAMLreturn(Val_long(curl_global_init(CURL_GLOBAL_NOTHING)));
1216         break;
1217
1218     default:
1219         caml_failwith("Invalid Initialization Option");
1220         break;
1221     }
1222
1223     /* Keep compiler happy, we should never get here due to caml_failwith() */
1224     CAMLreturn(Val_unit);
1225 }
1226
1227 /**
1228  **  curl_global_cleanup helper function
1229  **/
1230
1231 CAMLprim value helper_curl_global_cleanup(void)
1232 {
1233     CAMLparam0();
1234
1235     curl_global_cleanup();
1236
1237     CAMLreturn(Val_unit);
1238 }
1239
1240 /**
1241  ** curl_easy_init helper function
1242  **/
1243 CAMLprim value helper_curl_easy_init(void)
1244 {
1245     CAMLparam0();
1246     CAMLlocal1(result);
1247
1248     result = caml_curl_alloc(newConnection());
1249
1250     CAMLreturn(result);
1251 }
1252
1253 CAMLprim value helper_curl_easy_reset(value conn)
1254 {
1255     CAMLparam1(conn);
1256     Connection *connection = Connection_val(conn);
1257
1258     checkConnection(connection);
1259     curl_easy_reset(connection->handle);
1260     resetOcamlValues(connection);
1261
1262     CAMLreturn(Val_unit);
1263 }
1264
1265 /**
1266  **  curl_easy_setopt helper utility functions
1267  **/
1268
1269 #define SETOPT_FUNCTION(name) \
1270 static void handle_##name##FUNCTION(Connection *conn, value option) \
1271 { \
1272     CAMLparam1(option); \
1273     CURLcode result = CURLE_OK; \
1274     Store_field(conn->ocamlValues, Ocaml_##name##FUNCTION, option); \
1275     result = curl_easy_setopt(conn->handle, CURLOPT_##name##FUNCTION, cb_##name##FUNCTION); \
1276     if (result != CURLE_OK) raiseError(conn, result); \
1277     result = curl_easy_setopt(conn->handle, CURLOPT_##name##DATA, conn); \
1278     if (result != CURLE_OK) raiseError(conn, result); \
1279     CAMLreturn0; \
1280 }
1281
1282 SETOPT_FUNCTION( WRITE)
1283 SETOPT_FUNCTION( READ)
1284 SETOPT_FUNCTION( HEADER)
1285 SETOPT_FUNCTION( PROGRESS)
1286 SETOPT_FUNCTION( DEBUG)
1287
1288 #if HAVE_DECL_CURLOPT_SEEKFUNCTION
1289 SETOPT_FUNCTION( SEEK)
1290 #endif
1291
1292 #if HAVE_DECL_CURLOPT_IOCTLFUNCTION
1293 SETOPT_FUNCTION( IOCTL)
1294 #endif
1295
1296 #if HAVE_DECL_CURLOPT_OPENSOCKETFUNCTION
1297 SETOPT_FUNCTION( OPENSOCKET)
1298 #endif
1299
1300 static void handle_slist(Connection *conn, struct curl_slist** slist, OcamlValue caml_option, CURLoption curl_option, value option)
1301 {
1302     CAMLparam1(option);
1303     CURLcode result = CURLE_OK;
1304
1305     Store_field(conn->ocamlValues, caml_option, option);
1306
1307     free_curl_slist(*slist);
1308     *slist = NULL;
1309
1310     while (Val_emptylist != option)
1311     {
1312         *slist = curl_slist_append(*slist, String_val(Field(option, 0)));
1313
1314         option = Field(option, 1);
1315     }
1316
1317     result = curl_easy_setopt(conn->handle, curl_option, *slist);
1318
1319     if (result != CURLE_OK)
1320         raiseError(conn, result);
1321
1322     CAMLreturn0;
1323 }
1324
1325 static long convert_bit_list(long *map, size_t map_size, value option)
1326 {
1327     CAMLparam1(option);
1328     long bits = 0;
1329     int index;
1330
1331     while (Val_emptylist != option)
1332     {
1333         index = Int_val(Field(option, 0));
1334         if ((index < 0) || ((size_t)index >= map_size))
1335           caml_invalid_argument("convert_bit_list");
1336
1337         bits |= map[index];
1338
1339         option = Field(option, 1);
1340     }
1341
1342     CAMLreturnT(long, bits);
1343 }
1344
1345 #define SETOPT_STRING(name) \
1346 static void handle_##name(Connection *conn, value option) \
1347 { \
1348     CAMLparam1(option); \
1349     CURLcode result = CURLE_OK; \
1350 \
1351     Store_field(conn->ocamlValues, Ocaml_##name, option); \
1352 \
1353     if (conn->curl_##name != NULL) \
1354         free(conn->curl_##name); \
1355 \
1356     conn->curl_##name = strdup(String_val(option)); \
1357 \
1358     result = curl_easy_setopt(conn->handle, CURLOPT_##name, conn->curl_##name); \
1359 \
1360     if (result != CURLE_OK) \
1361         raiseError(conn, result); \
1362 \
1363     CAMLreturn0; \
1364 }
1365
1366 #define SETOPT_VAL_(func_name, curl_option, conv_val) \
1367 static void func_name(Connection *conn, value option) \
1368 { \
1369     CAMLparam1(option); \
1370     CURLcode result = CURLE_OK; \
1371 \
1372     result = curl_easy_setopt(conn->handle, curl_option, conv_val(option)); \
1373 \
1374     if (result != CURLE_OK) \
1375         raiseError(conn, result); \
1376 \
1377     CAMLreturn0; \
1378 }
1379
1380 #define SETOPT_VAL(name, conv) SETOPT_VAL_(handle_##name, CURLOPT_##name, conv)
1381 #define SETOPT_BOOL(name) SETOPT_VAL(name, Bool_val)
1382 #define SETOPT_LONG(name) SETOPT_VAL(name, Long_val)
1383 #define SETOPT_INT64(name) SETOPT_VAL(name, Int64_val)
1384
1385 #define SETOPT_SLIST(name) \
1386 static void handle_##name(Connection* conn, value option) \
1387 { \
1388   handle_slist(conn,&(conn->curl_##name),Ocaml_##name,CURLOPT_##name,option); \
1389 }
1390
1391 SETOPT_STRING( URL)
1392 SETOPT_LONG( INFILESIZE)
1393 SETOPT_STRING( PROXY)
1394 SETOPT_LONG( PROXYPORT)
1395 SETOPT_BOOL( HTTPPROXYTUNNEL)
1396 SETOPT_BOOL( VERBOSE)
1397 SETOPT_BOOL( HEADER)
1398 SETOPT_BOOL( NOPROGRESS)
1399
1400 #if HAVE_DECL_CURLOPT_NOSIGNAL
1401 SETOPT_BOOL( NOSIGNAL)
1402 #endif
1403
1404 SETOPT_BOOL( NOBODY)
1405 SETOPT_BOOL( FAILONERROR)
1406 SETOPT_BOOL( UPLOAD)
1407 SETOPT_BOOL( POST)
1408 SETOPT_BOOL( FTPLISTONLY)
1409 SETOPT_BOOL( FTPAPPEND)
1410
1411
1412 static void handle_NETRC(Connection *conn, value option)
1413 {
1414     CAMLparam1(option);
1415     CURLcode result = CURLE_OK;
1416     long netrc;
1417
1418     switch (Long_val(option))
1419     {
1420     case 0: /* CURL_NETRC_OPTIONAL */
1421         netrc = CURL_NETRC_OPTIONAL;
1422         break;
1423
1424     case 1:/* CURL_NETRC_IGNORED */
1425         netrc = CURL_NETRC_IGNORED;
1426         break;
1427
1428     case 2: /* CURL_NETRC_REQUIRED */
1429         netrc = CURL_NETRC_REQUIRED;
1430         break;
1431
1432     default:
1433         caml_failwith("Invalid NETRC Option");
1434         break;
1435     }
1436
1437     result = curl_easy_setopt(conn->handle,
1438                               CURLOPT_NETRC,
1439                               netrc);
1440
1441     if (result != CURLE_OK)
1442         raiseError(conn, result);
1443
1444     CAMLreturn0;
1445 }
1446
1447 #if HAVE_DECL_CURLOPT_ENCODING
1448 static void handle_ENCODING(Connection *conn, value option)
1449 {
1450     CAMLparam1(option);
1451     CURLcode result = CURLE_OK;
1452
1453     switch (Long_val(option))
1454     {
1455     case 0: /* CURL_ENCODING_NONE */
1456         result = curl_easy_setopt(conn->handle,
1457                                   CURLOPT_ENCODING,
1458                                   "identity");
1459         break;
1460
1461     case 1: /* CURL_ENCODING_DEFLATE */
1462         result = curl_easy_setopt(conn->handle,
1463                                   CURLOPT_ENCODING,
1464                                   "deflate");
1465         break;
1466
1467     case 2: /* CURL_ENCODING_GZIP */
1468         result = curl_easy_setopt(conn->handle,
1469                                   CURLOPT_ENCODING,
1470                                   "gzip");
1471         break;
1472
1473     case 3: /* CURL_ENCODING_ANY */
1474         result = curl_easy_setopt(conn->handle,
1475                                   CURLOPT_ENCODING,
1476                                   "");
1477         break;
1478
1479     default:
1480         caml_failwith("Invalid Encoding Option");
1481         break;
1482     }
1483
1484     if (result != CURLE_OK)
1485         raiseError(conn, result);
1486
1487     CAMLreturn0;
1488 }
1489 #endif
1490
1491
1492 SETOPT_BOOL( FOLLOWLOCATION)
1493 SETOPT_BOOL( TRANSFERTEXT)
1494 SETOPT_BOOL( PUT)
1495 SETOPT_STRING( USERPWD)
1496 SETOPT_STRING( PROXYUSERPWD)
1497 SETOPT_STRING( RANGE)
1498
1499 static void handle_ERRORBUFFER(Connection *conn, value option)
1500 {
1501     CAMLparam1(option);
1502     CURLcode result = CURLE_OK;
1503
1504     Store_field(conn->ocamlValues, Ocaml_ERRORBUFFER, option);
1505
1506     if (conn->curl_ERRORBUFFER != NULL)
1507         free(conn->curl_ERRORBUFFER);
1508
1509     conn->curl_ERRORBUFFER = malloc(sizeof(char) * CURL_ERROR_SIZE);
1510
1511     result = curl_easy_setopt(conn->handle,
1512                               CURLOPT_ERRORBUFFER,
1513                               conn->curl_ERRORBUFFER);
1514
1515     if (result != CURLE_OK)
1516         raiseError(conn, result);
1517
1518     CAMLreturn0;
1519 }
1520
1521 SETOPT_LONG( TIMEOUT)
1522
1523 static void handle_POSTFIELDS(Connection *conn, value option)
1524 {
1525     CAMLparam1(option);
1526     CURLcode result = CURLE_OK;
1527
1528     Store_field(conn->ocamlValues, Ocaml_POSTFIELDS, option);
1529
1530     if (conn->curl_POSTFIELDS != NULL)
1531         free(conn->curl_POSTFIELDS);
1532
1533     conn->curl_POSTFIELDS = strdup_ml(option);
1534
1535     result = curl_easy_setopt(conn->handle,
1536                               CURLOPT_POSTFIELDS,
1537                               conn->curl_POSTFIELDS);
1538
1539     if (result != CURLE_OK)
1540         raiseError(conn, result);
1541
1542     CAMLreturn0;
1543 }
1544
1545 SETOPT_LONG( POSTFIELDSIZE)
1546 SETOPT_STRING( REFERER)
1547 SETOPT_STRING( USERAGENT)
1548 SETOPT_STRING( FTPPORT)
1549 SETOPT_LONG( LOW_SPEED_LIMIT)
1550 SETOPT_LONG( LOW_SPEED_TIME)
1551 SETOPT_LONG( RESUME_FROM)
1552 SETOPT_STRING( COOKIE)
1553
1554 SETOPT_SLIST( HTTPHEADER)
1555
1556 static void handle_HTTPPOST(Connection *conn, value option)
1557 {
1558     CAMLparam1(option);
1559     CAMLlocal3(listIter, formItem, contentType);
1560     CURLcode result = CURLE_OK;
1561
1562     listIter = option;
1563
1564     Store_field(conn->ocamlValues, Ocaml_HTTPPOST, option);
1565
1566     free_curl_slist(conn->httpPostBuffers);
1567     if (conn->httpPostFirst != NULL)
1568         curl_formfree(conn->httpPostFirst);
1569
1570     conn->httpPostBuffers = NULL;
1571     conn->httpPostFirst = NULL;
1572     conn->httpPostLast = NULL;
1573
1574     while (!Is_long(listIter))
1575     {
1576         formItem = Field(listIter, 0);
1577
1578         switch (Tag_val(formItem))
1579         {
1580         case 0: /* CURLFORM_CONTENT */
1581             if (Wosize_val(formItem) < 3)
1582             {
1583                 caml_failwith("Incorrect CURLFORM_CONTENT parameters");
1584             }
1585
1586             if (Is_long(Field(formItem, 2)) &&
1587                 Long_val(Field(formItem, 2)) == 0)
1588             {
1589                 curl_formadd(&conn->httpPostFirst,
1590                              &conn->httpPostLast,
1591                              CURLFORM_COPYNAME,
1592                              String_val(Field(formItem, 0)),
1593                              CURLFORM_NAMELENGTH,
1594                              caml_string_length(Field(formItem, 0)),
1595                              CURLFORM_COPYCONTENTS,
1596                              String_val(Field(formItem, 1)),
1597                              CURLFORM_CONTENTSLENGTH,
1598                              caml_string_length(Field(formItem, 1)),
1599                              CURLFORM_END);
1600             }
1601             else if (Is_block(Field(formItem, 2)))
1602             {
1603                 contentType = Field(formItem, 2);
1604
1605                 curl_formadd(&conn->httpPostFirst,
1606                              &conn->httpPostLast,
1607                              CURLFORM_COPYNAME,
1608                              String_val(Field(formItem, 0)),
1609                              CURLFORM_NAMELENGTH,
1610                              caml_string_length(Field(formItem, 0)),
1611                              CURLFORM_COPYCONTENTS,
1612                              String_val(Field(formItem, 1)),
1613                              CURLFORM_CONTENTSLENGTH,
1614                              caml_string_length(Field(formItem, 1)),
1615                              CURLFORM_CONTENTTYPE,
1616                              String_val(Field(contentType, 0)),
1617                              CURLFORM_END);
1618             }
1619             else
1620             {
1621                 caml_failwith("Incorrect CURLFORM_CONTENT parameters");
1622             }
1623             break;
1624
1625         case 1: /* CURLFORM_FILECONTENT */
1626             if (Wosize_val(formItem) < 3)
1627             {
1628                 caml_failwith("Incorrect CURLFORM_FILECONTENT parameters");
1629             }
1630
1631             if (Is_long(Field(formItem, 2)) &&
1632                 Long_val(Field(formItem, 2)) == 0)
1633             {
1634                 curl_formadd(&conn->httpPostFirst,
1635                              &conn->httpPostLast,
1636                              CURLFORM_COPYNAME,
1637                              String_val(Field(formItem, 0)),
1638                              CURLFORM_NAMELENGTH,
1639                              caml_string_length(Field(formItem, 0)),
1640                              CURLFORM_FILECONTENT,
1641                              String_val(Field(formItem, 1)),
1642                              CURLFORM_END);
1643             }
1644             else if (Is_block(Field(formItem, 2)))
1645             {
1646                 contentType = Field(formItem, 2);
1647
1648                 curl_formadd(&conn->httpPostFirst,
1649                              &conn->httpPostLast,
1650                              CURLFORM_COPYNAME,
1651                              String_val(Field(formItem, 0)),
1652                              CURLFORM_NAMELENGTH,
1653                              caml_string_length(Field(formItem, 0)),
1654                              CURLFORM_FILECONTENT,
1655                              String_val(Field(formItem, 1)),
1656                              CURLFORM_CONTENTTYPE,
1657                              String_val(Field(contentType, 0)),
1658                              CURLFORM_END);
1659             }
1660             else
1661             {
1662                 caml_failwith("Incorrect CURLFORM_FILECONTENT parameters");
1663             }
1664             break;
1665
1666         case 2: /* CURLFORM_FILE */
1667             if (Wosize_val(formItem) < 3)
1668             {
1669                 caml_failwith("Incorrect CURLFORM_FILE parameters");
1670             }
1671
1672             if (Is_long(Field(formItem, 2)) &&
1673                 Long_val(Field(formItem, 2)) == 0)
1674             {
1675                 curl_formadd(&conn->httpPostFirst,
1676                              &conn->httpPostLast,
1677                              CURLFORM_COPYNAME,
1678                              String_val(Field(formItem, 0)),
1679                              CURLFORM_NAMELENGTH,
1680                              caml_string_length(Field(formItem, 0)),
1681                              CURLFORM_FILE,
1682                              String_val(Field(formItem, 1)),
1683                              CURLFORM_END);
1684             }
1685             else if (Is_block(Field(formItem, 2)))
1686             {
1687                 contentType = Field(formItem, 2);
1688
1689                 curl_formadd(&conn->httpPostFirst,
1690                              &conn->httpPostLast,
1691                              CURLFORM_COPYNAME,
1692                              String_val(Field(formItem, 0)),
1693                              CURLFORM_NAMELENGTH,
1694                              caml_string_length(Field(formItem, 0)),
1695                              CURLFORM_FILE,
1696                              String_val(Field(formItem, 1)),
1697                              CURLFORM_CONTENTTYPE,
1698                              String_val(Field(contentType, 0)),
1699                              CURLFORM_END);
1700             }
1701             else
1702             {
1703                 caml_failwith("Incorrect CURLFORM_FILE parameters");
1704             }
1705             break;
1706
1707         case 3: /* CURLFORM_BUFFER */
1708             if (Wosize_val(formItem) < 4)
1709             {
1710                 caml_failwith("Incorrect CURLFORM_BUFFER parameters");
1711             }
1712
1713             if (Is_long(Field(formItem, 3)) &&
1714                 Long_val(Field(formItem, 3)) == 0)
1715             {
1716                 conn->httpPostBuffers = curl_slist_prepend_ml(conn->httpPostBuffers, Field(formItem, 2));
1717
1718                 curl_formadd(&conn->httpPostFirst,
1719                              &conn->httpPostLast,
1720                              CURLFORM_COPYNAME,
1721                              String_val(Field(formItem, 0)),
1722                              CURLFORM_NAMELENGTH,
1723                              caml_string_length(Field(formItem, 0)),
1724                              CURLFORM_BUFFER,
1725                              String_val(Field(formItem, 1)),
1726                              CURLFORM_BUFFERPTR,
1727                              conn->httpPostBuffers->data,
1728                              CURLFORM_BUFFERLENGTH,
1729                              caml_string_length(Field(formItem, 2)),
1730                              CURLFORM_END);
1731             }
1732             else if (Is_block(Field(formItem, 3)))
1733             {
1734                 conn->httpPostBuffers = curl_slist_prepend_ml(conn->httpPostBuffers, Field(formItem, 2));
1735
1736                 contentType = Field(formItem, 3);
1737
1738                 curl_formadd(&conn->httpPostFirst,
1739                              &conn->httpPostLast,
1740                              CURLFORM_COPYNAME,
1741                              String_val(Field(formItem, 0)),
1742                              CURLFORM_NAMELENGTH,
1743                              caml_string_length(Field(formItem, 0)),
1744                              CURLFORM_BUFFER,
1745                              String_val(Field(formItem, 1)),
1746                              CURLFORM_BUFFERPTR,
1747                              conn->httpPostBuffers->data,
1748                              CURLFORM_BUFFERLENGTH,
1749                              caml_string_length(Field(formItem, 2)),
1750                              CURLFORM_CONTENTTYPE,
1751                              String_val(Field(contentType, 0)),
1752                              CURLFORM_END);
1753             }
1754             else
1755             {
1756                 caml_failwith("Incorrect CURLFORM_BUFFER parameters");
1757             }
1758             break;
1759         }
1760
1761         listIter = Field(listIter, 1);
1762     }
1763
1764     result = curl_easy_setopt(conn->handle,
1765                               CURLOPT_HTTPPOST,
1766                               conn->httpPostFirst);
1767
1768     if (result != CURLE_OK)
1769         raiseError(conn, result);
1770
1771     CAMLreturn0;
1772 }
1773
1774 SETOPT_STRING( SSLCERT)
1775 SETOPT_STRING( SSLCERTTYPE)
1776 SETOPT_STRING( SSLCERTPASSWD)
1777 SETOPT_STRING( SSLKEY)
1778 SETOPT_STRING( SSLKEYTYPE)
1779 SETOPT_STRING( SSLKEYPASSWD)
1780 SETOPT_STRING( SSLENGINE)
1781 SETOPT_BOOL( SSLENGINE_DEFAULT)
1782 SETOPT_BOOL( CRLF)
1783
1784 SETOPT_SLIST( QUOTE)
1785 SETOPT_SLIST( POSTQUOTE)
1786
1787 SETOPT_STRING( COOKIEFILE)
1788 #if HAVE_DECL_CURLOPT_CERTINFO
1789 SETOPT_BOOL( CERTINFO)
1790 #endif
1791
1792 #if !defined(CURL_SSLVERSION_TLSv1_0)
1793 #define CURL_SSLVERSION_TLSv1_0 CURL_SSLVERSION_TLSv1
1794 #endif
1795
1796 #if !defined(CURL_SSLVERSION_TLSv1_1)
1797 #define CURL_SSLVERSION_TLSv1_1 CURL_SSLVERSION_TLSv1
1798 #endif
1799
1800 #if !defined(CURL_SSLVERSION_TLSv1_2)
1801 #define CURL_SSLVERSION_TLSv1_2 CURL_SSLVERSION_TLSv1
1802 #endif
1803
1804 #if !defined(CURL_SSLVERSION_TLSv1_3)
1805 #define CURL_SSLVERSION_TLSv1_3 CURL_SSLVERSION_TLSv1
1806 #endif
1807
1808 static void handle_SSLVERSION(Connection *conn, value option)
1809 {
1810     CAMLparam1(option);
1811     CURLcode result = CURLE_OK;
1812     int v = CURL_SSLVERSION_DEFAULT;
1813
1814     switch (Long_val(option))
1815     {
1816     case 0: v = CURL_SSLVERSION_DEFAULT; break;
1817     case 1: v = CURL_SSLVERSION_TLSv1; break;
1818     case 2: v = CURL_SSLVERSION_SSLv2; break;
1819     case 3: v = CURL_SSLVERSION_SSLv3; break;
1820     case 4: v = CURL_SSLVERSION_TLSv1_0; break;
1821     case 5: v = CURL_SSLVERSION_TLSv1_1; break;
1822     case 6: v = CURL_SSLVERSION_TLSv1_2; break;
1823     case 7: v = CURL_SSLVERSION_TLSv1_3; break;
1824     default:
1825         caml_failwith("Invalid SSLVERSION Option");
1826         break;
1827     }
1828
1829     result = curl_easy_setopt(conn->handle, CURLOPT_SSLVERSION, v);
1830
1831     if (result != CURLE_OK)
1832         raiseError(conn, result);
1833
1834     CAMLreturn0;
1835 }
1836
1837 static void handle_TIMECONDITION(Connection *conn, value option)
1838 {
1839     CAMLparam1(option);
1840     CURLcode result = CURLE_OK;
1841     int timecond = CURL_TIMECOND_NONE;
1842
1843     switch (Long_val(option))
1844     {
1845     case 0: timecond = CURL_TIMECOND_NONE; break;
1846     case 1: timecond = CURL_TIMECOND_IFMODSINCE; break;
1847     case 2: timecond = CURL_TIMECOND_IFUNMODSINCE; break;
1848     case 3: timecond = CURL_TIMECOND_LASTMOD; break;
1849     default:
1850         caml_failwith("Invalid TIMECOND Option");
1851         break;
1852     }
1853
1854     result = curl_easy_setopt(conn->handle, CURLOPT_TIMECONDITION, timecond);
1855
1856     if (result != CURLE_OK)
1857         raiseError(conn, result);
1858
1859     CAMLreturn0;
1860 }
1861
1862 SETOPT_VAL( TIMEVALUE, Int32_val)
1863 SETOPT_STRING( CUSTOMREQUEST)
1864 SETOPT_STRING( INTERFACE)
1865
1866 static void handle_KRB4LEVEL(Connection *conn, value option)
1867 {
1868     CAMLparam1(option);
1869     CURLcode result = CURLE_OK;
1870
1871     switch (Long_val(option))
1872     {
1873     case 0: /* KRB4_NONE */
1874         result = curl_easy_setopt(conn->handle,
1875                                   CURLOPT_KRB4LEVEL,
1876                                   NULL);
1877         break;
1878
1879     case 1: /* KRB4_CLEAR */
1880         result = curl_easy_setopt(conn->handle,
1881                                   CURLOPT_KRB4LEVEL,
1882                                   "clear");
1883         break;
1884
1885     case 2: /* KRB4_SAFE */
1886         result = curl_easy_setopt(conn->handle,
1887                                   CURLOPT_KRB4LEVEL,
1888                                   "safe");
1889         break;
1890
1891     case 3: /* KRB4_CONFIDENTIAL */
1892         result = curl_easy_setopt(conn->handle,
1893                                   CURLOPT_KRB4LEVEL,
1894                                   "confidential");
1895         break;
1896
1897     case 4: /* KRB4_PRIVATE */
1898         result = curl_easy_setopt(conn->handle,
1899                                   CURLOPT_KRB4LEVEL,
1900                                   "private");
1901         break;
1902
1903     default:
1904         caml_failwith("Invalid KRB4 Option");
1905         break;
1906     }
1907
1908     if (result != CURLE_OK)
1909         raiseError(conn, result);
1910
1911     CAMLreturn0;
1912 }
1913
1914 SETOPT_BOOL( SSL_VERIFYPEER)
1915 SETOPT_STRING( CAINFO)
1916 SETOPT_STRING( CAPATH)
1917 SETOPT_BOOL( FILETIME)
1918 SETOPT_LONG( MAXREDIRS)
1919 SETOPT_LONG( MAXCONNECTS)
1920
1921 static void handle_CLOSEPOLICY(Connection *conn, value option)
1922 {
1923     CAMLparam1(option);
1924     CURLcode result = CURLE_OK;
1925
1926     switch (Long_val(option))
1927     {
1928     case 0: /* CLOSEPOLICY_OLDEST */
1929         result = curl_easy_setopt(conn->handle,
1930                                   CURLOPT_CLOSEPOLICY,
1931                                   CURLCLOSEPOLICY_OLDEST);
1932         break;
1933
1934     case 1: /* CLOSEPOLICY_LEAST_RECENTLY_USED */
1935         result = curl_easy_setopt(conn->handle,
1936                                   CURLOPT_CLOSEPOLICY,
1937                                   CURLCLOSEPOLICY_LEAST_RECENTLY_USED);
1938         break;
1939
1940     default:
1941         caml_failwith("Invalid CLOSEPOLICY Option");
1942         break;
1943     }
1944
1945     if (result != CURLE_OK)
1946         raiseError(conn, result);
1947
1948     CAMLreturn0;
1949 }
1950
1951 SETOPT_BOOL( FRESH_CONNECT)
1952 SETOPT_BOOL( FORBID_REUSE)
1953 SETOPT_STRING( RANDOM_FILE)
1954 SETOPT_STRING( EGDSOCKET)
1955 SETOPT_LONG( CONNECTTIMEOUT)
1956 SETOPT_BOOL( HTTPGET)
1957
1958 static void handle_SSL_VERIFYHOST(Connection *conn, value option)
1959 {
1960     CAMLparam1(option);
1961     CURLcode result = CURLE_OK;
1962
1963     switch (Long_val(option))
1964     {
1965     case 0: /* SSLVERIFYHOST_NONE */
1966     case 1: /* SSLVERIFYHOST_EXISTENCE */
1967     case 2: /* SSLVERIFYHOST_HOSTNAME */
1968         result = curl_easy_setopt(conn->handle,
1969                                   CURLOPT_SSL_VERIFYHOST,
1970                                   /* map EXISTENCE to HOSTNAME */
1971                                   Long_val(option) == 0 ? 0 : 2);
1972         break;
1973
1974     default:
1975         caml_failwith("Invalid SSLVERIFYHOST Option");
1976         break;
1977     }
1978
1979     if (result != CURLE_OK)
1980         raiseError(conn, result);
1981
1982     CAMLreturn0;
1983 }
1984
1985 SETOPT_STRING( COOKIEJAR)
1986 SETOPT_STRING( SSL_CIPHER_LIST)
1987
1988 static void handle_HTTP_VERSION(Connection *conn, value option)
1989 {
1990     CAMLparam1(option);
1991     CURLcode result = CURLE_OK;
1992
1993     long version = CURL_HTTP_VERSION_NONE;
1994
1995     switch (Long_val(option))
1996     {
1997     case 0: version = CURL_HTTP_VERSION_NONE; break;
1998     case 1: version = CURL_HTTP_VERSION_1_0; break;
1999     case 2: version = CURL_HTTP_VERSION_1_1; break;
2000     case 3:
2001 #if defined(CURL_HTTP_VERSION_2)
2002       version = CURL_HTTP_VERSION_2;
2003 #elif defined(CURL_HTTP_VERSION_2_0)
2004       version = CURL_HTTP_VERSION_2_0;
2005 #endif
2006       break;
2007     case 4:
2008 #if defined(CURL_HTTP_VERSION_2TLS)
2009       version = CURL_HTTP_VERSION_2TLS;
2010 #endif
2011       break;
2012     default:
2013       caml_invalid_argument("CURLOPT_HTTP_VERSION");
2014       break;
2015     }
2016
2017     result = curl_easy_setopt(conn->handle, CURLOPT_HTTP_VERSION, version);
2018
2019     if (result != CURLE_OK)
2020         raiseError(conn, result);
2021
2022     CAMLreturn0;
2023 }
2024
2025 SETOPT_BOOL( FTP_USE_EPSV)
2026 SETOPT_LONG( DNS_CACHE_TIMEOUT)
2027 SETOPT_BOOL( DNS_USE_GLOBAL_CACHE)
2028
2029 static void handle_PRIVATE(Connection *conn, value option)
2030 {
2031     CAMLparam1(option);
2032     Store_field(conn->ocamlValues, Ocaml_PRIVATE, option);
2033     CAMLreturn0;
2034 }
2035
2036 #if HAVE_DECL_CURLOPT_HTTP200ALIASES
2037 SETOPT_SLIST( HTTP200ALIASES)
2038 #endif
2039
2040 #if HAVE_DECL_CURLOPT_UNRESTRICTED_AUTH
2041 SETOPT_BOOL( UNRESTRICTED_AUTH)
2042 #endif
2043
2044 #if HAVE_DECL_CURLOPT_FTP_USE_EPRT
2045 SETOPT_BOOL( FTP_USE_EPRT)
2046 #endif
2047
2048 #if HAVE_DECL_CURLOPT_HTTPAUTH
2049 static void handle_HTTPAUTH(Connection *conn, value option)
2050 {
2051     CAMLparam1(option);
2052     CAMLlocal1(listIter);
2053     CURLcode result = CURLE_OK;
2054     long auth = CURLAUTH_NONE;
2055
2056     listIter = option;
2057
2058     while (!Is_long(listIter))
2059     {
2060         switch (Long_val(Field(listIter, 0)))
2061         {
2062         case 0: /* CURLAUTH_BASIC */
2063             auth |= CURLAUTH_BASIC;
2064             break;
2065
2066         case 1: /* CURLAUTH_DIGEST */
2067             auth |= CURLAUTH_DIGEST;
2068             break;
2069
2070         case 2: /* CURLAUTH_GSSNEGOTIATE */
2071             auth |= CURLAUTH_GSSNEGOTIATE;
2072             break;
2073
2074         case 3: /* CURLAUTH_NTLM */
2075             auth |= CURLAUTH_NTLM;
2076             break;
2077
2078         case 4: /* CURLAUTH_ANY */
2079             auth |= CURLAUTH_ANY;
2080             break;
2081
2082         case 5: /* CURLAUTH_ANYSAFE */
2083             auth |= CURLAUTH_ANYSAFE;
2084             break;
2085
2086         default:
2087             caml_failwith("Invalid HTTPAUTH Value");
2088             break;
2089         }
2090
2091         listIter = Field(listIter, 1);
2092     }
2093
2094     result = curl_easy_setopt(conn->handle,
2095                               CURLOPT_HTTPAUTH,
2096                               auth);
2097
2098     if (result != CURLE_OK)
2099         raiseError(conn, result);
2100
2101     CAMLreturn0;
2102 }
2103 #endif
2104
2105 #if HAVE_DECL_CURLOPT_FTP_CREATE_MISSING_DIRS
2106 SETOPT_BOOL( FTP_CREATE_MISSING_DIRS)
2107 #endif
2108
2109 #if HAVE_DECL_CURLOPT_PROXYAUTH
2110 static void handle_PROXYAUTH(Connection *conn, value option)
2111 {
2112     CAMLparam1(option);
2113     CAMLlocal1(listIter);
2114     CURLcode result = CURLE_OK;
2115     long auth = CURLAUTH_NONE;
2116
2117     listIter = option;
2118
2119     while (!Is_long(listIter))
2120     {
2121         switch (Long_val(Field(listIter, 0)))
2122         {
2123         case 0: /* CURLAUTH_BASIC */
2124             auth |= CURLAUTH_BASIC;
2125             break;
2126
2127         case 1: /* CURLAUTH_DIGEST */
2128             auth |= CURLAUTH_DIGEST;
2129             break;
2130
2131         case 2: /* CURLAUTH_GSSNEGOTIATE */
2132             auth |= CURLAUTH_GSSNEGOTIATE;
2133             break;
2134
2135         case 3: /* CURLAUTH_NTLM */
2136             auth |= CURLAUTH_NTLM;
2137             break;
2138
2139         case 4: /* CURLAUTH_ANY */
2140             auth |= CURLAUTH_ANY;
2141             break;
2142
2143         case 5: /* CURLAUTH_ANYSAFE */
2144             auth |= CURLAUTH_ANYSAFE;
2145             break;
2146
2147         default:
2148             caml_failwith("Invalid HTTPAUTH Value");
2149             break;
2150         }
2151
2152         listIter = Field(listIter, 1);
2153     }
2154
2155     result = curl_easy_setopt(conn->handle,
2156                               CURLOPT_PROXYAUTH,
2157                               auth);
2158
2159     if (result != CURLE_OK)
2160         raiseError(conn, result);
2161
2162     CAMLreturn0;
2163 }
2164 #endif
2165
2166 #if HAVE_DECL_CURLOPT_FTP_RESPONSE_TIMEOUT
2167 SETOPT_LONG( FTP_RESPONSE_TIMEOUT)
2168 #endif
2169
2170 #if HAVE_DECL_CURLOPT_IPRESOLVE
2171 static void handle_IPRESOLVE(Connection *conn, value option)
2172 {
2173     CAMLparam1(option);
2174     CURLcode result = CURLE_OK;
2175
2176     switch (Long_val(option))
2177     {
2178     case 0: /* CURL_IPRESOLVE_WHATEVER */
2179         result = curl_easy_setopt(conn->handle,
2180                                   CURLOPT_IPRESOLVE,
2181                                   CURL_IPRESOLVE_WHATEVER);
2182         break;
2183
2184     case 1: /* CURL_IPRESOLVE_V4 */
2185         result = curl_easy_setopt(conn->handle,
2186                                   CURLOPT_IPRESOLVE,
2187                                   CURL_IPRESOLVE_V4);
2188         break;
2189
2190     case 2: /* CURL_IPRESOLVE_V6 */
2191         result = curl_easy_setopt(conn->handle,
2192                                   CURLOPT_IPRESOLVE,
2193                                   CURL_IPRESOLVE_V6);
2194         break;
2195
2196     default:
2197         caml_failwith("Invalid IPRESOLVE Value");
2198         break;
2199     }
2200
2201     if (result != CURLE_OK)
2202         raiseError(conn, result);
2203
2204     CAMLreturn0;
2205 }
2206 #endif
2207
2208 #if HAVE_DECL_CURLOPT_MAXFILESIZE
2209 SETOPT_VAL( MAXFILESIZE, Int32_val)
2210 #endif
2211
2212 #if HAVE_DECL_CURLOPT_INFILESIZE_LARGE
2213 SETOPT_INT64( INFILESIZE_LARGE)
2214 #endif
2215
2216 #if HAVE_DECL_CURLOPT_RESUME_FROM_LARGE
2217 SETOPT_INT64( RESUME_FROM_LARGE)
2218 #endif
2219
2220 #if HAVE_DECL_CURLOPT_MAXFILESIZE_LARGE
2221 SETOPT_INT64( MAXFILESIZE_LARGE)
2222 #endif
2223
2224 #if HAVE_DECL_CURLOPT_NETRC_FILE
2225 SETOPT_STRING( NETRC_FILE)
2226 #endif
2227
2228 #if HAVE_DECL_CURLOPT_FTP_SSL
2229 static void handle_FTP_SSL(Connection *conn, value option)
2230 {
2231     CAMLparam1(option);
2232     CURLcode result = CURLE_OK;
2233
2234     switch (Long_val(option))
2235     {
2236     case 0: /* CURLFTPSSL_NONE */
2237         result = curl_easy_setopt(conn->handle,
2238                                   CURLOPT_FTP_SSL,
2239                                   CURLFTPSSL_NONE);
2240         break;
2241
2242     case 1: /* CURLFTPSSL_TRY */
2243         result = curl_easy_setopt(conn->handle,
2244                                   CURLOPT_FTP_SSL,
2245                                   CURLFTPSSL_TRY);
2246         break;
2247
2248     case 2: /* CURLFTPSSL_CONTROL */
2249         result = curl_easy_setopt(conn->handle,
2250                                   CURLOPT_FTP_SSL,
2251                                   CURLFTPSSL_CONTROL);
2252         break;
2253
2254     case 3: /* CURLFTPSSL_ALL */
2255         result = curl_easy_setopt(conn->handle,
2256                                   CURLOPT_FTP_SSL,
2257                                   CURLFTPSSL_ALL);
2258         break;
2259
2260     default:
2261         caml_failwith("Invalid FTP_SSL Value");
2262         break;
2263     }
2264
2265     if (result != CURLE_OK)
2266         raiseError(conn, result);
2267
2268     CAMLreturn0;
2269 }
2270 #endif
2271
2272 #if HAVE_DECL_CURLOPT_POSTFIELDSIZE_LARGE
2273 SETOPT_INT64( POSTFIELDSIZE_LARGE)
2274 #endif
2275
2276 #if HAVE_DECL_CURLOPT_TCP_NODELAY
2277 /* not using SETOPT_BOOL here because of TCP_NODELAY defined in winsock.h */
2278 SETOPT_VAL_( handle_TCP_NODELAY, CURLOPT_TCP_NODELAY, Bool_val)
2279 #endif
2280
2281 #if HAVE_DECL_CURLOPT_FTPSSLAUTH
2282 static void handle_FTPSSLAUTH(Connection *conn, value option)
2283 {
2284     CAMLparam1(option);
2285     CURLcode result = CURLE_OK;
2286
2287     switch (Long_val(option))
2288     {
2289     case 0: /* CURLFTPAUTH_DEFAULT */
2290         result = curl_easy_setopt(conn->handle,
2291                                   CURLOPT_FTPSSLAUTH,
2292                                   CURLFTPAUTH_DEFAULT);
2293         break;
2294
2295     case 1: /* CURLFTPAUTH_SSL */
2296         result = curl_easy_setopt(conn->handle,
2297                                   CURLOPT_FTPSSLAUTH,
2298                                   CURLFTPAUTH_SSL);
2299         break;
2300
2301     case 2: /* CURLFTPAUTH_TLS */
2302         result = curl_easy_setopt(conn->handle,
2303                                   CURLOPT_FTPSSLAUTH,
2304                                   CURLFTPAUTH_TLS);
2305         break;
2306
2307     default:
2308         caml_failwith("Invalid FTPSSLAUTH value");
2309         break;
2310     }
2311
2312     if (result != CURLE_OK)
2313         raiseError(conn, result);
2314
2315     CAMLreturn0;
2316 }
2317 #endif
2318
2319 #if HAVE_DECL_CURLOPT_FTP_ACCOUNT
2320 SETOPT_STRING( FTP_ACCOUNT)
2321 #endif
2322
2323 #if HAVE_DECL_CURLOPT_COOKIELIST
2324 SETOPT_STRING( COOKIELIST)
2325 #endif
2326
2327 #if HAVE_DECL_CURLOPT_IGNORE_CONTENT_LENGTH
2328 SETOPT_BOOL( IGNORE_CONTENT_LENGTH)
2329 #endif
2330
2331 #if HAVE_DECL_CURLOPT_FTP_SKIP_PASV_IP
2332 SETOPT_BOOL( FTP_SKIP_PASV_IP)
2333 #endif
2334
2335 #if HAVE_DECL_CURLOPT_FTP_FILEMETHOD
2336 static void handle_FTP_FILEMETHOD(Connection *conn, value option)
2337 {
2338     CAMLparam1(option);
2339     CURLcode result = CURLE_OK;
2340
2341     switch (Long_val(option))
2342     {
2343     case 0: /* CURLFTPMETHOD_DEFAULT */
2344         result = curl_easy_setopt(conn->handle,
2345                                   CURLOPT_FTP_FILEMETHOD,
2346                                   CURLFTPMETHOD_DEFAULT);
2347         break;
2348
2349     case 1: /* CURLFTMETHOD_MULTICWD */
2350         result = curl_easy_setopt(conn->handle,
2351                                   CURLOPT_FTP_FILEMETHOD,
2352                                   CURLFTPMETHOD_MULTICWD);
2353         break;
2354
2355     case 2: /* CURLFTPMETHOD_NOCWD */
2356         result = curl_easy_setopt(conn->handle,
2357                                   CURLOPT_FTP_FILEMETHOD,
2358                                   CURLFTPMETHOD_NOCWD);
2359         break;
2360
2361     case 3: /* CURLFTPMETHOD_SINGLECWD */
2362         result = curl_easy_setopt(conn->handle,
2363                                   CURLOPT_FTP_FILEMETHOD,
2364                                   CURLFTPMETHOD_SINGLECWD);
2365
2366     default:
2367         caml_failwith("Invalid FTP_FILEMETHOD value");
2368         break;
2369     }
2370
2371     if (result != CURLE_OK)
2372         raiseError(conn, result);
2373
2374     CAMLreturn0;
2375 }
2376 #endif
2377
2378 #if HAVE_DECL_CURLOPT_LOCALPORT
2379 SETOPT_LONG( LOCALPORT)
2380 #endif
2381
2382 #if HAVE_DECL_CURLOPT_LOCALPORTRANGE
2383 SETOPT_LONG( LOCALPORTRANGE)
2384 #endif
2385
2386 #if HAVE_DECL_CURLOPT_CONNECT_ONLY
2387 SETOPT_BOOL( CONNECT_ONLY)
2388 #endif
2389
2390 #if HAVE_DECL_CURLOPT_MAX_SEND_SPEED_LARGE
2391 SETOPT_INT64( MAX_SEND_SPEED_LARGE)
2392 #endif
2393
2394 #if HAVE_DECL_CURLOPT_MAX_RECV_SPEED_LARGE
2395 SETOPT_INT64( MAX_RECV_SPEED_LARGE)
2396 #endif
2397
2398 #if HAVE_DECL_CURLOPT_FTP_ALTERNATIVE_TO_USER
2399 SETOPT_STRING( FTP_ALTERNATIVE_TO_USER)
2400 #endif
2401
2402 #if HAVE_DECL_CURLOPT_SSL_SESSIONID_CACHE
2403 SETOPT_BOOL( SSL_SESSIONID_CACHE)
2404 #endif
2405
2406 #if HAVE_DECL_CURLOPT_SSH_AUTH_TYPES
2407 static void handle_SSH_AUTH_TYPES(Connection *conn, value option)
2408 {
2409     CAMLparam1(option);
2410     CAMLlocal1(listIter);
2411     CURLcode result = CURLE_OK;
2412     long authTypes = CURLSSH_AUTH_NONE;
2413
2414     listIter = option;
2415
2416     while (!Is_long(listIter))
2417     {
2418         switch (Long_val(Field(listIter, 0)))
2419         {
2420         case 0: /* CURLSSH_AUTH_ANY */
2421             authTypes |= CURLSSH_AUTH_ANY;
2422             break;
2423
2424         case 1: /* CURLSSH_AUTH_PUBLICKEY */
2425             authTypes |= CURLSSH_AUTH_PUBLICKEY;
2426             break;
2427
2428         case 2: /* CURLSSH_AUTH_PASSWORD */
2429             authTypes |= CURLSSH_AUTH_PASSWORD;
2430             break;
2431
2432         case 3: /* CURLSSH_AUTH_HOST */
2433             authTypes |= CURLSSH_AUTH_HOST;
2434             break;
2435
2436         case 4: /* CURLSSH_AUTH_KEYBOARD */
2437             authTypes |= CURLSSH_AUTH_KEYBOARD;
2438             break;
2439
2440         default:
2441             caml_failwith("Invalid CURLSSH_AUTH_TYPES Value");
2442             break;
2443         }
2444
2445         listIter = Field(listIter, 1);
2446     }
2447
2448     result = curl_easy_setopt(conn->handle,
2449                               CURLOPT_SSH_AUTH_TYPES,
2450                               authTypes);
2451
2452     if (result != CURLE_OK)
2453         raiseError(conn, result);
2454
2455     CAMLreturn0;
2456 }
2457 #endif
2458
2459 #if HAVE_DECL_CURLOPT_SSH_PUBLIC_KEYFILE
2460 SETOPT_STRING( SSH_PUBLIC_KEYFILE)
2461 #endif
2462
2463 #if HAVE_DECL_CURLOPT_SSH_PRIVATE_KEYFILE
2464 SETOPT_STRING( SSH_PRIVATE_KEYFILE)
2465 #endif
2466
2467 #if HAVE_DECL_CURLOPT_FTP_SSL_CCC
2468 static void handle_FTP_SSL_CCC(Connection *conn, value option)
2469 {
2470     CAMLparam1(option);
2471     CURLcode result = CURLE_OK;
2472
2473     switch (Long_val(option))
2474     {
2475     case 0: /* CURLFTPSSL_CCC_NONE */
2476         result = curl_easy_setopt(conn->handle,
2477                                   CURLOPT_FTP_SSL_CCC,
2478                                   CURLFTPSSL_CCC_NONE);
2479         break;
2480
2481     case 1: /* CURLFTPSSL_CCC_PASSIVE */
2482         result = curl_easy_setopt(conn->handle,
2483                                   CURLOPT_FTP_SSL_CCC,
2484                                   CURLFTPSSL_CCC_PASSIVE);
2485         break;
2486
2487     case 2: /* CURLFTPSSL_CCC_ACTIVE */
2488         result = curl_easy_setopt(conn->handle,
2489                                   CURLOPT_FTP_SSL_CCC,
2490                                   CURLFTPSSL_CCC_ACTIVE);
2491         break;
2492
2493     default:
2494         caml_failwith("Invalid FTPSSL_CCC value");
2495         break;
2496     }
2497
2498     if (result != CURLE_OK)
2499         raiseError(conn, result);
2500
2501     CAMLreturn0;
2502 }
2503 #endif
2504
2505 #if HAVE_DECL_CURLOPT_TIMEOUT_MS
2506 SETOPT_LONG( TIMEOUT_MS)
2507 #endif
2508
2509 #if HAVE_DECL_CURLOPT_CONNECTTIMEOUT_MS
2510 SETOPT_LONG( CONNECTTIMEOUT_MS)
2511 #endif
2512
2513 #if HAVE_DECL_CURLOPT_HTTP_TRANSFER_DECODING
2514 SETOPT_BOOL( HTTP_TRANSFER_DECODING)
2515 #endif
2516
2517 #if HAVE_DECL_CURLOPT_HTTP_CONTENT_DECODING
2518 SETOPT_BOOL( HTTP_CONTENT_DECODING)
2519 #endif
2520
2521 #if HAVE_DECL_CURLOPT_NEW_FILE_PERMS
2522 SETOPT_LONG( NEW_FILE_PERMS)
2523 #endif
2524
2525 #if HAVE_DECL_CURLOPT_NEW_DIRECTORY_PERMS
2526 SETOPT_LONG( NEW_DIRECTORY_PERMS)
2527 #endif
2528
2529 #if HAVE_DECL_CURLOPT_POST301
2530 SETOPT_BOOL( POST301)
2531 #endif
2532
2533 #if HAVE_DECL_CURLOPT_SSH_HOST_PUBLIC_KEY_MD5
2534 SETOPT_STRING( SSH_HOST_PUBLIC_KEY_MD5)
2535 #endif
2536
2537 #if HAVE_DECL_CURLOPT_COPYPOSTFIELDS
2538 SETOPT_STRING( COPYPOSTFIELDS)
2539 #endif
2540
2541 #if HAVE_DECL_CURLOPT_PROXY_TRANSFER_MODE
2542 SETOPT_BOOL( PROXY_TRANSFER_MODE)
2543 #endif
2544
2545 #if HAVE_DECL_CURLOPT_AUTOREFERER
2546 SETOPT_BOOL( AUTOREFERER)
2547 #endif
2548
2549 #if HAVE_DECL_CURLOPT_PROXYTYPE
2550 static void handle_PROXYTYPE(Connection *conn, value option)
2551 {
2552     CAMLparam1(option);
2553     CURLcode result = CURLE_OK;
2554     long proxy_type;
2555
2556     switch (Long_val(option))
2557     {
2558       case 0: proxy_type = CURLPROXY_HTTP; break;
2559       case 1: proxy_type = CURLPROXY_HTTP_1_0; break;
2560       case 2: proxy_type = CURLPROXY_SOCKS4; break;
2561       case 3: proxy_type = CURLPROXY_SOCKS5; break;
2562       case 4: proxy_type = CURLPROXY_SOCKS4A; break;
2563       case 5: proxy_type = CURLPROXY_SOCKS5_HOSTNAME; break;
2564       default:
2565         caml_failwith("Invalid curl proxy type");
2566     }
2567
2568     result = curl_easy_setopt(conn->handle,
2569                               CURLOPT_PROXYTYPE,
2570                               proxy_type);
2571
2572     if (result != CURLE_OK)
2573         raiseError(conn, result);
2574
2575     CAMLreturn0;
2576 }
2577 #endif
2578
2579 #if HAVE_DECL_CURLOPT_PROTOCOLS || HAVE_DECL_CURLOPT_REDIR_PROTOCOLS
2580
2581 long protoMap[] =
2582 {
2583   CURLPROTO_ALL,
2584   CURLPROTO_HTTP, CURLPROTO_HTTPS, CURLPROTO_FTP, CURLPROTO_FTPS, CURLPROTO_SCP, CURLPROTO_SFTP,
2585   CURLPROTO_TELNET, CURLPROTO_LDAP, CURLPROTO_LDAPS, CURLPROTO_DICT, CURLPROTO_FILE, CURLPROTO_TFTP,
2586 /* factor out with autoconf? */
2587 #if defined(CURLPROTO_IMAP)
2588   CURLPROTO_IMAP,
2589 #else
2590   0,
2591 #endif
2592 #if defined(CURLPROTO_IMAPS)
2593   CURLPROTO_IMAPS,
2594 #else
2595   0,
2596 #endif
2597 #if defined(CURLPROTO_POP3)
2598   CURLPROTO_POP3,
2599 #else
2600   0,
2601 #endif
2602 #if defined(CURLPROTO_POP3S)
2603   CURLPROTO_POP3S,
2604 #else
2605   0,
2606 #endif
2607 #if defined(CURLPROTO_SMTP)
2608   CURLPROTO_SMTP,
2609 #else
2610   0,
2611 #endif
2612 #if defined(CURLPROTO_SMTPS)
2613   CURLPROTO_SMTPS,
2614 #else
2615   0,
2616 #endif
2617 #if defined(CURLPROTO_RTSP)
2618   CURLPROTO_RTSP,
2619 #else
2620   0,
2621 #endif
2622 #if defined(CURLPROTO_RTMP)
2623   CURLPROTO_RTMP,
2624 #else
2625   0,
2626 #endif
2627 #if defined(CURLPROTO_RTMPT)
2628   CURLPROTO_RTMPT,
2629 #else
2630   0,
2631 #endif
2632 #if defined(CURLPROTO_RTMPE)
2633   CURLPROTO_RTMPE,
2634 #else
2635   0,
2636 #endif
2637 #if defined(CURLPROTO_RTMPTE)
2638   CURLPROTO_RTMPTE,
2639 #else
2640   0,
2641 #endif
2642 #if defined(CURLPROTO_RTMPS)
2643   CURLPROTO_RTMPS,
2644 #else
2645   0,
2646 #endif
2647 #if defined(CURLPROTO_RTMPTS)
2648   CURLPROTO_RTMPTS,
2649 #else
2650   0,
2651 #endif
2652 #if defined(CURLPROTO_GOPHER)
2653   CURLPROTO_GOPHER,
2654 #else
2655   0,
2656 #endif
2657 };
2658
2659 static void handle_PROTOCOLSOPTION(CURLoption curlopt, Connection *conn, value option)
2660 {
2661     CAMLparam1(option);
2662     CURLcode result = CURLE_OK;
2663     long bits = convert_bit_list(protoMap, sizeof(protoMap) / sizeof(protoMap[0]), option);
2664
2665     result = curl_easy_setopt(conn->handle, curlopt, bits);
2666
2667     if (result != CURLE_OK)
2668         raiseError(conn, result);
2669
2670     CAMLreturn0;
2671 }
2672 #endif
2673
2674 #if HAVE_DECL_CURLOPT_PROTOCOLS
2675 static void handle_PROTOCOLS(Connection *conn, value option)
2676 {
2677   handle_PROTOCOLSOPTION(CURLOPT_PROTOCOLS, conn, option);
2678 }
2679 #endif
2680
2681 #if HAVE_DECL_CURLOPT_REDIR_PROTOCOLS
2682 static void handle_REDIR_PROTOCOLS(Connection *conn, value option)
2683 {
2684   handle_PROTOCOLSOPTION(CURLOPT_REDIR_PROTOCOLS, conn, option);
2685 }
2686 #endif
2687
2688 #if HAVE_DECL_CURLOPT_RESOLVE
2689 SETOPT_SLIST( RESOLVE)
2690 #endif
2691
2692 #if HAVE_DECL_CURLOPT_DNS_SERVERS
2693 SETOPT_STRING( DNS_SERVERS)
2694 #endif
2695
2696 #if HAVE_DECL_CURLOPT_MAIL_FROM
2697 SETOPT_STRING( MAIL_FROM)
2698 #endif
2699
2700 #if HAVE_DECL_CURLOPT_MAIL_RCPT
2701 SETOPT_SLIST( MAIL_RCPT)
2702 #endif
2703
2704 #if HAVE_DECL_CURLOPT_PIPEWAIT
2705 SETOPT_BOOL( PIPEWAIT)
2706 #endif
2707
2708 /**
2709  **  curl_easy_setopt helper function
2710  **/
2711
2712 #define MAP(name) { handle_ ## name, "CURLOPT_"#name, Ocaml_##name }
2713 #define MAP_NO(name) { NULL, "CURLOPT_"#name , Ocaml_##name }
2714 #define IMM(name) { handle_ ## name, "CURLOPT_"#name, -1 }
2715 #define IMM_NO(name) { NULL, "CURLOPT_"#name , -1 }
2716
2717 CURLOptionMapping implementedOptionMap[] =
2718 {
2719   MAP(WRITEFUNCTION),
2720   MAP(READFUNCTION),
2721   IMM(INFILESIZE),
2722   MAP(URL),
2723   MAP(PROXY),
2724   IMM(PROXYPORT),
2725   IMM(HTTPPROXYTUNNEL),
2726   IMM(VERBOSE),
2727   IMM(HEADER),
2728   IMM(NOPROGRESS),
2729 #if HAVE_DECL_CURLOPT_NOSIGNAL
2730   IMM(NOSIGNAL),
2731 #else
2732   IMM_NO(NOSIGNAL),
2733 #endif
2734   IMM(NOBODY),
2735   IMM(FAILONERROR),
2736   IMM(UPLOAD),
2737   IMM(POST),
2738   IMM(FTPLISTONLY),
2739   IMM(FTPAPPEND),
2740   IMM(NETRC),
2741 #if HAVE_DECL_CURLOPT_ENCODING
2742   IMM(ENCODING),
2743 #else
2744   IMM_NO(ENCODING),
2745 #endif
2746   IMM(FOLLOWLOCATION),
2747   IMM(TRANSFERTEXT),
2748   IMM(PUT),
2749   MAP(USERPWD),
2750   MAP(PROXYUSERPWD),
2751   MAP(RANGE),
2752   IMM(ERRORBUFFER), /* mutable buffer, as output value, do not duplicate */
2753   IMM(TIMEOUT),
2754   MAP(POSTFIELDS),
2755   IMM(POSTFIELDSIZE),
2756   MAP(REFERER),
2757   MAP(USERAGENT),
2758   MAP(FTPPORT),
2759   IMM(LOW_SPEED_LIMIT),
2760   IMM(LOW_SPEED_TIME),
2761   IMM(RESUME_FROM),
2762   MAP(COOKIE),
2763   MAP(HTTPHEADER),
2764   MAP(HTTPPOST),
2765   MAP(SSLCERT),
2766   MAP(SSLCERTTYPE),
2767   MAP(SSLCERTPASSWD),
2768   MAP(SSLKEY),
2769   MAP(SSLKEYTYPE),
2770   MAP(SSLKEYPASSWD),
2771   MAP(SSLENGINE),
2772   IMM(SSLENGINE_DEFAULT),
2773   IMM(CRLF),
2774   MAP(QUOTE),
2775   MAP(POSTQUOTE),
2776   MAP(HEADERFUNCTION),
2777   MAP(COOKIEFILE),
2778   IMM(SSLVERSION),
2779   IMM(TIMECONDITION),
2780   IMM(TIMEVALUE),
2781   MAP(CUSTOMREQUEST),
2782   MAP(INTERFACE),
2783   IMM(KRB4LEVEL),
2784   MAP(PROGRESSFUNCTION),
2785   IMM(SSL_VERIFYPEER),
2786   MAP(CAINFO),
2787   MAP(CAPATH),
2788   IMM(FILETIME),
2789   IMM(MAXREDIRS),
2790   IMM(MAXCONNECTS),
2791   IMM(CLOSEPOLICY),
2792   IMM(FRESH_CONNECT),
2793   IMM(FORBID_REUSE),
2794   MAP(RANDOM_FILE),
2795   MAP(EGDSOCKET),
2796   IMM(CONNECTTIMEOUT),
2797   IMM(HTTPGET),
2798   IMM(SSL_VERIFYHOST),
2799   MAP(COOKIEJAR),
2800   MAP(SSL_CIPHER_LIST),
2801   IMM(HTTP_VERSION),
2802   IMM(FTP_USE_EPSV),
2803   IMM(DNS_CACHE_TIMEOUT),
2804   IMM(DNS_USE_GLOBAL_CACHE),
2805   MAP(DEBUGFUNCTION),
2806   MAP(PRIVATE),
2807 #if HAVE_DECL_CURLOPT_HTTP200ALIASES
2808   MAP(HTTP200ALIASES),
2809 #else
2810   MAP_NO(HTTP200ALIASES),
2811 #endif
2812 #if HAVE_DECL_CURLOPT_UNRESTRICTED_AUTH
2813   IMM(UNRESTRICTED_AUTH),
2814 #else
2815   IMM_NO(UNRESTRICTED_AUTH),
2816 #endif
2817 #if HAVE_DECL_CURLOPT_FTP_USE_EPRT
2818   IMM(FTP_USE_EPRT),
2819 #else
2820   IMM_NO(FTP_USE_EPRT),
2821 #endif
2822 #if HAVE_DECL_CURLOPT_HTTPAUTH
2823   IMM(HTTPAUTH),
2824 #else
2825   IMM_NO(HTTPAUTH),
2826 #endif
2827 #if HAVE_DECL_CURLOPT_FTP_CREATE_MISSING_DIRS
2828   IMM(FTP_CREATE_MISSING_DIRS),
2829 #else
2830   IMM_NO(FTP_CREATE_MISSING_DIRS),
2831 #endif
2832 #if HAVE_DECL_CURLOPT_PROXYAUTH
2833   IMM(PROXYAUTH),
2834 #else
2835   IMM_NO(PROXYAUTH),
2836 #endif
2837 #if HAVE_DECL_CURLOPT_FTP_RESPONSE_TIMEOUT
2838   IMM(FTP_RESPONSE_TIMEOUT),
2839 #else
2840   IMM_NO(FTP_RESPONSE_TIMEOUT),
2841 #endif
2842 #if HAVE_DECL_CURLOPT_IPRESOLVE
2843   IMM(IPRESOLVE),
2844 #else
2845   IMM_NO(IPRESOLVE),
2846 #endif
2847 #if HAVE_DECL_CURLOPT_MAXFILESIZE
2848   IMM(MAXFILESIZE),
2849 #else
2850   IMM_NO(MAXFILESIZE),
2851 #endif
2852 #if HAVE_DECL_CURLOPT_INFILESIZE_LARGE
2853   IMM(INFILESIZE_LARGE),
2854 #else
2855   IMM_NO(INFILESIZE_LARGE),
2856 #endif
2857 #if HAVE_DECL_CURLOPT_RESUME_FROM_LARGE
2858   IMM(RESUME_FROM_LARGE),
2859 #else
2860   IMM_NO(RESUME_FROM_LARGE),
2861 #endif
2862 #if HAVE_DECL_CURLOPT_MAXFILESIZE_LARGE
2863   IMM(MAXFILESIZE_LARGE),
2864 #else
2865   IMM_NO(MAXFILESIZE_LARGE),
2866 #endif
2867 #if HAVE_DECL_CURLOPT_NETRC_FILE
2868   MAP(NETRC_FILE),
2869 #else
2870   MAP_NO(NETRC_FILE),
2871 #endif
2872 #if HAVE_DECL_CURLOPT_FTP_SSL
2873   IMM(FTP_SSL),
2874 #else
2875   IMM_NO(FTP_SSL),
2876 #endif
2877 #if HAVE_DECL_CURLOPT_POSTFIELDSIZE_LARGE
2878   IMM(POSTFIELDSIZE_LARGE),
2879 #else
2880   IMM_NO(POSTFIELDSIZE_LARGE),
2881 #endif
2882 #if HAVE_DECL_CURLOPT_TCP_NODELAY
2883   IMM(TCP_NODELAY),
2884 #else
2885   IMM_NO(TCP_NODELAY),
2886 #endif
2887 #if HAVE_DECL_CURLOPT_FTPSSLAUTH
2888   IMM(FTPSSLAUTH),
2889 #else
2890   IMM_NO(FTPSSLAUTH),
2891 #endif
2892 #if HAVE_DECL_CURLOPT_IOCTLFUNCTION
2893   MAP(IOCTLFUNCTION),
2894 #else
2895   MAP_NO(IOCTLFUNCTION),
2896 #endif
2897 #if HAVE_DECL_CURLOPT_FTP_ACCOUNT
2898   MAP(FTP_ACCOUNT),
2899 #else
2900   MAP_NO(FTP_ACCOUNT),
2901 #endif
2902 #if HAVE_DECL_CURLOPT_COOKIELIST
2903   MAP(COOKIELIST),
2904 #else
2905   MAP_NO(COOKIELIST),
2906 #endif
2907 #if HAVE_DECL_CURLOPT_IGNORE_CONTENT_LENGTH
2908   IMM(IGNORE_CONTENT_LENGTH),
2909 #else
2910   IMM_NO(IGNORE_CONTENT_LENGTH),
2911 #endif
2912 #if HAVE_DECL_CURLOPT_FTP_SKIP_PASV_IP
2913   IMM(FTP_SKIP_PASV_IP),
2914 #else
2915   IMM_NO(FTP_SKIP_PASV_IP),
2916 #endif
2917 #if HAVE_DECL_CURLOPT_FTP_FILEMETHOD
2918   IMM(FTP_FILEMETHOD),
2919 #else
2920   IMM_NO(FTP_FILEMETHOD),
2921 #endif
2922 #if HAVE_DECL_CURLOPT_LOCALPORT
2923   IMM(LOCALPORT),
2924 #else
2925   IMM_NO(LOCALPORT),
2926 #endif
2927 #if HAVE_DECL_CURLOPT_LOCALPORTRANGE
2928   IMM(LOCALPORTRANGE),
2929 #else
2930   IMM_NO(LOCALPORTRANGE),
2931 #endif
2932 #if HAVE_DECL_CURLOPT_CONNECT_ONLY
2933   IMM(CONNECT_ONLY),
2934 #else
2935   IMM_NO(CONNECT_ONLY),
2936 #endif
2937 #if HAVE_DECL_CURLOPT_MAX_SEND_SPEED_LARGE
2938   IMM(MAX_SEND_SPEED_LARGE),
2939 #else
2940   IMM_NO(MAX_SEND_SPEED_LARGE),
2941 #endif
2942 #if HAVE_DECL_CURLOPT_MAX_RECV_SPEED_LARGE
2943   IMM(MAX_RECV_SPEED_LARGE),
2944 #else
2945   IMM_NO(MAX_RECV_SPEED_LARGE),
2946 #endif
2947 #if HAVE_DECL_CURLOPT_FTP_ALTERNATIVE_TO_USER
2948   MAP(FTP_ALTERNATIVE_TO_USER),
2949 #else
2950   MAP_NO(FTP_ALTERNATIVE_TO_USER),
2951 #endif
2952 #if HAVE_DECL_CURLOPT_SSL_SESSIONID_CACHE
2953   IMM(SSL_SESSIONID_CACHE),
2954 #else
2955   IMM_NO(SSL_SESSIONID_CACHE),
2956 #endif
2957 #if HAVE_DECL_CURLOPT_SSH_AUTH_TYPES
2958   IMM(SSH_AUTH_TYPES),
2959 #else
2960   IMM_NO(SSH_AUTH_TYPES),
2961 #endif
2962 #if HAVE_DECL_CURLOPT_SSH_PUBLIC_KEYFILE
2963   MAP(SSH_PUBLIC_KEYFILE),
2964 #else
2965   MAP_NO(SSH_PUBLIC_KEYFILE),
2966 #endif
2967 #if HAVE_DECL_CURLOPT_SSH_PRIVATE_KEYFILE
2968   MAP(SSH_PRIVATE_KEYFILE),
2969 #else
2970   MAP_NO(SSH_PRIVATE_KEYFILE),
2971 #endif
2972 #if HAVE_DECL_CURLOPT_FTP_SSL_CCC
2973   IMM(FTP_SSL_CCC),
2974 #else
2975   IMM_NO(FTP_SSL_CCC),
2976 #endif
2977 #if HAVE_DECL_CURLOPT_TIMEOUT_MS
2978   IMM(TIMEOUT_MS),
2979 #else
2980   IMM_NO(TIMEOUT_MS),
2981 #endif
2982 #if HAVE_DECL_CURLOPT_CONNECTTIMEOUT_MS
2983   IMM(CONNECTTIMEOUT_MS),
2984 #else
2985   IMM_NO(CONNECTTIMEOUT_MS),
2986 #endif
2987 #if HAVE_DECL_CURLOPT_HTTP_TRANSFER_DECODING
2988   IMM(HTTP_TRANSFER_DECODING),
2989 #else
2990   IMM_NO(HTTP_TRANSFER_DECODING),
2991 #endif
2992 #if HAVE_DECL_CURLOPT_HTTP_CONTENT_DECODING
2993   IMM(HTTP_CONTENT_DECODING),
2994 #else
2995   IMM_NO(HTTP_CONTENT_DECODING),
2996 #endif
2997 #if HAVE_DECL_CURLOPT_NEW_FILE_PERMS
2998   IMM(NEW_FILE_PERMS),
2999 #else
3000   IMM_NO(NEW_FILE_PERMS),
3001 #endif
3002 #if HAVE_DECL_CURLOPT_NEW_DIRECTORY_PERMS
3003   IMM(NEW_DIRECTORY_PERMS),
3004 #else
3005   IMM_NO(NEW_DIRECTORY_PERMS),
3006 #endif
3007 #if HAVE_DECL_CURLOPT_POST301
3008   IMM(POST301),
3009 #else
3010   IMM_NO(POST301),
3011 #endif
3012 #if HAVE_DECL_CURLOPT_SSH_HOST_PUBLIC_KEY_MD5
3013   MAP(SSH_HOST_PUBLIC_KEY_MD5),
3014 #else
3015   MAP_NO(SSH_HOST_PUBLIC_KEY_MD5),
3016 #endif
3017 #if HAVE_DECL_CURLOPT_COPYPOSTFIELDS
3018   MAP(COPYPOSTFIELDS),
3019 #else
3020   MAP_NO(COPYPOSTFIELDS),
3021 #endif
3022 #if HAVE_DECL_CURLOPT_PROXY_TRANSFER_MODE
3023   IMM(PROXY_TRANSFER_MODE),
3024 #else
3025   IMM_NO(PROXY_TRANSFER_MODE),
3026 #endif
3027 #if HAVE_DECL_CURLOPT_SEEKFUNCTION
3028   MAP(SEEKFUNCTION),
3029 #else
3030   MAP_NO(SEEKFUNCTION),
3031 #endif
3032 #if HAVE_DECL_CURLOPT_AUTOREFERER
3033   IMM(AUTOREFERER),
3034 #else
3035   IMM_NO(AUTOREFERER),
3036 #endif
3037 #if HAVE_DECL_CURLOPT_OPENSOCKETFUNCTION
3038   MAP(OPENSOCKETFUNCTION),
3039 #else
3040   MAP_NO(OPENSOCKETFUNCTION),
3041 #endif
3042 #if HAVE_DECL_CURLOPT_PROXYTYPE
3043   IMM(PROXYTYPE),
3044 #else
3045   IMM_NO(PROXYTYPE),
3046 #endif
3047 #if HAVE_DECL_CURLOPT_PROTOCOLS
3048   IMM(PROTOCOLS),
3049 #else
3050   IMM_NO(PROTOCOLS),
3051 #endif
3052 #if HAVE_DECL_CURLOPT_REDIR_PROTOCOLS
3053   IMM(REDIR_PROTOCOLS),
3054 #else
3055   IMM_NO(REDIR_PROTOCOLS),
3056 #endif
3057 #if HAVE_DECL_CURLOPT_RESOLVE
3058   MAP(RESOLVE),
3059 #else
3060   MAP_NO(RESOLVE),
3061 #endif
3062 #if HAVE_DECL_CURLOPT_DNS_SERVERS
3063   MAP(DNS_SERVERS),
3064 #else
3065   MAP_NO(DNS_SERVERS),
3066 #endif
3067 #if HAVE_DECL_CURLOPT_MAIL_FROM
3068   MAP(MAIL_FROM),
3069 #else
3070   MAP_NO(MAIL_FROM),
3071 #endif
3072 #if HAVE_DECL_CURLOPT_MAIL_RCPT
3073   MAP(MAIL_RCPT),
3074 #else
3075   MAP_NO(MAIL_RCPT),
3076 #endif
3077 #if HAVE_DECL_CURLOPT_PIPEWAIT
3078   IMM(PIPEWAIT),
3079 #else
3080   IMM_NO(PIPEWAIT),
3081 #endif
3082 #if HAVE_DECL_CURLOPT_CERTINFO
3083   IMM(CERTINFO),
3084 #else
3085   IMM_NO(CERTINFO),
3086 #endif
3087 };
3088
3089 static Connection *duplicateConnection(Connection *original)
3090 {
3091     Connection *connection = NULL;
3092     CURL* h = NULL;
3093     size_t i = 0;
3094     CURLOptionMapping* this = NULL;
3095
3096     caml_enter_blocking_section();
3097     h  = curl_easy_duphandle(original->handle);
3098     caml_leave_blocking_section();
3099
3100     connection = allocConnection(h);
3101
3102     for (i = 0; i < sizeof(implementedOptionMap)/sizeof(CURLOptionMapping); i++)
3103     {
3104       this = &implementedOptionMap[i];
3105       if (-1 == this->ocamlValue) continue;
3106       if (this->optionHandler && (Field(original->ocamlValues, this->ocamlValue) != Val_unit))
3107       {
3108         this->optionHandler(connection, Field(original->ocamlValues, this->ocamlValue));
3109       }
3110     }
3111
3112     return connection;
3113 }
3114
3115 CAMLprim value helper_curl_easy_setopt(value conn, value option)
3116 {
3117     CAMLparam2(conn, option);
3118     CAMLlocal1(data);
3119     Connection *connection = Connection_val(conn);
3120     CURLOptionMapping* thisOption = NULL;
3121     static value* exception = NULL;
3122
3123     checkConnection(connection);
3124
3125     data = Field(option, 0);
3126
3127     if (Tag_val(option) < sizeof(implementedOptionMap)/sizeof(CURLOptionMapping))
3128     {
3129       thisOption = &implementedOptionMap[Tag_val(option)];
3130       if (thisOption->optionHandler)
3131       {
3132         thisOption->optionHandler(connection, data);
3133       }
3134       else
3135       {
3136         if (NULL == exception)
3137         {
3138           exception = caml_named_value("Curl.NotImplemented");
3139           if (NULL == exception) caml_invalid_argument("Curl.NotImplemented");
3140         }
3141
3142         caml_raise_with_string(*exception, thisOption->name);
3143       }
3144     }
3145     else
3146     {
3147       caml_failwith("Invalid CURLOPT Option");
3148     }
3149
3150     CAMLreturn(Val_unit);
3151 }
3152
3153 /**
3154  **  curl_easy_perform helper function
3155  **/
3156
3157 CAMLprim value helper_curl_easy_perform(value conn)
3158 {
3159     CAMLparam1(conn);
3160     CURLcode result = CURLE_OK;
3161     Connection *connection = Connection_val(conn);
3162
3163     checkConnection(connection);
3164
3165     caml_enter_blocking_section();
3166     result = curl_easy_perform(connection->handle);
3167     caml_leave_blocking_section();
3168
3169     if (result != CURLE_OK)
3170         raiseError(connection, result);
3171
3172     CAMLreturn(Val_unit);
3173 }
3174
3175 /**
3176  **  curl_easy_cleanup helper function
3177  **/
3178
3179 CAMLprim value helper_curl_easy_cleanup(value conn)
3180 {
3181     CAMLparam1(conn);
3182     Connection *connection = Connection_val(conn);
3183
3184     checkConnection(connection);
3185
3186     removeConnection(connection, 0);
3187
3188     CAMLreturn(Val_unit);
3189 }
3190
3191 /**
3192  **  curl_easy_duphandle helper function
3193  **/
3194
3195 CAMLprim value helper_curl_easy_duphandle(value conn)
3196 {
3197     CAMLparam1(conn);
3198     CAMLlocal1(result);
3199     Connection *connection = Connection_val(conn);
3200
3201     checkConnection(connection);
3202
3203     result = caml_curl_alloc(duplicateConnection(connection));
3204
3205     CAMLreturn(result);
3206 }
3207
3208 /**
3209  **  curl_easy_getinfo helper function
3210  **/
3211
3212 enum GetInfoResultType {
3213     StringValue, LongValue, DoubleValue, StringListValue, StringListListValue,
3214     OCamlValue, /* keep last - no matching OCaml CURLINFO_ constructor */
3215 };
3216
3217 value convertStringList(struct curl_slist *p)
3218 {
3219     CAMLparam0();
3220     CAMLlocal3(result, current, next);
3221
3222     result = Val_emptylist;
3223     current = Val_emptylist;
3224     next = Val_emptylist;
3225
3226     while (p != NULL)
3227     {
3228         next = caml_alloc_tuple(2);
3229         Store_field(next, 0, caml_copy_string(p->data));
3230         Store_field(next, 1, Val_emptylist);
3231
3232         if (result == Val_emptylist)
3233             result = next;
3234
3235         if (current != Val_emptylist)
3236           Store_field(current, 1, next);
3237
3238         current = next;
3239
3240         p = p->next;
3241     }
3242
3243     CAMLreturn(result);
3244 }
3245
3246 CAMLprim value helper_curl_easy_getinfo(value conn, value option)
3247 {
3248     CAMLparam2(conn, option);
3249     CAMLlocal3(result, current, next);
3250     CURLcode curlResult;
3251     Connection *connection = Connection_val(conn);
3252     enum GetInfoResultType resultType;
3253     char *strValue = NULL;
3254     double doubleValue;
3255     long longValue;
3256     struct curl_slist *stringListValue = NULL;
3257 #if HAVE_DECL_CURLINFO_CERTINFO
3258     int i;
3259     union {
3260       struct curl_slist    *to_info;
3261       struct curl_certinfo *to_certinfo;
3262     } ptr;
3263 #endif
3264
3265     checkConnection(connection);
3266
3267     switch(Long_val(option))
3268     {
3269 #if HAVE_DECL_CURLINFO_EFFECTIVE_URL
3270     case 0: /* CURLINFO_EFFECTIVE_URL */
3271         resultType = StringValue;
3272
3273         curlResult = curl_easy_getinfo(connection->handle,
3274                                        CURLINFO_EFFECTIVE_URL,
3275                                        &strValue);
3276         break;
3277 #else
3278 #pragma message("libcurl does not provide CURLINFO_EFFECTIVE_URL")
3279 #endif
3280
3281 #if HAVE_DECL_CURLINFO_RESPONSE_CODE || HAVE_DECL_CURLINFO_HTTP_CODE
3282     case 1: /* CURLINFO_HTTP_CODE */
3283     case 2: /* CURLINFO_RESPONSE_CODE */
3284 #if HAVE_DECL_CURLINFO_RESPONSE_CODE
3285         resultType = LongValue;
3286
3287         curlResult = curl_easy_getinfo(connection->handle,
3288                                        CURLINFO_RESPONSE_CODE,
3289                                        &longValue);
3290 #else
3291         resultType = LongValue;
3292
3293         curlResult = curl_easy_getinfo(connection->handle,
3294                                        CURLINFO_HTTP_CODE,
3295                                        &longValue);
3296 #endif
3297         break;
3298 #endif
3299
3300 #if HAVE_DECL_CURLINFO_TOTAL_TIME
3301     case 3: /* CURLINFO_TOTAL_TIME */
3302         resultType = DoubleValue;
3303
3304         curlResult = curl_easy_getinfo(connection->handle,
3305                                        CURLINFO_TOTAL_TIME,
3306                                        &doubleValue);
3307         break;
3308 #endif
3309
3310 #if HAVE_DECL_CURLINFO_NAMELOOKUP_TIME
3311     case 4: /* CURLINFO_NAMELOOKUP_TIME */
3312         resultType = DoubleValue;
3313
3314         curlResult = curl_easy_getinfo(connection->handle,
3315                                        CURLINFO_NAMELOOKUP_TIME,
3316                                        &doubleValue);
3317         break;
3318 #endif
3319
3320 #if HAVE_DECL_CURLINFO_CONNECT_TIME
3321     case 5: /* CURLINFO_CONNECT_TIME */
3322         resultType = DoubleValue;
3323
3324         curlResult = curl_easy_getinfo(connection->handle,
3325                                        CURLINFO_CONNECT_TIME,
3326                                        &doubleValue);
3327         break;
3328 #endif
3329
3330 #if HAVE_DECL_CURLINFO_PRETRANSFER_TIME
3331     case 6: /* CURLINFO_PRETRANSFER_TIME */
3332         resultType = DoubleValue;
3333
3334         curlResult = curl_easy_getinfo(connection->handle,
3335                                        CURLINFO_PRETRANSFER_TIME,
3336                                        &doubleValue);
3337         break;
3338 #endif
3339
3340 #if HAVE_DECL_CURLINFO_SIZE_UPLOAD
3341     case 7: /* CURLINFO_SIZE_UPLOAD */
3342         resultType = DoubleValue;
3343
3344         curlResult = curl_easy_getinfo(connection->handle,
3345                                        CURLINFO_SIZE_UPLOAD,
3346                                        &doubleValue);
3347         break;
3348 #endif
3349
3350 #if HAVE_DECL_CURLINFO_SIZE_DOWNLOAD
3351     case 8: /* CURLINFO_SIZE_DOWNLOAD */
3352         resultType = DoubleValue;
3353
3354         curlResult = curl_easy_getinfo(connection->handle,
3355                                        CURLINFO_SIZE_DOWNLOAD,
3356                                        &doubleValue);
3357         break;
3358 #endif
3359
3360 #if HAVE_DECL_CURLINFO_SPEED_DOWNLOAD
3361     case 9: /* CURLINFO_SPEED_DOWNLOAD */
3362         resultType = DoubleValue;
3363
3364         curlResult = curl_easy_getinfo(connection->handle,
3365                                        CURLINFO_SPEED_DOWNLOAD,
3366                                        &doubleValue);
3367         break;
3368 #endif
3369
3370 #if HAVE_DECL_CURLINFO_SPEED_UPLOAD
3371     case 10: /* CURLINFO_SPEED_UPLOAD */
3372         resultType = DoubleValue;
3373
3374         curlResult = curl_easy_getinfo(connection->handle,
3375                                        CURLINFO_SPEED_UPLOAD,
3376                                        &doubleValue);
3377         break;
3378
3379 #endif
3380
3381 #if HAVE_DECL_CURLINFO_HEADER_SIZE
3382     case 11: /* CURLINFO_HEADER_SIZE */
3383         resultType = LongValue;
3384
3385         curlResult = curl_easy_getinfo(connection->handle,
3386                                        CURLINFO_HEADER_SIZE,
3387                                        &longValue);
3388         break;
3389 #endif
3390
3391 #if HAVE_DECL_CURLINFO_REQUEST_SIZE
3392     case 12: /* CURLINFO_REQUEST_SIZE */
3393         resultType = LongValue;
3394
3395         curlResult = curl_easy_getinfo(connection->handle,
3396                                        CURLINFO_REQUEST_SIZE,
3397                                        &longValue);
3398         break;
3399 #endif
3400
3401 #if HAVE_DECL_CURLINFO_SSL_VERIFYRESULT
3402     case 13: /* CURLINFO_SSL_VERIFYRESULT */
3403         resultType = LongValue;
3404
3405         curlResult = curl_easy_getinfo(connection->handle,
3406                                        CURLINFO_SSL_VERIFYRESULT,
3407                                        &longValue);
3408         break;
3409 #endif
3410
3411 #if HAVE_DECL_CURLINFO_FILETIME
3412     case 14: /* CURLINFO_FILETIME */
3413         resultType = DoubleValue;
3414
3415         curlResult = curl_easy_getinfo(connection->handle,
3416                                        CURLINFO_FILETIME,
3417                                        &longValue);
3418
3419         doubleValue = longValue;
3420         break;
3421 #endif
3422
3423 #if HAVE_DECL_CURLINFO_CONTENT_LENGTH_DOWNLOAD
3424     case 15: /* CURLINFO_CONTENT_LENGTH_DOWNLOAD */
3425         resultType = DoubleValue;
3426
3427         curlResult = curl_easy_getinfo(connection->handle,
3428                                        CURLINFO_CONTENT_LENGTH_DOWNLOAD,
3429                                        &doubleValue);
3430         break;
3431 #endif
3432
3433 #if HAVE_DECL_CURLINFO_CONTENT_LENGTH_UPLOAD
3434     case 16: /* CURLINFO_CONTENT_LENGTH_UPLOAD */
3435         resultType = DoubleValue;
3436
3437         curlResult = curl_easy_getinfo(connection->handle,
3438                                        CURLINFO_CONTENT_LENGTH_UPLOAD,
3439                                        &doubleValue);
3440         break;
3441 #endif
3442
3443 #if HAVE_DECL_CURLINFO_STARTTRANSFER_TIME
3444     case 17: /* CURLINFO_STARTTRANSFER_TIME */
3445         resultType = DoubleValue;
3446
3447         curlResult = curl_easy_getinfo(connection->handle,
3448                                        CURLINFO_STARTTRANSFER_TIME,
3449                                        &doubleValue);
3450         break;
3451 #endif
3452
3453 #if HAVE_DECL_CURLINFO_CONTENT_TYPE
3454     case 18: /* CURLINFO_CONTENT_TYPE */
3455         resultType = StringValue;
3456
3457         curlResult = curl_easy_getinfo(connection->handle,
3458                                        CURLINFO_CONTENT_TYPE,
3459                                        &strValue);
3460         break;
3461 #endif
3462
3463 #if HAVE_DECL_CURLINFO_REDIRECT_TIME
3464     case 19: /* CURLINFO_REDIRECT_TIME */
3465         resultType = DoubleValue;
3466
3467         curlResult = curl_easy_getinfo(connection->handle,
3468                                        CURLINFO_REDIRECT_TIME,
3469                                        &doubleValue);
3470         break;
3471 #endif
3472
3473 #if HAVE_DECL_CURLINFO_REDIRECT_COUNT
3474     case 20: /* CURLINFO_REDIRECT_COUNT */
3475         resultType = LongValue;
3476
3477         curlResult = curl_easy_getinfo(connection->handle,
3478                                        CURLINFO_REDIRECT_COUNT,
3479                                        &longValue);
3480         break;
3481 #endif
3482
3483     case 21: /* CURLINFO_PRIVATE */
3484         resultType = OCamlValue;
3485         curlResult = CURLE_OK;
3486         result = caml_alloc(1, StringValue);
3487         Store_field(result, 0, Field(connection->ocamlValues, Ocaml_PRIVATE));
3488         break;
3489
3490 #if HAVE_DECL_CURLINFO_HTTP_CONNECTCODE
3491     case 22: /* CURLINFO_HTTP_CONNECTCODE */
3492         resultType = LongValue;
3493
3494         curlResult = curl_easy_getinfo(connection->handle,
3495                                        CURLINFO_HTTP_CONNECTCODE,
3496                                        &longValue);
3497         break;
3498 #endif
3499
3500 #if HAVE_DECL_CURLINFO_HTTPAUTH_AVAIL
3501     case 23: /* CURLINFO_HTTPAUTH_AVAIL */
3502         resultType = LongValue;
3503
3504         curlResult = curl_easy_getinfo(connection->handle,
3505                                        CURLINFO_HTTPAUTH_AVAIL,
3506                                        &longValue);
3507         break;
3508 #endif
3509
3510 #if HAVE_DECL_CURLINFO_PROXYAUTH_AVAIL
3511     case 24: /* CURLINFO_PROXYAUTH_AVAIL */
3512         resultType = LongValue;
3513
3514         curlResult = curl_easy_getinfo(connection->handle,
3515                                        CURLINFO_PROXYAUTH_AVAIL,
3516                                        &longValue);
3517         break;
3518 #endif
3519
3520 #if HAVE_DECL_CURLINFO_OS_ERRNO
3521     case 25: /* CURLINFO_OS_ERRNO */
3522         resultType = LongValue;
3523
3524         curlResult = curl_easy_getinfo(connection->handle,
3525                                        CURLINFO_OS_ERRNO,
3526                                        &longValue);
3527         break;
3528 #endif
3529
3530 #if HAVE_DECL_CURLINFO_NUM_CONNECTS
3531     case 26: /* CURLINFO_NUM_CONNECTS */
3532         resultType = LongValue;
3533
3534         curlResult = curl_easy_getinfo(connection->handle,
3535                                        CURLINFO_NUM_CONNECTS,
3536                                        &longValue);
3537         break;
3538 #endif
3539
3540 #if HAVE_DECL_CURLINFO_SSL_ENGINES
3541     case 27: /* CURLINFO_SSL_ENGINES */
3542         resultType = StringListValue;
3543
3544         curlResult = curl_easy_getinfo(connection->handle,
3545                                        CURLINFO_SSL_ENGINES,
3546                                        &stringListValue);
3547         break;
3548 #endif
3549
3550 #if HAVE_DECL_CURLINFO_COOKIELIST
3551     case 28: /* CURLINFO_COOKIELIST */
3552         resultType = StringListValue;
3553
3554         curlResult = curl_easy_getinfo(connection->handle,
3555                                        CURLINFO_COOKIELIST,
3556                                        &stringListValue);
3557         break;
3558 #endif
3559
3560 #if HAVE_DECL_CURLINFO_LASTSOCKET
3561     case 29: /* CURLINFO_LASTSOCKET */
3562         resultType = LongValue;
3563
3564         curlResult = curl_easy_getinfo(connection->handle,
3565                                        CURLINFO_LASTSOCKET,
3566                                        &longValue);
3567         break;
3568 #endif
3569
3570 #if HAVE_DECL_CURLINFO_FTP_ENTRY_PATH
3571     case 30: /* CURLINFO_FTP_ENTRY_PATH */
3572         resultType = StringValue;
3573
3574         curlResult = curl_easy_getinfo(connection->handle,
3575                                        CURLINFO_FTP_ENTRY_PATH,
3576                                        &strValue);
3577         break;
3578 #endif
3579
3580 #if HAVE_DECL_CURLINFO_REDIRECT_URL
3581     case 31: /* CURLINFO_REDIRECT_URL */
3582         resultType = StringValue;
3583
3584         curlResult = curl_easy_getinfo(connection->handle,
3585                                        CURLINFO_REDIRECT_URL,
3586                                        &strValue);
3587         break;
3588 #else
3589 #pragma message("libcurl does not provide CURLINFO_REDIRECT_URL")
3590 #endif
3591
3592 #if HAVE_DECL_CURLINFO_PRIMARY_IP
3593     case 32: /* CURLINFO_PRIMARY_IP */
3594         resultType = StringValue;
3595
3596         curlResult = curl_easy_getinfo(connection->handle,
3597                                        CURLINFO_PRIMARY_IP,
3598                                        &strValue);
3599         break;
3600 #else
3601 #pragma message("libcurl does not provide CURLINFO_PRIMARY_IP")
3602 #endif
3603
3604 #if HAVE_DECL_CURLINFO_LOCAL_IP
3605     case 33: /* CURLINFO_LOCAL_IP */
3606         resultType = StringValue;
3607
3608         curlResult = curl_easy_getinfo(connection->handle,
3609                                        CURLINFO_LOCAL_IP,
3610                                        &strValue);
3611         break;
3612 #else
3613 #pragma message("libcurl does not provide CURLINFO_LOCAL_IP")
3614 #endif
3615
3616 #if HAVE_DECL_CURLINFO_LOCAL_PORT
3617     case 34: /* CURLINFO_LOCAL_PORT */
3618         resultType = LongValue;
3619
3620         curlResult = curl_easy_getinfo(connection->handle,
3621                                        CURLINFO_LOCAL_PORT,
3622                                        &longValue);
3623         break;
3624 #else
3625 #pragma message("libcurl does not provide CURLINFO_LOCAL_PORT")
3626 #endif
3627
3628 #if HAVE_DECL_CURLINFO_CONDITION_UNMET
3629     case 35: /* CURLINFO_CONDITION_UNMET */
3630         resultType = LongValue;
3631
3632         curlResult = curl_easy_getinfo(connection->handle,
3633                                        CURLINFO_CONDITION_UNMET,
3634                                        &longValue);
3635         break;
3636 #else
3637 #pragma message("libcurl does not provide CURLINFO_CONDITION_UNMET")
3638 #endif
3639 #if HAVE_DECL_CURLINFO_CERTINFO
3640     case 36: /* CURLINFO_CERTINFO */
3641         resultType = StringListListValue;
3642         ptr.to_info = NULL;
3643         curlResult = curl_easy_getinfo(connection->handle,
3644                                        CURLINFO_CERTINFO,
3645                                        &ptr.to_info);
3646
3647         result = Val_emptylist;
3648         current = Val_emptylist;
3649         next = Val_emptylist;
3650
3651         if (curlResult != CURLE_OK || !ptr.to_info)
3652           break;
3653
3654         for (i = 0; i < ptr.to_certinfo->num_of_certs; i++) {
3655           next = caml_alloc_tuple(2);
3656           Store_field(next, 0, convertStringList(ptr.to_certinfo->certinfo[i]));
3657           Store_field(next, 1, current);
3658           current = next;
3659         }
3660         break;
3661 #else
3662 #pragma message("libcurl does not provide CURLINFO_CERTINFO")
3663 #endif
3664     default:
3665         caml_failwith("Invalid CURLINFO Option");
3666         break;
3667     }
3668
3669     if (curlResult != CURLE_OK)
3670         raiseError(connection, curlResult);
3671
3672     switch (resultType)
3673     {
3674     case StringValue:
3675         result = caml_alloc(1, StringValue);
3676         Store_field(result, 0, caml_copy_string(strValue?strValue:""));
3677         break;
3678
3679     case LongValue:
3680         result = caml_alloc(1, LongValue);
3681         Store_field(result, 0, Val_long(longValue));
3682         break;
3683
3684     case DoubleValue:
3685         result = caml_alloc(1, DoubleValue);
3686         Store_field(result, 0, caml_copy_double(doubleValue));
3687         break;
3688
3689     case StringListValue:
3690         result = caml_alloc(1, StringListValue);
3691         Store_field(result, 0, convertStringList(stringListValue));
3692         curl_slist_free_all(stringListValue);
3693         break;
3694
3695     case StringListListValue:
3696         result = caml_alloc(1, StringListListValue);
3697         Store_field(result, 0, current);
3698         break;
3699
3700     case OCamlValue:
3701         break;
3702     }
3703
3704     CAMLreturn(result);
3705 }
3706
3707 /**
3708  **  curl_escape helper function
3709  **/
3710
3711 CAMLprim value helper_curl_escape(value str)
3712 {
3713     CAMLparam1(str);
3714     CAMLlocal1(result);
3715     char *curlResult;
3716
3717     curlResult = curl_escape(String_val(str), caml_string_length(str));
3718     result = caml_copy_string(curlResult);
3719     free(curlResult);
3720
3721     CAMLreturn(result);
3722 }
3723
3724 /**
3725  **  curl_unescape helper function
3726  **/
3727
3728 CAMLprim value helper_curl_unescape(value str)
3729 {
3730     CAMLparam1(str);
3731     CAMLlocal1(result);
3732     char *curlResult;
3733
3734     curlResult = curl_unescape(String_val(str), caml_string_length(str));
3735     result = caml_copy_string(curlResult);
3736     free(curlResult);
3737
3738     CAMLreturn(result);
3739 }
3740
3741 /**
3742  **  curl_getdate helper function
3743  **/
3744
3745 CAMLprim value helper_curl_getdate(value str, value now)
3746 {
3747     CAMLparam2(str, now);
3748     CAMLlocal1(result);
3749     time_t curlResult;
3750     time_t curlNow;
3751
3752     curlNow = (time_t)Double_val(now);
3753     curlResult = curl_getdate(String_val(str), &curlNow);
3754     result = caml_copy_double((double)curlResult);
3755
3756     CAMLreturn(result);
3757 }
3758
3759 /**
3760  **  curl_version helper function
3761  **/
3762
3763 CAMLprim value helper_curl_version(void)
3764 {
3765     CAMLparam0();
3766     CAMLlocal1(result);
3767     char *str;
3768
3769     str = curl_version();
3770     result = caml_copy_string(str);
3771
3772     CAMLreturn(result);
3773 }
3774
3775 struct CURLVersionBitsMapping
3776 {
3777     int code;
3778     char *name;
3779 };
3780
3781 struct CURLVersionBitsMapping versionBitsMap[] =
3782 {
3783     {CURL_VERSION_IPV6, "ipv6"},
3784     {CURL_VERSION_KERBEROS4, "kerberos4"},
3785     {CURL_VERSION_SSL, "ssl"},
3786     {CURL_VERSION_LIBZ, "libz"},
3787     {CURL_VERSION_NTLM, "ntlm"},
3788     {CURL_VERSION_GSSNEGOTIATE, "gssnegotiate"},
3789     {CURL_VERSION_DEBUG, "debug"},
3790     {CURL_VERSION_CURLDEBUG, "curldebug"},
3791     {CURL_VERSION_ASYNCHDNS, "asynchdns"},
3792     {CURL_VERSION_SPNEGO, "spnego"},
3793     {CURL_VERSION_LARGEFILE, "largefile"},
3794     {CURL_VERSION_IDN, "idn"},
3795     {CURL_VERSION_SSPI, "sspi"},
3796     {CURL_VERSION_CONV, "conv"},
3797 #if HAVE_DECL_CURL_VERSION_TLSAUTH_SRP
3798     {CURL_VERSION_TLSAUTH_SRP, "srp"},
3799 #endif
3800 #if HAVE_DECL_CURL_VERSION_NTLM_WB
3801     {CURL_VERSION_NTLM_WB, "wb"},
3802 #endif
3803 };
3804
3805 CAMLprim value caml_curl_version_info(value unit)
3806 {
3807   CAMLparam1(unit);
3808   CAMLlocal4(v, vlist, vnum, vfeatures);
3809   const char* const* p = NULL;
3810   size_t i = 0;
3811
3812   curl_version_info_data* data = curl_version_info(CURLVERSION_NOW);
3813   if (NULL == data) caml_failwith("curl_version_info");
3814
3815   vlist = Val_emptylist;
3816   for (p = data->protocols; NULL != *p; p++)
3817   {
3818     vlist = Val_cons(vlist, caml_copy_string(*p));
3819   }
3820
3821   vfeatures = Val_emptylist;
3822   for (i = 0; i < sizeof(versionBitsMap)/sizeof(versionBitsMap[0]); i++)
3823   {
3824     if (0 != (versionBitsMap[i].code & data->features))
3825       vfeatures = Val_cons(vfeatures, caml_copy_string(versionBitsMap[i].name));
3826   }
3827
3828   vnum = caml_alloc_tuple(3);
3829   Store_field(vnum,0,Val_int(0xFF & (data->version_num >> 16)));
3830   Store_field(vnum,1,Val_int(0xFF & (data->version_num >> 8)));
3831   Store_field(vnum,2,Val_int(0xFF & (data->version_num)));
3832
3833   v = caml_alloc_tuple(12);
3834   Store_field(v,0,caml_copy_string(data->version));
3835   Store_field(v,1,vnum);
3836   Store_field(v,2,caml_copy_string(data->host));
3837   Store_field(v,3,vfeatures);
3838   Store_field(v,4,data->ssl_version ? Val_some(caml_copy_string(data->ssl_version)) : Val_none);
3839   Store_field(v,5,data->libz_version ? Val_some(caml_copy_string(data->libz_version)) : Val_none);
3840   Store_field(v,6,vlist);
3841   Store_field(v,7,caml_copy_string((data->age >= 1 && data->ares) ? data->ares : ""));
3842   Store_field(v,8,Val_int((data->age >= 1) ? data->ares_num : 0));
3843   Store_field(v,9,caml_copy_string((data->age >= 2 && data->libidn) ? data->libidn : ""));
3844   Store_field(v,10,Val_int((data->age >= 3) ? data->iconv_ver_num : 0));
3845   Store_field(v,11,caml_copy_string((data->age >= 3 && data->libssh_version) ? data->libssh_version : ""));
3846
3847   CAMLreturn(v);
3848 }
3849
3850 CAMLprim value caml_curl_pause(value conn, value opts)
3851 {
3852   CAMLparam2(conn, opts);
3853   CAMLlocal4(v, vlist, vnum, vfeatures);
3854   Connection *connection = Connection_val(conn);
3855   int bitmask = 0;
3856   CURLcode result;
3857
3858   while (Val_emptylist != opts)
3859   {
3860     switch (Int_val(Field(opts,0)))
3861     {
3862       case 0: bitmask |= CURLPAUSE_SEND; break;
3863       case 1: bitmask |= CURLPAUSE_RECV; break;
3864       case 2: bitmask |= CURLPAUSE_ALL; break;
3865       default: caml_failwith("wrong pauseOption");
3866     }
3867     opts = Field(opts,1);
3868   }
3869
3870   result = curl_easy_pause(connection->handle,bitmask);
3871   if (result != CURLE_OK)
3872     raiseError(connection, result);
3873
3874   CAMLreturn(Val_unit);
3875 }
3876
3877 /*
3878  * Curl multi stack support
3879  *
3880  * Exported thin wrappers for libcurl are prefixed with caml_curl_multi_.
3881  * Other exported functions are prefixed with caml_curlm_, some of them
3882  * can/should be decomposed into smaller parts.
3883  */
3884
3885 struct ml_multi_handle
3886 {
3887   CURLM* handle;
3888   value values; /* callbacks */
3889 };
3890
3891 enum
3892 {
3893   curlmopt_socket_function,
3894   curlmopt_timer_function,
3895
3896   /* last, not used */
3897   multi_values_total
3898 };
3899
3900 typedef struct ml_multi_handle ml_multi_handle;
3901
3902 #define Multi_val(v) (*(ml_multi_handle**)Data_custom_val(v))
3903 #define CURLM_val(v) (Multi_val(v)->handle)
3904
3905 static struct custom_operations curl_multi_ops = {
3906   "ygrek.curl_multi",
3907   custom_finalize_default,
3908   custom_compare_default,
3909   custom_hash_default,
3910   custom_serialize_default,
3911   custom_deserialize_default,
3912 #if defined(custom_compare_ext_default)
3913   custom_compare_ext_default,
3914 #endif
3915 };
3916
3917 CAMLprim value caml_curl_multi_init(value unit)
3918 {
3919   CAMLparam1(unit);
3920   CAMLlocal1(v);
3921   ml_multi_handle* multi = (ml_multi_handle*)caml_stat_alloc(sizeof(ml_multi_handle));
3922   CURLM* h = curl_multi_init();
3923
3924   if (!h)
3925   {
3926     caml_stat_free(multi);
3927     caml_failwith("caml_curl_multi_init");
3928   }
3929
3930   multi->handle = h;
3931   multi->values = caml_alloc(multi_values_total, 0);
3932   caml_register_generational_global_root(&multi->values);
3933
3934   v = caml_alloc_custom(&curl_multi_ops, sizeof(ml_multi_handle*), 0, 1);
3935   Multi_val(v) = multi;
3936
3937   CAMLreturn(v);
3938 }
3939
3940 CAMLprim value caml_curl_multi_cleanup(value handle)
3941 {
3942   CAMLparam1(handle);
3943   ml_multi_handle* h = Multi_val(handle);
3944
3945   if (NULL == h)
3946     CAMLreturn(Val_unit);
3947
3948   caml_remove_generational_global_root(&h->values);
3949
3950   if (CURLM_OK != curl_multi_cleanup(h->handle))
3951     caml_failwith("caml_curl_multi_cleanup");
3952
3953   caml_stat_free(h);
3954   Multi_val(handle) = (ml_multi_handle*)NULL;
3955
3956   CAMLreturn(Val_unit);
3957 }
3958
3959 static CURL* curlm_remove_finished(CURLM* multi_handle, CURLcode* result)
3960 {
3961   int msgs_in_queue = 0;
3962
3963   while (1)
3964   {
3965     CURLMsg* msg = curl_multi_info_read(multi_handle, &msgs_in_queue);
3966     if (NULL == msg) return NULL;
3967     if (CURLMSG_DONE == msg->msg)
3968     {
3969       CURL* easy_handle = msg->easy_handle;
3970       if (result) *result = msg->data.result;
3971       if (CURLM_OK != curl_multi_remove_handle(multi_handle, easy_handle))
3972       {
3973         /*caml_failwith("curlm_remove_finished");*/
3974       }
3975       return easy_handle;
3976     }
3977   }
3978 }
3979
3980 CAMLprim value caml_curlm_remove_finished(value v_multi)
3981 {
3982   CAMLparam1(v_multi);
3983   CAMLlocal2(v_easy, v_tuple);
3984   CURL* handle;
3985   CURLM* multi_handle;
3986   CURLcode result;
3987   Connection* conn = NULL;
3988
3989   multi_handle = CURLM_val(v_multi);
3990
3991   caml_enter_blocking_section();
3992   handle = curlm_remove_finished(multi_handle,&result);
3993   caml_leave_blocking_section();
3994
3995   if (NULL == handle)
3996   {
3997     CAMLreturn(Val_none);
3998   }
3999   else
4000   {
4001     conn = getConnection(handle);
4002     if (conn->curl_ERRORBUFFER != NULL)
4003     {
4004         Store_field(Field(conn->ocamlValues, Ocaml_ERRORBUFFER), 0, caml_copy_string(conn->curl_ERRORBUFFER));
4005     }
4006     conn->refcount--;
4007     /* NB: same handle, but different block */
4008     v_easy = caml_curl_alloc(conn);
4009     v_tuple = caml_alloc(2, 0);
4010     Store_field(v_tuple,0,v_easy);
4011     Store_field(v_tuple,1,Val_int(result)); /* CURLcode */
4012     CAMLreturn(Val_some(v_tuple));
4013   }
4014 }
4015
4016 static int curlm_wait_data(CURLM* multi_handle)
4017 {
4018         struct timeval timeout;
4019   CURLMcode ret;
4020
4021         fd_set fdread;
4022         fd_set fdwrite;
4023         fd_set fdexcep;
4024         int maxfd = -1;
4025
4026         FD_ZERO(&fdread);
4027         FD_ZERO(&fdwrite);
4028         FD_ZERO(&fdexcep);
4029
4030         /* set a suitable timeout */
4031         timeout.tv_sec = 1;
4032         timeout.tv_usec = 0;
4033
4034         /* get file descriptors from the transfers */
4035         ret = curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
4036
4037         if (ret == CURLM_OK && maxfd >= 0)
4038         {
4039                 int rc = select(maxfd+1, &fdread, &fdwrite, &fdexcep, &timeout);
4040                 if (-1 != rc) return 0;
4041         }
4042         return 1;
4043 }
4044
4045 CAMLprim value caml_curlm_wait_data(value v_multi)
4046 {
4047   CAMLparam1(v_multi);
4048   int ret;
4049   CURLM* h = CURLM_val(v_multi);
4050
4051   caml_enter_blocking_section();
4052   ret = curlm_wait_data(h);
4053   caml_leave_blocking_section();
4054
4055   CAMLreturn(Val_bool(0 == ret));
4056 }
4057
4058 CAMLprim value caml_curl_multi_add_handle(value v_multi, value v_easy)
4059 {
4060   CAMLparam2(v_multi,v_easy);
4061   CURLM* multi = CURLM_val(v_multi);
4062   Connection* conn = Connection_val(v_easy);
4063
4064   /* prevent collection of OCaml value while the easy handle is used
4065    and may invoke callbacks registered on OCaml side */
4066   conn->refcount++;
4067
4068   /* may invoke callbacks so need to be consistent with locks */
4069   caml_enter_blocking_section();
4070   if (CURLM_OK != curl_multi_add_handle(multi, conn->handle))
4071   {
4072     conn->refcount--; /* not added, revert */
4073     caml_leave_blocking_section();
4074     caml_failwith("caml_curl_multi_add_handle");
4075   }
4076   caml_leave_blocking_section();
4077
4078   CAMLreturn(Val_unit);
4079 }
4080
4081 CAMLprim value caml_curl_multi_remove_handle(value v_multi, value v_easy)
4082 {
4083   CAMLparam2(v_multi,v_easy);
4084   CURLM* multi = CURLM_val(v_multi);
4085   Connection* conn = Connection_val(v_easy);
4086
4087   /* may invoke callbacks so need to be consistent with locks */
4088   caml_enter_blocking_section();
4089   if (CURLM_OK != curl_multi_remove_handle(multi, conn->handle))
4090   {
4091     caml_leave_blocking_section();
4092     caml_failwith("caml_curl_multi_remove_handle");
4093   }
4094   conn->refcount--;
4095   caml_leave_blocking_section();
4096
4097   CAMLreturn(Val_unit);
4098 }
4099
4100 CAMLprim value caml_curl_multi_perform_all(value v_multi)
4101 {
4102   CAMLparam1(v_multi);
4103   int still_running = 0;
4104   CURLM* h = CURLM_val(v_multi);
4105
4106   caml_enter_blocking_section();
4107   while (CURLM_CALL_MULTI_PERFORM == curl_multi_perform(h, &still_running));
4108   caml_leave_blocking_section();
4109
4110   CAMLreturn(Val_int(still_running));
4111 }
4112
4113 CAMLprim value helper_curl_easy_strerror(value v_code)
4114 {
4115   CAMLparam1(v_code);
4116   CAMLreturn(caml_copy_string(curl_easy_strerror(Int_val(v_code))));
4117 }
4118
4119 /*
4120  * Wrappers for the curl_multi_socket_action infrastructure
4121  * Based on curl hiperfifo.c example
4122  */
4123
4124 #ifdef _WIN32
4125 #ifndef Val_socket
4126 #define Val_socket(v) win_alloc_socket(v)
4127 #endif
4128 #ifndef Socket_val
4129 #error Socket_val not defined in unixsupport.h
4130 #endif
4131 #else /* _WIN32 */
4132 #ifndef Socket_val
4133 #define Socket_val(v) Long_val(v)
4134 #endif
4135 #ifndef Val_socket
4136 #define Val_socket(v) Val_int(v)
4137 #endif
4138 #endif  /* _WIN32 */
4139
4140 static void raise_multi_error(char const* msg)
4141 {
4142   static value* exception = NULL;
4143
4144   if (NULL == exception)
4145   {
4146     exception = caml_named_value("Curl.Multi.Error");
4147     if (NULL == exception) caml_invalid_argument("Curl.Multi.Error");
4148   }
4149
4150   caml_raise_with_string(*exception, msg);
4151 }
4152
4153 static void check_mcode(CURLMcode code)
4154 {
4155   char const *s = NULL;
4156   switch (code)
4157   {
4158     case CURLM_OK                  : return;
4159     case CURLM_CALL_MULTI_PERFORM  : s="CURLM_CALL_MULTI_PERFORM"; break;
4160     case CURLM_BAD_HANDLE          : s="CURLM_BAD_HANDLE";         break;
4161     case CURLM_BAD_EASY_HANDLE     : s="CURLM_BAD_EASY_HANDLE";    break;
4162     case CURLM_OUT_OF_MEMORY       : s="CURLM_OUT_OF_MEMORY";      break;
4163     case CURLM_INTERNAL_ERROR      : s="CURLM_INTERNAL_ERROR";     break;
4164     case CURLM_UNKNOWN_OPTION      : s="CURLM_UNKNOWN_OPTION";     break;
4165     case CURLM_LAST                : s="CURLM_LAST";               break;
4166     case CURLM_BAD_SOCKET          : s="CURLM_BAD_SOCKET";         break;
4167     default                        : s="CURLM_unknown";            break;
4168   }
4169   raise_multi_error(s);
4170 }
4171
4172 CAMLprim value caml_curl_multi_socket_action(value v_multi, value v_fd, value v_kind)
4173 {
4174   CAMLparam3(v_multi, v_fd, v_kind);
4175   CURLM* h = CURLM_val(v_multi);
4176   int still_running = 0;
4177   CURLMcode rc = CURLM_OK;
4178   curl_socket_t socket;
4179   int kind = 0;
4180
4181   if (Val_none == v_fd)
4182   {
4183     socket = CURL_SOCKET_TIMEOUT;
4184   }
4185   else
4186   {
4187     socket = Socket_val(Field(v_fd, 0));
4188   }
4189
4190   switch (Int_val(v_kind))
4191   {
4192     case 0 : break;
4193     case 1 : kind |= CURL_CSELECT_IN; break;
4194     case 2 : kind |= CURL_CSELECT_OUT; break;
4195     case 3 : kind |= CURL_CSELECT_IN | CURL_CSELECT_OUT; break;
4196     default:
4197       raise_multi_error("caml_curl_multi_socket_action");
4198   }
4199
4200 /*  fprintf(stdout,"fd %u kind %u\n",socket, kind); fflush(stdout); */
4201
4202   caml_enter_blocking_section();
4203   do {
4204     rc = curl_multi_socket_action(h, socket, kind, &still_running);
4205   } while (rc == CURLM_CALL_MULTI_PERFORM);
4206   caml_leave_blocking_section();
4207
4208   check_mcode(rc);
4209
4210   CAMLreturn(Val_int(still_running));
4211 }
4212
4213 CAMLprim value caml_curl_multi_socket_all(value v_multi)
4214 {
4215   CAMLparam1(v_multi);
4216   int still_running = 0;
4217   CURLMcode rc = CURLM_OK;
4218   CURLM* h = CURLM_val(v_multi);
4219
4220   caml_enter_blocking_section();
4221   do {
4222     rc = curl_multi_socket_all(h, &still_running);
4223   } while (rc == CURLM_CALL_MULTI_PERFORM);
4224   caml_leave_blocking_section();
4225
4226   check_mcode(rc);
4227
4228   CAMLreturn(Val_int(still_running));
4229 }
4230
4231 static int curlm_sock_cb(CURL *e, curl_socket_t sock, int what, void *cbp, void *sockp)
4232 {
4233   caml_leave_blocking_section();
4234
4235   CAMLparam0();
4236   CAMLlocal2(v_what,csock);
4237   (void)e;
4238   (void)sockp; /* not used */
4239
4240   /* v_what = Val_int(what); */
4241   switch (what)
4242   {
4243     case CURL_POLL_NONE   : v_what = Val_int(0); break;
4244     case CURL_POLL_IN     : v_what = Val_int(1); break;
4245     case CURL_POLL_OUT    : v_what = Val_int(2); break;
4246     case CURL_POLL_INOUT  : v_what = Val_int(3); break;
4247     case CURL_POLL_REMOVE : v_what = Val_int(4); break;
4248     default:
4249       fprintf(stderr, "curlm_sock_cb sock=%d what=%d\n", sock, what);
4250       fflush(stderr);
4251       raise_multi_error("curlm_sock_cb"); /* FIXME exception from callback */
4252   }
4253   csock=Val_socket(sock);
4254   caml_callback2(Field(((ml_multi_handle*)cbp)->values,curlmopt_socket_function),
4255                  csock, v_what);
4256   CAMLdrop;
4257
4258   caml_enter_blocking_section();
4259   return 0;
4260 }
4261
4262 CAMLprim value caml_curl_multi_socketfunction(value v_multi, value v_cb)
4263 {
4264   CAMLparam2(v_multi, v_cb);
4265   ml_multi_handle* multi = Multi_val(v_multi);
4266
4267   Store_field(multi->values, curlmopt_socket_function, v_cb);
4268
4269   curl_multi_setopt(multi->handle, CURLMOPT_SOCKETFUNCTION, curlm_sock_cb);
4270   curl_multi_setopt(multi->handle, CURLMOPT_SOCKETDATA, multi);
4271
4272   CAMLreturn(Val_unit);
4273 }
4274
4275 static int curlm_timer_cb(CURLM *multi, long timeout_ms, void *userp)
4276 {
4277   caml_leave_blocking_section();
4278
4279   CAMLparam0();
4280   (void)multi;
4281   caml_callback(Field(((ml_multi_handle*)userp)->values,curlmopt_timer_function), Val_long(timeout_ms));
4282   CAMLdrop;
4283
4284   caml_enter_blocking_section();
4285   return 0;
4286 }
4287
4288 CAMLprim value caml_curl_multi_timerfunction(value v_multi, value v_cb)
4289 {
4290   CAMLparam2(v_multi, v_cb);
4291   ml_multi_handle* multi = Multi_val(v_multi);
4292
4293   Store_field(multi->values, curlmopt_timer_function, v_cb);
4294
4295   curl_multi_setopt(multi->handle, CURLMOPT_TIMERFUNCTION, curlm_timer_cb);
4296   curl_multi_setopt(multi->handle, CURLMOPT_TIMERDATA, multi);
4297
4298   CAMLreturn(Val_unit);
4299 }
4300
4301 CAMLprim value caml_curl_multi_timeout(value v_multi)
4302 {
4303   CAMLparam1(v_multi);
4304   long ms = 0;
4305   CURLMcode rc = CURLM_OK;
4306   ml_multi_handle* multi = Multi_val(v_multi);
4307
4308   rc = curl_multi_timeout(multi->handle, &ms);
4309
4310   check_mcode(rc);
4311
4312   CAMLreturn(Val_long(ms));
4313 }
4314
4315 #define SETMOPT_VAL_(func_name, curl_option, conv_val) \
4316 static void func_name(CURLM *handle, value option) \
4317 { \
4318     CAMLparam1(option); \
4319     CURLMcode result = CURLM_OK; \
4320 \
4321     result = curl_multi_setopt(handle, curl_option, conv_val(option)); \
4322 \
4323     check_mcode(result); \
4324 \
4325     CAMLreturn0; \
4326 }
4327
4328 #define SETMOPT_VAL(name, conv) SETMOPT_VAL_(handle_multi_##name, CURLMOPT_##name, conv)
4329 #define SETMOPT_BOOL(name) SETMOPT_VAL(name, Bool_val)
4330 #define SETMOPT_LONG(name) SETMOPT_VAL(name, Long_val)
4331 #define SETMOPT_INT64(name) SETMOPT_VAL(name, Int64_val)
4332
4333 long pipeliningMap[] =
4334 {
4335   0, /* CURLPIPE_NOTHING */
4336   1, /* CURLPIPE_HTTP1 */
4337   2, /* CURLPIPE_MULTIPLEX */
4338 };
4339
4340 static void handle_multi_PIPELINING(CURLM* handle, value option)
4341 {
4342   CAMLparam1(option);
4343   CURLMcode result = CURLM_OK;
4344
4345   long bits = convert_bit_list(pipeliningMap, sizeof(pipeliningMap) / sizeof(pipeliningMap[0]), option);
4346
4347   result = curl_multi_setopt(handle, CURLMOPT_PIPELINING, bits);
4348
4349   check_mcode(result);
4350
4351   CAMLreturn0;
4352 }
4353
4354 #if HAVE_DECL_CURLMOPT_MAXCONNECTS
4355 SETMOPT_LONG( MAXCONNECTS)
4356 #endif
4357
4358 #if HAVE_DECL_CURLMOPT_MAX_PIPELINE_LENGTH
4359 SETMOPT_LONG( MAX_PIPELINE_LENGTH)
4360 #endif
4361
4362 #if HAVE_DECL_CURLMOPT_MAX_HOST_CONNECTIONS
4363 SETMOPT_LONG( MAX_HOST_CONNECTIONS)
4364 #endif
4365
4366 typedef struct CURLMOptionMapping CURLMOptionMapping;
4367 #define OPT(name) { handle_multi_## name, "CURLMOPT_"#name}
4368 #define NO_OPT(name) { NULL, "CURLMOPT_"#name}
4369
4370 struct CURLMOptionMapping
4371 {
4372     void (*optionHandler)(CURLM *, value);
4373     char *name;
4374 };
4375
4376 CURLMOptionMapping implementedMOptionMap[] = {
4377   OPT( PIPELINING),
4378 #if HAVE_DECL_CURLMOPT_MAXCONNECTS
4379   OPT( MAXCONNECTS),
4380 #else
4381   NO_OPT( MAXCONNECTS),
4382 #endif
4383 #if HAVE_DECL_CURLMOPT_MAX_PIPELINE_LENGTH
4384   OPT( MAX_PIPELINE_LENGTH),
4385 #else
4386   NO_OPT( MAX_PIPELINE_LENGTH),
4387 #endif
4388 #if HAVE_DECL_CURLMOPT_MAX_HOST_CONNECTIONS
4389   OPT( MAX_HOST_CONNECTIONS),
4390 #else
4391   NO_OPT( MAX_HOST_CONNECTIONS),
4392 #endif
4393 };
4394
4395 CAMLprim value caml_curl_multi_setopt(value v_multi, value option)
4396 {
4397     CAMLparam2(v_multi, option);
4398     CAMLlocal1(data);
4399     CURLM *handle = Multi_val(v_multi)->handle;
4400     CURLMOptionMapping* thisOption = NULL;
4401     static value* exception = NULL;
4402
4403     data = Field(option, 0);
4404
4405     if (Tag_val(option) < sizeof(implementedMOptionMap)/sizeof(CURLMOptionMapping))
4406     {
4407       thisOption = &implementedMOptionMap[Tag_val(option)];
4408       if (thisOption->optionHandler)
4409       {
4410         thisOption->optionHandler(handle, data);
4411       }
4412       else
4413       {
4414         if (NULL == exception)
4415         {
4416           exception = caml_named_value("Curl.NotImplemented");
4417           if (NULL == exception) caml_invalid_argument("Curl.NotImplemented");
4418         }
4419
4420         caml_raise_with_string(*exception, thisOption->name);
4421       }
4422     }
4423     else
4424     {
4425       caml_failwith("Invalid CURLMOPT Option");
4426     }
4427
4428     CAMLreturn(Val_unit);
4429 }