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     curl_easy_setopt(connection->handle, CURLOPT_PRIVATE, connection);
1261     resetOcamlValues(connection);
1262
1263     CAMLreturn(Val_unit);
1264 }
1265
1266 /**
1267  **  curl_easy_setopt helper utility functions
1268  **/
1269
1270 #define SETOPT_FUNCTION(name) \
1271 static void handle_##name##FUNCTION(Connection *conn, value option) \
1272 { \
1273     CAMLparam1(option); \
1274     CURLcode result = CURLE_OK; \
1275     Store_field(conn->ocamlValues, Ocaml_##name##FUNCTION, option); \
1276     result = curl_easy_setopt(conn->handle, CURLOPT_##name##FUNCTION, cb_##name##FUNCTION); \
1277     if (result != CURLE_OK) raiseError(conn, result); \
1278     result = curl_easy_setopt(conn->handle, CURLOPT_##name##DATA, conn); \
1279     if (result != CURLE_OK) raiseError(conn, result); \
1280     CAMLreturn0; \
1281 }
1282
1283 SETOPT_FUNCTION( WRITE)
1284 SETOPT_FUNCTION( READ)
1285 SETOPT_FUNCTION( HEADER)
1286 SETOPT_FUNCTION( PROGRESS)
1287 SETOPT_FUNCTION( DEBUG)
1288
1289 #if HAVE_DECL_CURLOPT_SEEKFUNCTION
1290 SETOPT_FUNCTION( SEEK)
1291 #endif
1292
1293 #if HAVE_DECL_CURLOPT_IOCTLFUNCTION
1294 SETOPT_FUNCTION( IOCTL)
1295 #endif
1296
1297 #if HAVE_DECL_CURLOPT_OPENSOCKETFUNCTION
1298 SETOPT_FUNCTION( OPENSOCKET)
1299 #endif
1300
1301 static void handle_slist(Connection *conn, struct curl_slist** slist, OcamlValue caml_option, CURLoption curl_option, value option)
1302 {
1303     CAMLparam1(option);
1304     CURLcode result = CURLE_OK;
1305
1306     Store_field(conn->ocamlValues, caml_option, option);
1307
1308     free_curl_slist(*slist);
1309     *slist = NULL;
1310
1311     while (Val_emptylist != option)
1312     {
1313         *slist = curl_slist_append(*slist, String_val(Field(option, 0)));
1314
1315         option = Field(option, 1);
1316     }
1317
1318     result = curl_easy_setopt(conn->handle, curl_option, *slist);
1319
1320     if (result != CURLE_OK)
1321         raiseError(conn, result);
1322
1323     CAMLreturn0;
1324 }
1325
1326 static long convert_bit_list(long *map, size_t map_size, value option)
1327 {
1328     CAMLparam1(option);
1329     long bits = 0;
1330     int index;
1331
1332     while (Val_emptylist != option)
1333     {
1334         index = Int_val(Field(option, 0));
1335         if ((index < 0) || ((size_t)index >= map_size))
1336           caml_invalid_argument("convert_bit_list");
1337
1338         bits |= map[index];
1339
1340         option = Field(option, 1);
1341     }
1342
1343     CAMLreturnT(long, bits);
1344 }
1345
1346 #define SETOPT_STRING(name) \
1347 static void handle_##name(Connection *conn, value option) \
1348 { \
1349     CAMLparam1(option); \
1350     CURLcode result = CURLE_OK; \
1351 \
1352     Store_field(conn->ocamlValues, Ocaml_##name, option); \
1353 \
1354     if (conn->curl_##name != NULL) \
1355         free(conn->curl_##name); \
1356 \
1357     conn->curl_##name = strdup(String_val(option)); \
1358 \
1359     result = curl_easy_setopt(conn->handle, CURLOPT_##name, conn->curl_##name); \
1360 \
1361     if (result != CURLE_OK) \
1362         raiseError(conn, result); \
1363 \
1364     CAMLreturn0; \
1365 }
1366
1367 #define SETOPT_VAL_(func_name, curl_option, conv_val) \
1368 static void func_name(Connection *conn, value option) \
1369 { \
1370     CAMLparam1(option); \
1371     CURLcode result = CURLE_OK; \
1372 \
1373     result = curl_easy_setopt(conn->handle, curl_option, conv_val(option)); \
1374 \
1375     if (result != CURLE_OK) \
1376         raiseError(conn, result); \
1377 \
1378     CAMLreturn0; \
1379 }
1380
1381 #define SETOPT_VAL(name, conv) SETOPT_VAL_(handle_##name, CURLOPT_##name, conv)
1382 #define SETOPT_BOOL(name) SETOPT_VAL(name, Bool_val)
1383 #define SETOPT_LONG(name) SETOPT_VAL(name, Long_val)
1384 #define SETOPT_INT64(name) SETOPT_VAL(name, Int64_val)
1385
1386 #define SETOPT_SLIST(name) \
1387 static void handle_##name(Connection* conn, value option) \
1388 { \
1389   handle_slist(conn,&(conn->curl_##name),Ocaml_##name,CURLOPT_##name,option); \
1390 }
1391
1392 SETOPT_STRING( URL)
1393 SETOPT_LONG( INFILESIZE)
1394 SETOPT_STRING( PROXY)
1395 SETOPT_LONG( PROXYPORT)
1396 SETOPT_BOOL( HTTPPROXYTUNNEL)
1397 SETOPT_BOOL( VERBOSE)
1398 SETOPT_BOOL( HEADER)
1399 SETOPT_BOOL( NOPROGRESS)
1400
1401 #if HAVE_DECL_CURLOPT_NOSIGNAL
1402 SETOPT_BOOL( NOSIGNAL)
1403 #endif
1404
1405 SETOPT_BOOL( NOBODY)
1406 SETOPT_BOOL( FAILONERROR)
1407 SETOPT_BOOL( UPLOAD)
1408 SETOPT_BOOL( POST)
1409 SETOPT_BOOL( FTPLISTONLY)
1410 SETOPT_BOOL( FTPAPPEND)
1411
1412
1413 static void handle_NETRC(Connection *conn, value option)
1414 {
1415     CAMLparam1(option);
1416     CURLcode result = CURLE_OK;
1417     long netrc;
1418
1419     switch (Long_val(option))
1420     {
1421     case 0: /* CURL_NETRC_OPTIONAL */
1422         netrc = CURL_NETRC_OPTIONAL;
1423         break;
1424
1425     case 1:/* CURL_NETRC_IGNORED */
1426         netrc = CURL_NETRC_IGNORED;
1427         break;
1428
1429     case 2: /* CURL_NETRC_REQUIRED */
1430         netrc = CURL_NETRC_REQUIRED;
1431         break;
1432
1433     default:
1434         caml_failwith("Invalid NETRC Option");
1435         break;
1436     }
1437
1438     result = curl_easy_setopt(conn->handle,
1439                               CURLOPT_NETRC,
1440                               netrc);
1441
1442     if (result != CURLE_OK)
1443         raiseError(conn, result);
1444
1445     CAMLreturn0;
1446 }
1447
1448 #if HAVE_DECL_CURLOPT_ENCODING
1449 static void handle_ENCODING(Connection *conn, value option)
1450 {
1451     CAMLparam1(option);
1452     CURLcode result = CURLE_OK;
1453
1454     switch (Long_val(option))
1455     {
1456     case 0: /* CURL_ENCODING_NONE */
1457         result = curl_easy_setopt(conn->handle,
1458                                   CURLOPT_ENCODING,
1459                                   "identity");
1460         break;
1461
1462     case 1: /* CURL_ENCODING_DEFLATE */
1463         result = curl_easy_setopt(conn->handle,
1464                                   CURLOPT_ENCODING,
1465                                   "deflate");
1466         break;
1467
1468     case 2: /* CURL_ENCODING_GZIP */
1469         result = curl_easy_setopt(conn->handle,
1470                                   CURLOPT_ENCODING,
1471                                   "gzip");
1472         break;
1473
1474     case 3: /* CURL_ENCODING_ANY */
1475         result = curl_easy_setopt(conn->handle,
1476                                   CURLOPT_ENCODING,
1477                                   "");
1478         break;
1479
1480     default:
1481         caml_failwith("Invalid Encoding Option");
1482         break;
1483     }
1484
1485     if (result != CURLE_OK)
1486         raiseError(conn, result);
1487
1488     CAMLreturn0;
1489 }
1490 #endif
1491
1492
1493 SETOPT_BOOL( FOLLOWLOCATION)
1494 SETOPT_BOOL( TRANSFERTEXT)
1495 SETOPT_BOOL( PUT)
1496 SETOPT_STRING( USERPWD)
1497 SETOPT_STRING( PROXYUSERPWD)
1498 SETOPT_STRING( RANGE)
1499
1500 static void handle_ERRORBUFFER(Connection *conn, value option)
1501 {
1502     CAMLparam1(option);
1503     CURLcode result = CURLE_OK;
1504
1505     Store_field(conn->ocamlValues, Ocaml_ERRORBUFFER, option);
1506
1507     if (conn->curl_ERRORBUFFER != NULL)
1508         free(conn->curl_ERRORBUFFER);
1509
1510     conn->curl_ERRORBUFFER = malloc(sizeof(char) * CURL_ERROR_SIZE);
1511
1512     result = curl_easy_setopt(conn->handle,
1513                               CURLOPT_ERRORBUFFER,
1514                               conn->curl_ERRORBUFFER);
1515
1516     if (result != CURLE_OK)
1517         raiseError(conn, result);
1518
1519     CAMLreturn0;
1520 }
1521
1522 SETOPT_LONG( TIMEOUT)
1523
1524 static void handle_POSTFIELDS(Connection *conn, value option)
1525 {
1526     CAMLparam1(option);
1527     CURLcode result = CURLE_OK;
1528
1529     Store_field(conn->ocamlValues, Ocaml_POSTFIELDS, option);
1530
1531     if (conn->curl_POSTFIELDS != NULL)
1532         free(conn->curl_POSTFIELDS);
1533
1534     conn->curl_POSTFIELDS = strdup_ml(option);
1535
1536     result = curl_easy_setopt(conn->handle,
1537                               CURLOPT_POSTFIELDS,
1538                               conn->curl_POSTFIELDS);
1539
1540     if (result != CURLE_OK)
1541         raiseError(conn, result);
1542
1543     CAMLreturn0;
1544 }
1545
1546 SETOPT_LONG( POSTFIELDSIZE)
1547 SETOPT_STRING( REFERER)
1548 SETOPT_STRING( USERAGENT)
1549 SETOPT_STRING( FTPPORT)
1550 SETOPT_LONG( LOW_SPEED_LIMIT)
1551 SETOPT_LONG( LOW_SPEED_TIME)
1552 SETOPT_LONG( RESUME_FROM)
1553 SETOPT_STRING( COOKIE)
1554
1555 SETOPT_SLIST( HTTPHEADER)
1556
1557 static void handle_HTTPPOST(Connection *conn, value option)
1558 {
1559     CAMLparam1(option);
1560     CAMLlocal3(listIter, formItem, contentType);
1561     CURLcode result = CURLE_OK;
1562
1563     listIter = option;
1564
1565     Store_field(conn->ocamlValues, Ocaml_HTTPPOST, option);
1566
1567     free_curl_slist(conn->httpPostBuffers);
1568     if (conn->httpPostFirst != NULL)
1569         curl_formfree(conn->httpPostFirst);
1570
1571     conn->httpPostBuffers = NULL;
1572     conn->httpPostFirst = NULL;
1573     conn->httpPostLast = NULL;
1574
1575     while (!Is_long(listIter))
1576     {
1577         formItem = Field(listIter, 0);
1578
1579         switch (Tag_val(formItem))
1580         {
1581         case 0: /* CURLFORM_CONTENT */
1582             if (Wosize_val(formItem) < 3)
1583             {
1584                 caml_failwith("Incorrect CURLFORM_CONTENT parameters");
1585             }
1586
1587             if (Is_long(Field(formItem, 2)) &&
1588                 Long_val(Field(formItem, 2)) == 0)
1589             {
1590                 curl_formadd(&conn->httpPostFirst,
1591                              &conn->httpPostLast,
1592                              CURLFORM_COPYNAME,
1593                              String_val(Field(formItem, 0)),
1594                              CURLFORM_NAMELENGTH,
1595                              caml_string_length(Field(formItem, 0)),
1596                              CURLFORM_COPYCONTENTS,
1597                              String_val(Field(formItem, 1)),
1598                              CURLFORM_CONTENTSLENGTH,
1599                              caml_string_length(Field(formItem, 1)),
1600                              CURLFORM_END);
1601             }
1602             else if (Is_block(Field(formItem, 2)))
1603             {
1604                 contentType = Field(formItem, 2);
1605
1606                 curl_formadd(&conn->httpPostFirst,
1607                              &conn->httpPostLast,
1608                              CURLFORM_COPYNAME,
1609                              String_val(Field(formItem, 0)),
1610                              CURLFORM_NAMELENGTH,
1611                              caml_string_length(Field(formItem, 0)),
1612                              CURLFORM_COPYCONTENTS,
1613                              String_val(Field(formItem, 1)),
1614                              CURLFORM_CONTENTSLENGTH,
1615                              caml_string_length(Field(formItem, 1)),
1616                              CURLFORM_CONTENTTYPE,
1617                              String_val(Field(contentType, 0)),
1618                              CURLFORM_END);
1619             }
1620             else
1621             {
1622                 caml_failwith("Incorrect CURLFORM_CONTENT parameters");
1623             }
1624             break;
1625
1626         case 1: /* CURLFORM_FILECONTENT */
1627             if (Wosize_val(formItem) < 3)
1628             {
1629                 caml_failwith("Incorrect CURLFORM_FILECONTENT parameters");
1630             }
1631
1632             if (Is_long(Field(formItem, 2)) &&
1633                 Long_val(Field(formItem, 2)) == 0)
1634             {
1635                 curl_formadd(&conn->httpPostFirst,
1636                              &conn->httpPostLast,
1637                              CURLFORM_COPYNAME,
1638                              String_val(Field(formItem, 0)),
1639                              CURLFORM_NAMELENGTH,
1640                              caml_string_length(Field(formItem, 0)),
1641                              CURLFORM_FILECONTENT,
1642                              String_val(Field(formItem, 1)),
1643                              CURLFORM_END);
1644             }
1645             else if (Is_block(Field(formItem, 2)))
1646             {
1647                 contentType = Field(formItem, 2);
1648
1649                 curl_formadd(&conn->httpPostFirst,
1650                              &conn->httpPostLast,
1651                              CURLFORM_COPYNAME,
1652                              String_val(Field(formItem, 0)),
1653                              CURLFORM_NAMELENGTH,
1654                              caml_string_length(Field(formItem, 0)),
1655                              CURLFORM_FILECONTENT,
1656                              String_val(Field(formItem, 1)),
1657                              CURLFORM_CONTENTTYPE,
1658                              String_val(Field(contentType, 0)),
1659                              CURLFORM_END);
1660             }
1661             else
1662             {
1663                 caml_failwith("Incorrect CURLFORM_FILECONTENT parameters");
1664             }
1665             break;
1666
1667         case 2: /* CURLFORM_FILE */
1668             if (Wosize_val(formItem) < 3)
1669             {
1670                 caml_failwith("Incorrect CURLFORM_FILE parameters");
1671             }
1672
1673             if (Is_long(Field(formItem, 2)) &&
1674                 Long_val(Field(formItem, 2)) == 0)
1675             {
1676                 curl_formadd(&conn->httpPostFirst,
1677                              &conn->httpPostLast,
1678                              CURLFORM_COPYNAME,
1679                              String_val(Field(formItem, 0)),
1680                              CURLFORM_NAMELENGTH,
1681                              caml_string_length(Field(formItem, 0)),
1682                              CURLFORM_FILE,
1683                              String_val(Field(formItem, 1)),
1684                              CURLFORM_END);
1685             }
1686             else if (Is_block(Field(formItem, 2)))
1687             {
1688                 contentType = Field(formItem, 2);
1689
1690                 curl_formadd(&conn->httpPostFirst,
1691                              &conn->httpPostLast,
1692                              CURLFORM_COPYNAME,
1693                              String_val(Field(formItem, 0)),
1694                              CURLFORM_NAMELENGTH,
1695                              caml_string_length(Field(formItem, 0)),
1696                              CURLFORM_FILE,
1697                              String_val(Field(formItem, 1)),
1698                              CURLFORM_CONTENTTYPE,
1699                              String_val(Field(contentType, 0)),
1700                              CURLFORM_END);
1701             }
1702             else
1703             {
1704                 caml_failwith("Incorrect CURLFORM_FILE parameters");
1705             }
1706             break;
1707
1708         case 3: /* CURLFORM_BUFFER */
1709             if (Wosize_val(formItem) < 4)
1710             {
1711                 caml_failwith("Incorrect CURLFORM_BUFFER parameters");
1712             }
1713
1714             if (Is_long(Field(formItem, 3)) &&
1715                 Long_val(Field(formItem, 3)) == 0)
1716             {
1717                 conn->httpPostBuffers = curl_slist_prepend_ml(conn->httpPostBuffers, Field(formItem, 2));
1718
1719                 curl_formadd(&conn->httpPostFirst,
1720                              &conn->httpPostLast,
1721                              CURLFORM_COPYNAME,
1722                              String_val(Field(formItem, 0)),
1723                              CURLFORM_NAMELENGTH,
1724                              caml_string_length(Field(formItem, 0)),
1725                              CURLFORM_BUFFER,
1726                              String_val(Field(formItem, 1)),
1727                              CURLFORM_BUFFERPTR,
1728                              conn->httpPostBuffers->data,
1729                              CURLFORM_BUFFERLENGTH,
1730                              caml_string_length(Field(formItem, 2)),
1731                              CURLFORM_END);
1732             }
1733             else if (Is_block(Field(formItem, 3)))
1734             {
1735                 conn->httpPostBuffers = curl_slist_prepend_ml(conn->httpPostBuffers, Field(formItem, 2));
1736
1737                 contentType = Field(formItem, 3);
1738
1739                 curl_formadd(&conn->httpPostFirst,
1740                              &conn->httpPostLast,
1741                              CURLFORM_COPYNAME,
1742                              String_val(Field(formItem, 0)),
1743                              CURLFORM_NAMELENGTH,
1744                              caml_string_length(Field(formItem, 0)),
1745                              CURLFORM_BUFFER,
1746                              String_val(Field(formItem, 1)),
1747                              CURLFORM_BUFFERPTR,
1748                              conn->httpPostBuffers->data,
1749                              CURLFORM_BUFFERLENGTH,
1750                              caml_string_length(Field(formItem, 2)),
1751                              CURLFORM_CONTENTTYPE,
1752                              String_val(Field(contentType, 0)),
1753                              CURLFORM_END);
1754             }
1755             else
1756             {
1757                 caml_failwith("Incorrect CURLFORM_BUFFER parameters");
1758             }
1759             break;
1760         }
1761
1762         listIter = Field(listIter, 1);
1763     }
1764
1765     result = curl_easy_setopt(conn->handle,
1766                               CURLOPT_HTTPPOST,
1767                               conn->httpPostFirst);
1768
1769     if (result != CURLE_OK)
1770         raiseError(conn, result);
1771
1772     CAMLreturn0;
1773 }
1774
1775 SETOPT_STRING( SSLCERT)
1776 SETOPT_STRING( SSLCERTTYPE)
1777 SETOPT_STRING( SSLCERTPASSWD)
1778 SETOPT_STRING( SSLKEY)
1779 SETOPT_STRING( SSLKEYTYPE)
1780 SETOPT_STRING( SSLKEYPASSWD)
1781 SETOPT_STRING( SSLENGINE)
1782 SETOPT_BOOL( SSLENGINE_DEFAULT)
1783 SETOPT_BOOL( CRLF)
1784
1785 SETOPT_SLIST( QUOTE)
1786 SETOPT_SLIST( POSTQUOTE)
1787
1788 SETOPT_STRING( COOKIEFILE)
1789 #if HAVE_DECL_CURLOPT_CERTINFO
1790 SETOPT_BOOL( CERTINFO)
1791 #endif
1792
1793 #if !defined(CURL_SSLVERSION_TLSv1_0)
1794 #define CURL_SSLVERSION_TLSv1_0 CURL_SSLVERSION_TLSv1
1795 #endif
1796
1797 #if !defined(CURL_SSLVERSION_TLSv1_1)
1798 #define CURL_SSLVERSION_TLSv1_1 CURL_SSLVERSION_TLSv1
1799 #endif
1800
1801 #if !defined(CURL_SSLVERSION_TLSv1_2)
1802 #define CURL_SSLVERSION_TLSv1_2 CURL_SSLVERSION_TLSv1
1803 #endif
1804
1805 #if !defined(CURL_SSLVERSION_TLSv1_3)
1806 #define CURL_SSLVERSION_TLSv1_3 CURL_SSLVERSION_TLSv1
1807 #endif
1808
1809 static void handle_SSLVERSION(Connection *conn, value option)
1810 {
1811     CAMLparam1(option);
1812     CURLcode result = CURLE_OK;
1813     int v = CURL_SSLVERSION_DEFAULT;
1814
1815     switch (Long_val(option))
1816     {
1817     case 0: v = CURL_SSLVERSION_DEFAULT; break;
1818     case 1: v = CURL_SSLVERSION_TLSv1; break;
1819     case 2: v = CURL_SSLVERSION_SSLv2; break;
1820     case 3: v = CURL_SSLVERSION_SSLv3; break;
1821     case 4: v = CURL_SSLVERSION_TLSv1_0; break;
1822     case 5: v = CURL_SSLVERSION_TLSv1_1; break;
1823     case 6: v = CURL_SSLVERSION_TLSv1_2; break;
1824     case 7: v = CURL_SSLVERSION_TLSv1_3; break;
1825     default:
1826         caml_failwith("Invalid SSLVERSION Option");
1827         break;
1828     }
1829
1830     result = curl_easy_setopt(conn->handle, CURLOPT_SSLVERSION, v);
1831
1832     if (result != CURLE_OK)
1833         raiseError(conn, result);
1834
1835     CAMLreturn0;
1836 }
1837
1838 static void handle_TIMECONDITION(Connection *conn, value option)
1839 {
1840     CAMLparam1(option);
1841     CURLcode result = CURLE_OK;
1842     int timecond = CURL_TIMECOND_NONE;
1843
1844     switch (Long_val(option))
1845     {
1846     case 0: timecond = CURL_TIMECOND_NONE; break;
1847     case 1: timecond = CURL_TIMECOND_IFMODSINCE; break;
1848     case 2: timecond = CURL_TIMECOND_IFUNMODSINCE; break;
1849     case 3: timecond = CURL_TIMECOND_LASTMOD; break;
1850     default:
1851         caml_failwith("Invalid TIMECOND Option");
1852         break;
1853     }
1854
1855     result = curl_easy_setopt(conn->handle, CURLOPT_TIMECONDITION, timecond);
1856
1857     if (result != CURLE_OK)
1858         raiseError(conn, result);
1859
1860     CAMLreturn0;
1861 }
1862
1863 SETOPT_VAL( TIMEVALUE, Int32_val)
1864 SETOPT_STRING( CUSTOMREQUEST)
1865 SETOPT_STRING( INTERFACE)
1866
1867 static void handle_KRB4LEVEL(Connection *conn, value option)
1868 {
1869     CAMLparam1(option);
1870     CURLcode result = CURLE_OK;
1871
1872     switch (Long_val(option))
1873     {
1874     case 0: /* KRB4_NONE */
1875         result = curl_easy_setopt(conn->handle,
1876                                   CURLOPT_KRB4LEVEL,
1877                                   NULL);
1878         break;
1879
1880     case 1: /* KRB4_CLEAR */
1881         result = curl_easy_setopt(conn->handle,
1882                                   CURLOPT_KRB4LEVEL,
1883                                   "clear");
1884         break;
1885
1886     case 2: /* KRB4_SAFE */
1887         result = curl_easy_setopt(conn->handle,
1888                                   CURLOPT_KRB4LEVEL,
1889                                   "safe");
1890         break;
1891
1892     case 3: /* KRB4_CONFIDENTIAL */
1893         result = curl_easy_setopt(conn->handle,
1894                                   CURLOPT_KRB4LEVEL,
1895                                   "confidential");
1896         break;
1897
1898     case 4: /* KRB4_PRIVATE */
1899         result = curl_easy_setopt(conn->handle,
1900                                   CURLOPT_KRB4LEVEL,
1901                                   "private");
1902         break;
1903
1904     default:
1905         caml_failwith("Invalid KRB4 Option");
1906         break;
1907     }
1908
1909     if (result != CURLE_OK)
1910         raiseError(conn, result);
1911
1912     CAMLreturn0;
1913 }
1914
1915 SETOPT_BOOL( SSL_VERIFYPEER)
1916 SETOPT_STRING( CAINFO)
1917 SETOPT_STRING( CAPATH)
1918 SETOPT_BOOL( FILETIME)
1919 SETOPT_LONG( MAXREDIRS)
1920 SETOPT_LONG( MAXCONNECTS)
1921
1922 static void handle_CLOSEPOLICY(Connection *conn, value option)
1923 {
1924     CAMLparam1(option);
1925     CURLcode result = CURLE_OK;
1926
1927     switch (Long_val(option))
1928     {
1929     case 0: /* CLOSEPOLICY_OLDEST */
1930         result = curl_easy_setopt(conn->handle,
1931                                   CURLOPT_CLOSEPOLICY,
1932                                   CURLCLOSEPOLICY_OLDEST);
1933         break;
1934
1935     case 1: /* CLOSEPOLICY_LEAST_RECENTLY_USED */
1936         result = curl_easy_setopt(conn->handle,
1937                                   CURLOPT_CLOSEPOLICY,
1938                                   CURLCLOSEPOLICY_LEAST_RECENTLY_USED);
1939         break;
1940
1941     default:
1942         caml_failwith("Invalid CLOSEPOLICY Option");
1943         break;
1944     }
1945
1946     if (result != CURLE_OK)
1947         raiseError(conn, result);
1948
1949     CAMLreturn0;
1950 }
1951
1952 SETOPT_BOOL( FRESH_CONNECT)
1953 SETOPT_BOOL( FORBID_REUSE)
1954 SETOPT_STRING( RANDOM_FILE)
1955 SETOPT_STRING( EGDSOCKET)
1956 SETOPT_LONG( CONNECTTIMEOUT)
1957 SETOPT_BOOL( HTTPGET)
1958
1959 static void handle_SSL_VERIFYHOST(Connection *conn, value option)
1960 {
1961     CAMLparam1(option);
1962     CURLcode result = CURLE_OK;
1963
1964     switch (Long_val(option))
1965     {
1966     case 0: /* SSLVERIFYHOST_NONE */
1967     case 1: /* SSLVERIFYHOST_EXISTENCE */
1968     case 2: /* SSLVERIFYHOST_HOSTNAME */
1969         result = curl_easy_setopt(conn->handle,
1970                                   CURLOPT_SSL_VERIFYHOST,
1971                                   /* map EXISTENCE to HOSTNAME */
1972                                   Long_val(option) == 0 ? 0 : 2);
1973         break;
1974
1975     default:
1976         caml_failwith("Invalid SSLVERIFYHOST Option");
1977         break;
1978     }
1979
1980     if (result != CURLE_OK)
1981         raiseError(conn, result);
1982
1983     CAMLreturn0;
1984 }
1985
1986 SETOPT_STRING( COOKIEJAR)
1987 SETOPT_STRING( SSL_CIPHER_LIST)
1988
1989 static void handle_HTTP_VERSION(Connection *conn, value option)
1990 {
1991     CAMLparam1(option);
1992     CURLcode result = CURLE_OK;
1993
1994     long version = CURL_HTTP_VERSION_NONE;
1995
1996     switch (Long_val(option))
1997     {
1998     case 0: version = CURL_HTTP_VERSION_NONE; break;
1999     case 1: version = CURL_HTTP_VERSION_1_0; break;
2000     case 2: version = CURL_HTTP_VERSION_1_1; break;
2001     case 3:
2002 #if defined(CURL_HTTP_VERSION_2)
2003       version = CURL_HTTP_VERSION_2;
2004 #elif defined(CURL_HTTP_VERSION_2_0)
2005       version = CURL_HTTP_VERSION_2_0;
2006 #endif
2007       break;
2008     case 4:
2009 #if defined(CURL_HTTP_VERSION_2TLS)
2010       version = CURL_HTTP_VERSION_2TLS;
2011 #endif
2012       break;
2013     default:
2014       caml_invalid_argument("CURLOPT_HTTP_VERSION");
2015       break;
2016     }
2017
2018     result = curl_easy_setopt(conn->handle, CURLOPT_HTTP_VERSION, version);
2019
2020     if (result != CURLE_OK)
2021         raiseError(conn, result);
2022
2023     CAMLreturn0;
2024 }
2025
2026 SETOPT_BOOL( FTP_USE_EPSV)
2027 SETOPT_LONG( DNS_CACHE_TIMEOUT)
2028 SETOPT_BOOL( DNS_USE_GLOBAL_CACHE)
2029
2030 static void handle_PRIVATE(Connection *conn, value option)
2031 {
2032     CAMLparam1(option);
2033     Store_field(conn->ocamlValues, Ocaml_PRIVATE, option);
2034     CAMLreturn0;
2035 }
2036
2037 #if HAVE_DECL_CURLOPT_HTTP200ALIASES
2038 SETOPT_SLIST( HTTP200ALIASES)
2039 #endif
2040
2041 #if HAVE_DECL_CURLOPT_UNRESTRICTED_AUTH
2042 SETOPT_BOOL( UNRESTRICTED_AUTH)
2043 #endif
2044
2045 #if HAVE_DECL_CURLOPT_FTP_USE_EPRT
2046 SETOPT_BOOL( FTP_USE_EPRT)
2047 #endif
2048
2049 #if HAVE_DECL_CURLOPT_HTTPAUTH
2050 static void handle_HTTPAUTH(Connection *conn, value option)
2051 {
2052     CAMLparam1(option);
2053     CAMLlocal1(listIter);
2054     CURLcode result = CURLE_OK;
2055     long auth = CURLAUTH_NONE;
2056
2057     listIter = option;
2058
2059     while (!Is_long(listIter))
2060     {
2061         switch (Long_val(Field(listIter, 0)))
2062         {
2063         case 0: /* CURLAUTH_BASIC */
2064             auth |= CURLAUTH_BASIC;
2065             break;
2066
2067         case 1: /* CURLAUTH_DIGEST */
2068             auth |= CURLAUTH_DIGEST;
2069             break;
2070
2071         case 2: /* CURLAUTH_GSSNEGOTIATE */
2072             auth |= CURLAUTH_GSSNEGOTIATE;
2073             break;
2074
2075         case 3: /* CURLAUTH_NTLM */
2076             auth |= CURLAUTH_NTLM;
2077             break;
2078
2079         case 4: /* CURLAUTH_ANY */
2080             auth |= CURLAUTH_ANY;
2081             break;
2082
2083         case 5: /* CURLAUTH_ANYSAFE */
2084             auth |= CURLAUTH_ANYSAFE;
2085             break;
2086
2087         default:
2088             caml_failwith("Invalid HTTPAUTH Value");
2089             break;
2090         }
2091
2092         listIter = Field(listIter, 1);
2093     }
2094
2095     result = curl_easy_setopt(conn->handle,
2096                               CURLOPT_HTTPAUTH,
2097                               auth);
2098
2099     if (result != CURLE_OK)
2100         raiseError(conn, result);
2101
2102     CAMLreturn0;
2103 }
2104 #endif
2105
2106 #if HAVE_DECL_CURLOPT_FTP_CREATE_MISSING_DIRS
2107 SETOPT_BOOL( FTP_CREATE_MISSING_DIRS)
2108 #endif
2109
2110 #if HAVE_DECL_CURLOPT_PROXYAUTH
2111 static void handle_PROXYAUTH(Connection *conn, value option)
2112 {
2113     CAMLparam1(option);
2114     CAMLlocal1(listIter);
2115     CURLcode result = CURLE_OK;
2116     long auth = CURLAUTH_NONE;
2117
2118     listIter = option;
2119
2120     while (!Is_long(listIter))
2121     {
2122         switch (Long_val(Field(listIter, 0)))
2123         {
2124         case 0: /* CURLAUTH_BASIC */
2125             auth |= CURLAUTH_BASIC;
2126             break;
2127
2128         case 1: /* CURLAUTH_DIGEST */
2129             auth |= CURLAUTH_DIGEST;
2130             break;
2131
2132         case 2: /* CURLAUTH_GSSNEGOTIATE */
2133             auth |= CURLAUTH_GSSNEGOTIATE;
2134             break;
2135
2136         case 3: /* CURLAUTH_NTLM */
2137             auth |= CURLAUTH_NTLM;
2138             break;
2139
2140         case 4: /* CURLAUTH_ANY */
2141             auth |= CURLAUTH_ANY;
2142             break;
2143
2144         case 5: /* CURLAUTH_ANYSAFE */
2145             auth |= CURLAUTH_ANYSAFE;
2146             break;
2147
2148         default:
2149             caml_failwith("Invalid HTTPAUTH Value");
2150             break;
2151         }
2152
2153         listIter = Field(listIter, 1);
2154     }
2155
2156     result = curl_easy_setopt(conn->handle,
2157                               CURLOPT_PROXYAUTH,
2158                               auth);
2159
2160     if (result != CURLE_OK)
2161         raiseError(conn, result);
2162
2163     CAMLreturn0;
2164 }
2165 #endif
2166
2167 #if HAVE_DECL_CURLOPT_FTP_RESPONSE_TIMEOUT
2168 SETOPT_LONG( FTP_RESPONSE_TIMEOUT)
2169 #endif
2170
2171 #if HAVE_DECL_CURLOPT_IPRESOLVE
2172 static void handle_IPRESOLVE(Connection *conn, value option)
2173 {
2174     CAMLparam1(option);
2175     CURLcode result = CURLE_OK;
2176
2177     switch (Long_val(option))
2178     {
2179     case 0: /* CURL_IPRESOLVE_WHATEVER */
2180         result = curl_easy_setopt(conn->handle,
2181                                   CURLOPT_IPRESOLVE,
2182                                   CURL_IPRESOLVE_WHATEVER);
2183         break;
2184
2185     case 1: /* CURL_IPRESOLVE_V4 */
2186         result = curl_easy_setopt(conn->handle,
2187                                   CURLOPT_IPRESOLVE,
2188                                   CURL_IPRESOLVE_V4);
2189         break;
2190
2191     case 2: /* CURL_IPRESOLVE_V6 */
2192         result = curl_easy_setopt(conn->handle,
2193                                   CURLOPT_IPRESOLVE,
2194                                   CURL_IPRESOLVE_V6);
2195         break;
2196
2197     default:
2198         caml_failwith("Invalid IPRESOLVE Value");
2199         break;
2200     }
2201
2202     if (result != CURLE_OK)
2203         raiseError(conn, result);
2204
2205     CAMLreturn0;
2206 }
2207 #endif
2208
2209 #if HAVE_DECL_CURLOPT_MAXFILESIZE
2210 SETOPT_VAL( MAXFILESIZE, Int32_val)
2211 #endif
2212
2213 #if HAVE_DECL_CURLOPT_INFILESIZE_LARGE
2214 SETOPT_INT64( INFILESIZE_LARGE)
2215 #endif
2216
2217 #if HAVE_DECL_CURLOPT_RESUME_FROM_LARGE
2218 SETOPT_INT64( RESUME_FROM_LARGE)
2219 #endif
2220
2221 #if HAVE_DECL_CURLOPT_MAXFILESIZE_LARGE
2222 SETOPT_INT64( MAXFILESIZE_LARGE)
2223 #endif
2224
2225 #if HAVE_DECL_CURLOPT_NETRC_FILE
2226 SETOPT_STRING( NETRC_FILE)
2227 #endif
2228
2229 #if HAVE_DECL_CURLOPT_FTP_SSL
2230 static void handle_FTP_SSL(Connection *conn, value option)
2231 {
2232     CAMLparam1(option);
2233     CURLcode result = CURLE_OK;
2234
2235     switch (Long_val(option))
2236     {
2237     case 0: /* CURLFTPSSL_NONE */
2238         result = curl_easy_setopt(conn->handle,
2239                                   CURLOPT_FTP_SSL,
2240                                   CURLFTPSSL_NONE);
2241         break;
2242
2243     case 1: /* CURLFTPSSL_TRY */
2244         result = curl_easy_setopt(conn->handle,
2245                                   CURLOPT_FTP_SSL,
2246                                   CURLFTPSSL_TRY);
2247         break;
2248
2249     case 2: /* CURLFTPSSL_CONTROL */
2250         result = curl_easy_setopt(conn->handle,
2251                                   CURLOPT_FTP_SSL,
2252                                   CURLFTPSSL_CONTROL);
2253         break;
2254
2255     case 3: /* CURLFTPSSL_ALL */
2256         result = curl_easy_setopt(conn->handle,
2257                                   CURLOPT_FTP_SSL,
2258                                   CURLFTPSSL_ALL);
2259         break;
2260
2261     default:
2262         caml_failwith("Invalid FTP_SSL Value");
2263         break;
2264     }
2265
2266     if (result != CURLE_OK)
2267         raiseError(conn, result);
2268
2269     CAMLreturn0;
2270 }
2271 #endif
2272
2273 #if HAVE_DECL_CURLOPT_POSTFIELDSIZE_LARGE
2274 SETOPT_INT64( POSTFIELDSIZE_LARGE)
2275 #endif
2276
2277 #if HAVE_DECL_CURLOPT_TCP_NODELAY
2278 /* not using SETOPT_BOOL here because of TCP_NODELAY defined in winsock.h */
2279 SETOPT_VAL_( handle_TCP_NODELAY, CURLOPT_TCP_NODELAY, Bool_val)
2280 #endif
2281
2282 #if HAVE_DECL_CURLOPT_FTPSSLAUTH
2283 static void handle_FTPSSLAUTH(Connection *conn, value option)
2284 {
2285     CAMLparam1(option);
2286     CURLcode result = CURLE_OK;
2287
2288     switch (Long_val(option))
2289     {
2290     case 0: /* CURLFTPAUTH_DEFAULT */
2291         result = curl_easy_setopt(conn->handle,
2292                                   CURLOPT_FTPSSLAUTH,
2293                                   CURLFTPAUTH_DEFAULT);
2294         break;
2295
2296     case 1: /* CURLFTPAUTH_SSL */
2297         result = curl_easy_setopt(conn->handle,
2298                                   CURLOPT_FTPSSLAUTH,
2299                                   CURLFTPAUTH_SSL);
2300         break;
2301
2302     case 2: /* CURLFTPAUTH_TLS */
2303         result = curl_easy_setopt(conn->handle,
2304                                   CURLOPT_FTPSSLAUTH,
2305                                   CURLFTPAUTH_TLS);
2306         break;
2307
2308     default:
2309         caml_failwith("Invalid FTPSSLAUTH value");
2310         break;
2311     }
2312
2313     if (result != CURLE_OK)
2314         raiseError(conn, result);
2315
2316     CAMLreturn0;
2317 }
2318 #endif
2319
2320 #if HAVE_DECL_CURLOPT_FTP_ACCOUNT
2321 SETOPT_STRING( FTP_ACCOUNT)
2322 #endif
2323
2324 #if HAVE_DECL_CURLOPT_COOKIELIST
2325 SETOPT_STRING( COOKIELIST)
2326 #endif
2327
2328 #if HAVE_DECL_CURLOPT_IGNORE_CONTENT_LENGTH
2329 SETOPT_BOOL( IGNORE_CONTENT_LENGTH)
2330 #endif
2331
2332 #if HAVE_DECL_CURLOPT_FTP_SKIP_PASV_IP
2333 SETOPT_BOOL( FTP_SKIP_PASV_IP)
2334 #endif
2335
2336 #if HAVE_DECL_CURLOPT_FTP_FILEMETHOD
2337 static void handle_FTP_FILEMETHOD(Connection *conn, value option)
2338 {
2339     CAMLparam1(option);
2340     CURLcode result = CURLE_OK;
2341
2342     switch (Long_val(option))
2343     {
2344     case 0: /* CURLFTPMETHOD_DEFAULT */
2345         result = curl_easy_setopt(conn->handle,
2346                                   CURLOPT_FTP_FILEMETHOD,
2347                                   CURLFTPMETHOD_DEFAULT);
2348         break;
2349
2350     case 1: /* CURLFTMETHOD_MULTICWD */
2351         result = curl_easy_setopt(conn->handle,
2352                                   CURLOPT_FTP_FILEMETHOD,
2353                                   CURLFTPMETHOD_MULTICWD);
2354         break;
2355
2356     case 2: /* CURLFTPMETHOD_NOCWD */
2357         result = curl_easy_setopt(conn->handle,
2358                                   CURLOPT_FTP_FILEMETHOD,
2359                                   CURLFTPMETHOD_NOCWD);
2360         break;
2361
2362     case 3: /* CURLFTPMETHOD_SINGLECWD */
2363         result = curl_easy_setopt(conn->handle,
2364                                   CURLOPT_FTP_FILEMETHOD,
2365                                   CURLFTPMETHOD_SINGLECWD);
2366
2367     default:
2368         caml_failwith("Invalid FTP_FILEMETHOD value");
2369         break;
2370     }
2371
2372     if (result != CURLE_OK)
2373         raiseError(conn, result);
2374
2375     CAMLreturn0;
2376 }
2377 #endif
2378
2379 #if HAVE_DECL_CURLOPT_LOCALPORT
2380 SETOPT_LONG( LOCALPORT)
2381 #endif
2382
2383 #if HAVE_DECL_CURLOPT_LOCALPORTRANGE
2384 SETOPT_LONG( LOCALPORTRANGE)
2385 #endif
2386
2387 #if HAVE_DECL_CURLOPT_CONNECT_ONLY
2388 SETOPT_BOOL( CONNECT_ONLY)
2389 #endif
2390
2391 #if HAVE_DECL_CURLOPT_MAX_SEND_SPEED_LARGE
2392 SETOPT_INT64( MAX_SEND_SPEED_LARGE)
2393 #endif
2394
2395 #if HAVE_DECL_CURLOPT_MAX_RECV_SPEED_LARGE
2396 SETOPT_INT64( MAX_RECV_SPEED_LARGE)
2397 #endif
2398
2399 #if HAVE_DECL_CURLOPT_FTP_ALTERNATIVE_TO_USER
2400 SETOPT_STRING( FTP_ALTERNATIVE_TO_USER)
2401 #endif
2402
2403 #if HAVE_DECL_CURLOPT_SSL_SESSIONID_CACHE
2404 SETOPT_BOOL( SSL_SESSIONID_CACHE)
2405 #endif
2406
2407 #if HAVE_DECL_CURLOPT_SSH_AUTH_TYPES
2408 static void handle_SSH_AUTH_TYPES(Connection *conn, value option)
2409 {
2410     CAMLparam1(option);
2411     CAMLlocal1(listIter);
2412     CURLcode result = CURLE_OK;
2413     long authTypes = CURLSSH_AUTH_NONE;
2414
2415     listIter = option;
2416
2417     while (!Is_long(listIter))
2418     {
2419         switch (Long_val(Field(listIter, 0)))
2420         {
2421         case 0: /* CURLSSH_AUTH_ANY */
2422             authTypes |= CURLSSH_AUTH_ANY;
2423             break;
2424
2425         case 1: /* CURLSSH_AUTH_PUBLICKEY */
2426             authTypes |= CURLSSH_AUTH_PUBLICKEY;
2427             break;
2428
2429         case 2: /* CURLSSH_AUTH_PASSWORD */
2430             authTypes |= CURLSSH_AUTH_PASSWORD;
2431             break;
2432
2433         case 3: /* CURLSSH_AUTH_HOST */
2434             authTypes |= CURLSSH_AUTH_HOST;
2435             break;
2436
2437         case 4: /* CURLSSH_AUTH_KEYBOARD */
2438             authTypes |= CURLSSH_AUTH_KEYBOARD;
2439             break;
2440
2441         default:
2442             caml_failwith("Invalid CURLSSH_AUTH_TYPES Value");
2443             break;
2444         }
2445
2446         listIter = Field(listIter, 1);
2447     }
2448
2449     result = curl_easy_setopt(conn->handle,
2450                               CURLOPT_SSH_AUTH_TYPES,
2451                               authTypes);
2452
2453     if (result != CURLE_OK)
2454         raiseError(conn, result);
2455
2456     CAMLreturn0;
2457 }
2458 #endif
2459
2460 #if HAVE_DECL_CURLOPT_SSH_PUBLIC_KEYFILE
2461 SETOPT_STRING( SSH_PUBLIC_KEYFILE)
2462 #endif
2463
2464 #if HAVE_DECL_CURLOPT_SSH_PRIVATE_KEYFILE
2465 SETOPT_STRING( SSH_PRIVATE_KEYFILE)
2466 #endif
2467
2468 #if HAVE_DECL_CURLOPT_FTP_SSL_CCC
2469 static void handle_FTP_SSL_CCC(Connection *conn, value option)
2470 {
2471     CAMLparam1(option);
2472     CURLcode result = CURLE_OK;
2473
2474     switch (Long_val(option))
2475     {
2476     case 0: /* CURLFTPSSL_CCC_NONE */
2477         result = curl_easy_setopt(conn->handle,
2478                                   CURLOPT_FTP_SSL_CCC,
2479                                   CURLFTPSSL_CCC_NONE);
2480         break;
2481
2482     case 1: /* CURLFTPSSL_CCC_PASSIVE */
2483         result = curl_easy_setopt(conn->handle,
2484                                   CURLOPT_FTP_SSL_CCC,
2485                                   CURLFTPSSL_CCC_PASSIVE);
2486         break;
2487
2488     case 2: /* CURLFTPSSL_CCC_ACTIVE */
2489         result = curl_easy_setopt(conn->handle,
2490                                   CURLOPT_FTP_SSL_CCC,
2491                                   CURLFTPSSL_CCC_ACTIVE);
2492         break;
2493
2494     default:
2495         caml_failwith("Invalid FTPSSL_CCC value");
2496         break;
2497     }
2498
2499     if (result != CURLE_OK)
2500         raiseError(conn, result);
2501
2502     CAMLreturn0;
2503 }
2504 #endif
2505
2506 #if HAVE_DECL_CURLOPT_TIMEOUT_MS
2507 SETOPT_LONG( TIMEOUT_MS)
2508 #endif
2509
2510 #if HAVE_DECL_CURLOPT_CONNECTTIMEOUT_MS
2511 SETOPT_LONG( CONNECTTIMEOUT_MS)
2512 #endif
2513
2514 #if HAVE_DECL_CURLOPT_HTTP_TRANSFER_DECODING
2515 SETOPT_BOOL( HTTP_TRANSFER_DECODING)
2516 #endif
2517
2518 #if HAVE_DECL_CURLOPT_HTTP_CONTENT_DECODING
2519 SETOPT_BOOL( HTTP_CONTENT_DECODING)
2520 #endif
2521
2522 #if HAVE_DECL_CURLOPT_NEW_FILE_PERMS
2523 SETOPT_LONG( NEW_FILE_PERMS)
2524 #endif
2525
2526 #if HAVE_DECL_CURLOPT_NEW_DIRECTORY_PERMS
2527 SETOPT_LONG( NEW_DIRECTORY_PERMS)
2528 #endif
2529
2530 #if HAVE_DECL_CURLOPT_POST301
2531 SETOPT_BOOL( POST301)
2532 #endif
2533
2534 #if HAVE_DECL_CURLOPT_SSH_HOST_PUBLIC_KEY_MD5
2535 SETOPT_STRING( SSH_HOST_PUBLIC_KEY_MD5)
2536 #endif
2537
2538 #if HAVE_DECL_CURLOPT_COPYPOSTFIELDS
2539 SETOPT_STRING( COPYPOSTFIELDS)
2540 #endif
2541
2542 #if HAVE_DECL_CURLOPT_PROXY_TRANSFER_MODE
2543 SETOPT_BOOL( PROXY_TRANSFER_MODE)
2544 #endif
2545
2546 #if HAVE_DECL_CURLOPT_AUTOREFERER
2547 SETOPT_BOOL( AUTOREFERER)
2548 #endif
2549
2550 #if HAVE_DECL_CURLOPT_PROXYTYPE
2551 static void handle_PROXYTYPE(Connection *conn, value option)
2552 {
2553     CAMLparam1(option);
2554     CURLcode result = CURLE_OK;
2555     long proxy_type;
2556
2557     switch (Long_val(option))
2558     {
2559       case 0: proxy_type = CURLPROXY_HTTP; break;
2560       case 1: proxy_type = CURLPROXY_HTTP_1_0; break;
2561       case 2: proxy_type = CURLPROXY_SOCKS4; break;
2562       case 3: proxy_type = CURLPROXY_SOCKS5; break;
2563       case 4: proxy_type = CURLPROXY_SOCKS4A; break;
2564       case 5: proxy_type = CURLPROXY_SOCKS5_HOSTNAME; break;
2565       default:
2566         caml_failwith("Invalid curl proxy type");
2567     }
2568
2569     result = curl_easy_setopt(conn->handle,
2570                               CURLOPT_PROXYTYPE,
2571                               proxy_type);
2572
2573     if (result != CURLE_OK)
2574         raiseError(conn, result);
2575
2576     CAMLreturn0;
2577 }
2578 #endif
2579
2580 #if HAVE_DECL_CURLOPT_PROTOCOLS || HAVE_DECL_CURLOPT_REDIR_PROTOCOLS
2581
2582 long protoMap[] =
2583 {
2584   CURLPROTO_ALL,
2585   CURLPROTO_HTTP, CURLPROTO_HTTPS, CURLPROTO_FTP, CURLPROTO_FTPS, CURLPROTO_SCP, CURLPROTO_SFTP,
2586   CURLPROTO_TELNET, CURLPROTO_LDAP, CURLPROTO_LDAPS, CURLPROTO_DICT, CURLPROTO_FILE, CURLPROTO_TFTP,
2587 /* factor out with autoconf? */
2588 #if defined(CURLPROTO_IMAP)
2589   CURLPROTO_IMAP,
2590 #else
2591   0,
2592 #endif
2593 #if defined(CURLPROTO_IMAPS)
2594   CURLPROTO_IMAPS,
2595 #else
2596   0,
2597 #endif
2598 #if defined(CURLPROTO_POP3)
2599   CURLPROTO_POP3,
2600 #else
2601   0,
2602 #endif
2603 #if defined(CURLPROTO_POP3S)
2604   CURLPROTO_POP3S,
2605 #else
2606   0,
2607 #endif
2608 #if defined(CURLPROTO_SMTP)
2609   CURLPROTO_SMTP,
2610 #else
2611   0,
2612 #endif
2613 #if defined(CURLPROTO_SMTPS)
2614   CURLPROTO_SMTPS,
2615 #else
2616   0,
2617 #endif
2618 #if defined(CURLPROTO_RTSP)
2619   CURLPROTO_RTSP,
2620 #else
2621   0,
2622 #endif
2623 #if defined(CURLPROTO_RTMP)
2624   CURLPROTO_RTMP,
2625 #else
2626   0,
2627 #endif
2628 #if defined(CURLPROTO_RTMPT)
2629   CURLPROTO_RTMPT,
2630 #else
2631   0,
2632 #endif
2633 #if defined(CURLPROTO_RTMPE)
2634   CURLPROTO_RTMPE,
2635 #else
2636   0,
2637 #endif
2638 #if defined(CURLPROTO_RTMPTE)
2639   CURLPROTO_RTMPTE,
2640 #else
2641   0,
2642 #endif
2643 #if defined(CURLPROTO_RTMPS)
2644   CURLPROTO_RTMPS,
2645 #else
2646   0,
2647 #endif
2648 #if defined(CURLPROTO_RTMPTS)
2649   CURLPROTO_RTMPTS,
2650 #else
2651   0,
2652 #endif
2653 #if defined(CURLPROTO_GOPHER)
2654   CURLPROTO_GOPHER,
2655 #else
2656   0,
2657 #endif
2658 };
2659
2660 static void handle_PROTOCOLSOPTION(CURLoption curlopt, Connection *conn, value option)
2661 {
2662     CAMLparam1(option);
2663     CURLcode result = CURLE_OK;
2664     long bits = convert_bit_list(protoMap, sizeof(protoMap) / sizeof(protoMap[0]), option);
2665
2666     result = curl_easy_setopt(conn->handle, curlopt, bits);
2667
2668     if (result != CURLE_OK)
2669         raiseError(conn, result);
2670
2671     CAMLreturn0;
2672 }
2673 #endif
2674
2675 #if HAVE_DECL_CURLOPT_PROTOCOLS
2676 static void handle_PROTOCOLS(Connection *conn, value option)
2677 {
2678   handle_PROTOCOLSOPTION(CURLOPT_PROTOCOLS, conn, option);
2679 }
2680 #endif
2681
2682 #if HAVE_DECL_CURLOPT_REDIR_PROTOCOLS
2683 static void handle_REDIR_PROTOCOLS(Connection *conn, value option)
2684 {
2685   handle_PROTOCOLSOPTION(CURLOPT_REDIR_PROTOCOLS, conn, option);
2686 }
2687 #endif
2688
2689 #if HAVE_DECL_CURLOPT_RESOLVE
2690 SETOPT_SLIST( RESOLVE)
2691 #endif
2692
2693 #if HAVE_DECL_CURLOPT_DNS_SERVERS
2694 SETOPT_STRING( DNS_SERVERS)
2695 #endif
2696
2697 #if HAVE_DECL_CURLOPT_MAIL_FROM
2698 SETOPT_STRING( MAIL_FROM)
2699 #endif
2700
2701 #if HAVE_DECL_CURLOPT_MAIL_RCPT
2702 SETOPT_SLIST( MAIL_RCPT)
2703 #endif
2704
2705 #if HAVE_DECL_CURLOPT_PIPEWAIT
2706 SETOPT_BOOL( PIPEWAIT)
2707 #endif
2708
2709 /**
2710  **  curl_easy_setopt helper function
2711  **/
2712
2713 #define MAP(name) { handle_ ## name, "CURLOPT_"#name, Ocaml_##name }
2714 #define MAP_NO(name) { NULL, "CURLOPT_"#name , Ocaml_##name }
2715 #define IMM(name) { handle_ ## name, "CURLOPT_"#name, -1 }
2716 #define IMM_NO(name) { NULL, "CURLOPT_"#name , -1 }
2717
2718 CURLOptionMapping implementedOptionMap[] =
2719 {
2720   MAP(WRITEFUNCTION),
2721   MAP(READFUNCTION),
2722   IMM(INFILESIZE),
2723   MAP(URL),
2724   MAP(PROXY),
2725   IMM(PROXYPORT),
2726   IMM(HTTPPROXYTUNNEL),
2727   IMM(VERBOSE),
2728   IMM(HEADER),
2729   IMM(NOPROGRESS),
2730 #if HAVE_DECL_CURLOPT_NOSIGNAL
2731   IMM(NOSIGNAL),
2732 #else
2733   IMM_NO(NOSIGNAL),
2734 #endif
2735   IMM(NOBODY),
2736   IMM(FAILONERROR),
2737   IMM(UPLOAD),
2738   IMM(POST),
2739   IMM(FTPLISTONLY),
2740   IMM(FTPAPPEND),
2741   IMM(NETRC),
2742 #if HAVE_DECL_CURLOPT_ENCODING
2743   IMM(ENCODING),
2744 #else
2745   IMM_NO(ENCODING),
2746 #endif
2747   IMM(FOLLOWLOCATION),
2748   IMM(TRANSFERTEXT),
2749   IMM(PUT),
2750   MAP(USERPWD),
2751   MAP(PROXYUSERPWD),
2752   MAP(RANGE),
2753   IMM(ERRORBUFFER), /* mutable buffer, as output value, do not duplicate */
2754   IMM(TIMEOUT),
2755   MAP(POSTFIELDS),
2756   IMM(POSTFIELDSIZE),
2757   MAP(REFERER),
2758   MAP(USERAGENT),
2759   MAP(FTPPORT),
2760   IMM(LOW_SPEED_LIMIT),
2761   IMM(LOW_SPEED_TIME),
2762   IMM(RESUME_FROM),
2763   MAP(COOKIE),
2764   MAP(HTTPHEADER),
2765   MAP(HTTPPOST),
2766   MAP(SSLCERT),
2767   MAP(SSLCERTTYPE),
2768   MAP(SSLCERTPASSWD),
2769   MAP(SSLKEY),
2770   MAP(SSLKEYTYPE),
2771   MAP(SSLKEYPASSWD),
2772   MAP(SSLENGINE),
2773   IMM(SSLENGINE_DEFAULT),
2774   IMM(CRLF),
2775   MAP(QUOTE),
2776   MAP(POSTQUOTE),
2777   MAP(HEADERFUNCTION),
2778   MAP(COOKIEFILE),
2779   IMM(SSLVERSION),
2780   IMM(TIMECONDITION),
2781   IMM(TIMEVALUE),
2782   MAP(CUSTOMREQUEST),
2783   MAP(INTERFACE),
2784   IMM(KRB4LEVEL),
2785   MAP(PROGRESSFUNCTION),
2786   IMM(SSL_VERIFYPEER),
2787   MAP(CAINFO),
2788   MAP(CAPATH),
2789   IMM(FILETIME),
2790   IMM(MAXREDIRS),
2791   IMM(MAXCONNECTS),
2792   IMM(CLOSEPOLICY),
2793   IMM(FRESH_CONNECT),
2794   IMM(FORBID_REUSE),
2795   MAP(RANDOM_FILE),
2796   MAP(EGDSOCKET),
2797   IMM(CONNECTTIMEOUT),
2798   IMM(HTTPGET),
2799   IMM(SSL_VERIFYHOST),
2800   MAP(COOKIEJAR),
2801   MAP(SSL_CIPHER_LIST),
2802   IMM(HTTP_VERSION),
2803   IMM(FTP_USE_EPSV),
2804   IMM(DNS_CACHE_TIMEOUT),
2805   IMM(DNS_USE_GLOBAL_CACHE),
2806   MAP(DEBUGFUNCTION),
2807   MAP(PRIVATE),
2808 #if HAVE_DECL_CURLOPT_HTTP200ALIASES
2809   MAP(HTTP200ALIASES),
2810 #else
2811   MAP_NO(HTTP200ALIASES),
2812 #endif
2813 #if HAVE_DECL_CURLOPT_UNRESTRICTED_AUTH
2814   IMM(UNRESTRICTED_AUTH),
2815 #else
2816   IMM_NO(UNRESTRICTED_AUTH),
2817 #endif
2818 #if HAVE_DECL_CURLOPT_FTP_USE_EPRT
2819   IMM(FTP_USE_EPRT),
2820 #else
2821   IMM_NO(FTP_USE_EPRT),
2822 #endif
2823 #if HAVE_DECL_CURLOPT_HTTPAUTH
2824   IMM(HTTPAUTH),
2825 #else
2826   IMM_NO(HTTPAUTH),
2827 #endif
2828 #if HAVE_DECL_CURLOPT_FTP_CREATE_MISSING_DIRS
2829   IMM(FTP_CREATE_MISSING_DIRS),
2830 #else
2831   IMM_NO(FTP_CREATE_MISSING_DIRS),
2832 #endif
2833 #if HAVE_DECL_CURLOPT_PROXYAUTH
2834   IMM(PROXYAUTH),
2835 #else
2836   IMM_NO(PROXYAUTH),
2837 #endif
2838 #if HAVE_DECL_CURLOPT_FTP_RESPONSE_TIMEOUT
2839   IMM(FTP_RESPONSE_TIMEOUT),
2840 #else
2841   IMM_NO(FTP_RESPONSE_TIMEOUT),
2842 #endif
2843 #if HAVE_DECL_CURLOPT_IPRESOLVE
2844   IMM(IPRESOLVE),
2845 #else
2846   IMM_NO(IPRESOLVE),
2847 #endif
2848 #if HAVE_DECL_CURLOPT_MAXFILESIZE
2849   IMM(MAXFILESIZE),
2850 #else
2851   IMM_NO(MAXFILESIZE),
2852 #endif
2853 #if HAVE_DECL_CURLOPT_INFILESIZE_LARGE
2854   IMM(INFILESIZE_LARGE),
2855 #else
2856   IMM_NO(INFILESIZE_LARGE),
2857 #endif
2858 #if HAVE_DECL_CURLOPT_RESUME_FROM_LARGE
2859   IMM(RESUME_FROM_LARGE),
2860 #else
2861   IMM_NO(RESUME_FROM_LARGE),
2862 #endif
2863 #if HAVE_DECL_CURLOPT_MAXFILESIZE_LARGE
2864   IMM(MAXFILESIZE_LARGE),
2865 #else
2866   IMM_NO(MAXFILESIZE_LARGE),
2867 #endif
2868 #if HAVE_DECL_CURLOPT_NETRC_FILE
2869   MAP(NETRC_FILE),
2870 #else
2871   MAP_NO(NETRC_FILE),
2872 #endif
2873 #if HAVE_DECL_CURLOPT_FTP_SSL
2874   IMM(FTP_SSL),
2875 #else
2876   IMM_NO(FTP_SSL),
2877 #endif
2878 #if HAVE_DECL_CURLOPT_POSTFIELDSIZE_LARGE
2879   IMM(POSTFIELDSIZE_LARGE),
2880 #else
2881   IMM_NO(POSTFIELDSIZE_LARGE),
2882 #endif
2883 #if HAVE_DECL_CURLOPT_TCP_NODELAY
2884   IMM(TCP_NODELAY),
2885 #else
2886   IMM_NO(TCP_NODELAY),
2887 #endif
2888 #if HAVE_DECL_CURLOPT_FTPSSLAUTH
2889   IMM(FTPSSLAUTH),
2890 #else
2891   IMM_NO(FTPSSLAUTH),
2892 #endif
2893 #if HAVE_DECL_CURLOPT_IOCTLFUNCTION
2894   MAP(IOCTLFUNCTION),
2895 #else
2896   MAP_NO(IOCTLFUNCTION),
2897 #endif
2898 #if HAVE_DECL_CURLOPT_FTP_ACCOUNT
2899   MAP(FTP_ACCOUNT),
2900 #else
2901   MAP_NO(FTP_ACCOUNT),
2902 #endif
2903 #if HAVE_DECL_CURLOPT_COOKIELIST
2904   MAP(COOKIELIST),
2905 #else
2906   MAP_NO(COOKIELIST),
2907 #endif
2908 #if HAVE_DECL_CURLOPT_IGNORE_CONTENT_LENGTH
2909   IMM(IGNORE_CONTENT_LENGTH),
2910 #else
2911   IMM_NO(IGNORE_CONTENT_LENGTH),
2912 #endif
2913 #if HAVE_DECL_CURLOPT_FTP_SKIP_PASV_IP
2914   IMM(FTP_SKIP_PASV_IP),
2915 #else
2916   IMM_NO(FTP_SKIP_PASV_IP),
2917 #endif
2918 #if HAVE_DECL_CURLOPT_FTP_FILEMETHOD
2919   IMM(FTP_FILEMETHOD),
2920 #else
2921   IMM_NO(FTP_FILEMETHOD),
2922 #endif
2923 #if HAVE_DECL_CURLOPT_LOCALPORT
2924   IMM(LOCALPORT),
2925 #else
2926   IMM_NO(LOCALPORT),
2927 #endif
2928 #if HAVE_DECL_CURLOPT_LOCALPORTRANGE
2929   IMM(LOCALPORTRANGE),
2930 #else
2931   IMM_NO(LOCALPORTRANGE),
2932 #endif
2933 #if HAVE_DECL_CURLOPT_CONNECT_ONLY
2934   IMM(CONNECT_ONLY),
2935 #else
2936   IMM_NO(CONNECT_ONLY),
2937 #endif
2938 #if HAVE_DECL_CURLOPT_MAX_SEND_SPEED_LARGE
2939   IMM(MAX_SEND_SPEED_LARGE),
2940 #else
2941   IMM_NO(MAX_SEND_SPEED_LARGE),
2942 #endif
2943 #if HAVE_DECL_CURLOPT_MAX_RECV_SPEED_LARGE
2944   IMM(MAX_RECV_SPEED_LARGE),
2945 #else
2946   IMM_NO(MAX_RECV_SPEED_LARGE),
2947 #endif
2948 #if HAVE_DECL_CURLOPT_FTP_ALTERNATIVE_TO_USER
2949   MAP(FTP_ALTERNATIVE_TO_USER),
2950 #else
2951   MAP_NO(FTP_ALTERNATIVE_TO_USER),
2952 #endif
2953 #if HAVE_DECL_CURLOPT_SSL_SESSIONID_CACHE
2954   IMM(SSL_SESSIONID_CACHE),
2955 #else
2956   IMM_NO(SSL_SESSIONID_CACHE),
2957 #endif
2958 #if HAVE_DECL_CURLOPT_SSH_AUTH_TYPES
2959   IMM(SSH_AUTH_TYPES),
2960 #else
2961   IMM_NO(SSH_AUTH_TYPES),
2962 #endif
2963 #if HAVE_DECL_CURLOPT_SSH_PUBLIC_KEYFILE
2964   MAP(SSH_PUBLIC_KEYFILE),
2965 #else
2966   MAP_NO(SSH_PUBLIC_KEYFILE),
2967 #endif
2968 #if HAVE_DECL_CURLOPT_SSH_PRIVATE_KEYFILE
2969   MAP(SSH_PRIVATE_KEYFILE),
2970 #else
2971   MAP_NO(SSH_PRIVATE_KEYFILE),
2972 #endif
2973 #if HAVE_DECL_CURLOPT_FTP_SSL_CCC
2974   IMM(FTP_SSL_CCC),
2975 #else
2976   IMM_NO(FTP_SSL_CCC),
2977 #endif
2978 #if HAVE_DECL_CURLOPT_TIMEOUT_MS
2979   IMM(TIMEOUT_MS),
2980 #else
2981   IMM_NO(TIMEOUT_MS),
2982 #endif
2983 #if HAVE_DECL_CURLOPT_CONNECTTIMEOUT_MS
2984   IMM(CONNECTTIMEOUT_MS),
2985 #else
2986   IMM_NO(CONNECTTIMEOUT_MS),
2987 #endif
2988 #if HAVE_DECL_CURLOPT_HTTP_TRANSFER_DECODING
2989   IMM(HTTP_TRANSFER_DECODING),
2990 #else
2991   IMM_NO(HTTP_TRANSFER_DECODING),
2992 #endif
2993 #if HAVE_DECL_CURLOPT_HTTP_CONTENT_DECODING
2994   IMM(HTTP_CONTENT_DECODING),
2995 #else
2996   IMM_NO(HTTP_CONTENT_DECODING),
2997 #endif
2998 #if HAVE_DECL_CURLOPT_NEW_FILE_PERMS
2999   IMM(NEW_FILE_PERMS),
3000 #else
3001   IMM_NO(NEW_FILE_PERMS),
3002 #endif
3003 #if HAVE_DECL_CURLOPT_NEW_DIRECTORY_PERMS
3004   IMM(NEW_DIRECTORY_PERMS),
3005 #else
3006   IMM_NO(NEW_DIRECTORY_PERMS),
3007 #endif
3008 #if HAVE_DECL_CURLOPT_POST301
3009   IMM(POST301),
3010 #else
3011   IMM_NO(POST301),
3012 #endif
3013 #if HAVE_DECL_CURLOPT_SSH_HOST_PUBLIC_KEY_MD5
3014   MAP(SSH_HOST_PUBLIC_KEY_MD5),
3015 #else
3016   MAP_NO(SSH_HOST_PUBLIC_KEY_MD5),
3017 #endif
3018 #if HAVE_DECL_CURLOPT_COPYPOSTFIELDS
3019   MAP(COPYPOSTFIELDS),
3020 #else
3021   MAP_NO(COPYPOSTFIELDS),
3022 #endif
3023 #if HAVE_DECL_CURLOPT_PROXY_TRANSFER_MODE
3024   IMM(PROXY_TRANSFER_MODE),
3025 #else
3026   IMM_NO(PROXY_TRANSFER_MODE),
3027 #endif
3028 #if HAVE_DECL_CURLOPT_SEEKFUNCTION
3029   MAP(SEEKFUNCTION),
3030 #else
3031   MAP_NO(SEEKFUNCTION),
3032 #endif
3033 #if HAVE_DECL_CURLOPT_AUTOREFERER
3034   IMM(AUTOREFERER),
3035 #else
3036   IMM_NO(AUTOREFERER),
3037 #endif
3038 #if HAVE_DECL_CURLOPT_OPENSOCKETFUNCTION
3039   MAP(OPENSOCKETFUNCTION),
3040 #else
3041   MAP_NO(OPENSOCKETFUNCTION),
3042 #endif
3043 #if HAVE_DECL_CURLOPT_PROXYTYPE
3044   IMM(PROXYTYPE),
3045 #else
3046   IMM_NO(PROXYTYPE),
3047 #endif
3048 #if HAVE_DECL_CURLOPT_PROTOCOLS
3049   IMM(PROTOCOLS),
3050 #else
3051   IMM_NO(PROTOCOLS),
3052 #endif
3053 #if HAVE_DECL_CURLOPT_REDIR_PROTOCOLS
3054   IMM(REDIR_PROTOCOLS),
3055 #else
3056   IMM_NO(REDIR_PROTOCOLS),
3057 #endif
3058 #if HAVE_DECL_CURLOPT_RESOLVE
3059   MAP(RESOLVE),
3060 #else
3061   MAP_NO(RESOLVE),
3062 #endif
3063 #if HAVE_DECL_CURLOPT_DNS_SERVERS
3064   MAP(DNS_SERVERS),
3065 #else
3066   MAP_NO(DNS_SERVERS),
3067 #endif
3068 #if HAVE_DECL_CURLOPT_MAIL_FROM
3069   MAP(MAIL_FROM),
3070 #else
3071   MAP_NO(MAIL_FROM),
3072 #endif
3073 #if HAVE_DECL_CURLOPT_MAIL_RCPT
3074   MAP(MAIL_RCPT),
3075 #else
3076   MAP_NO(MAIL_RCPT),
3077 #endif
3078 #if HAVE_DECL_CURLOPT_PIPEWAIT
3079   IMM(PIPEWAIT),
3080 #else
3081   IMM_NO(PIPEWAIT),
3082 #endif
3083 #if HAVE_DECL_CURLOPT_CERTINFO
3084   IMM(CERTINFO),
3085 #else
3086   IMM_NO(CERTINFO),
3087 #endif
3088 };
3089
3090 static Connection *duplicateConnection(Connection *original)
3091 {
3092     Connection *connection = NULL;
3093     CURL* h = NULL;
3094     size_t i = 0;
3095     CURLOptionMapping* this = NULL;
3096
3097     caml_enter_blocking_section();
3098     h  = curl_easy_duphandle(original->handle);
3099     caml_leave_blocking_section();
3100
3101     connection = allocConnection(h);
3102
3103     for (i = 0; i < sizeof(implementedOptionMap)/sizeof(CURLOptionMapping); i++)
3104     {
3105       this = &implementedOptionMap[i];
3106       if (-1 == this->ocamlValue) continue;
3107       if (this->optionHandler && (Field(original->ocamlValues, this->ocamlValue) != Val_unit))
3108       {
3109         this->optionHandler(connection, Field(original->ocamlValues, this->ocamlValue));
3110       }
3111     }
3112
3113     return connection;
3114 }
3115
3116 CAMLprim value helper_curl_easy_setopt(value conn, value option)
3117 {
3118     CAMLparam2(conn, option);
3119     CAMLlocal1(data);
3120     Connection *connection = Connection_val(conn);
3121     CURLOptionMapping* thisOption = NULL;
3122     static value* exception = NULL;
3123
3124     checkConnection(connection);
3125
3126     data = Field(option, 0);
3127
3128     if (Tag_val(option) < sizeof(implementedOptionMap)/sizeof(CURLOptionMapping))
3129     {
3130       thisOption = &implementedOptionMap[Tag_val(option)];
3131       if (thisOption->optionHandler)
3132       {
3133         thisOption->optionHandler(connection, data);
3134       }
3135       else
3136       {
3137         if (NULL == exception)
3138         {
3139           exception = caml_named_value("Curl.NotImplemented");
3140           if (NULL == exception) caml_invalid_argument("Curl.NotImplemented");
3141         }
3142
3143         caml_raise_with_string(*exception, thisOption->name);
3144       }
3145     }
3146     else
3147     {
3148       caml_failwith("Invalid CURLOPT Option");
3149     }
3150
3151     CAMLreturn(Val_unit);
3152 }
3153
3154 /**
3155  **  curl_easy_perform helper function
3156  **/
3157
3158 CAMLprim value helper_curl_easy_perform(value conn)
3159 {
3160     CAMLparam1(conn);
3161     CURLcode result = CURLE_OK;
3162     Connection *connection = Connection_val(conn);
3163
3164     checkConnection(connection);
3165
3166     caml_enter_blocking_section();
3167     result = curl_easy_perform(connection->handle);
3168     caml_leave_blocking_section();
3169
3170     if (result != CURLE_OK)
3171         raiseError(connection, result);
3172
3173     CAMLreturn(Val_unit);
3174 }
3175
3176 /**
3177  **  curl_easy_cleanup helper function
3178  **/
3179
3180 CAMLprim value helper_curl_easy_cleanup(value conn)
3181 {
3182     CAMLparam1(conn);
3183     Connection *connection = Connection_val(conn);
3184
3185     checkConnection(connection);
3186
3187     removeConnection(connection, 0);
3188
3189     CAMLreturn(Val_unit);
3190 }
3191
3192 /**
3193  **  curl_easy_duphandle helper function
3194  **/
3195
3196 CAMLprim value helper_curl_easy_duphandle(value conn)
3197 {
3198     CAMLparam1(conn);
3199     CAMLlocal1(result);
3200     Connection *connection = Connection_val(conn);
3201
3202     checkConnection(connection);
3203
3204     result = caml_curl_alloc(duplicateConnection(connection));
3205
3206     CAMLreturn(result);
3207 }
3208
3209 /**
3210  **  curl_easy_getinfo helper function
3211  **/
3212
3213 enum GetInfoResultType {
3214     StringValue, LongValue, DoubleValue, StringListValue, StringListListValue,
3215     OCamlValue, /* keep last - no matching OCaml CURLINFO_ constructor */
3216 };
3217
3218 value convertStringList(struct curl_slist *p)
3219 {
3220     CAMLparam0();
3221     CAMLlocal3(result, current, next);
3222
3223     result = Val_emptylist;
3224     current = Val_emptylist;
3225     next = Val_emptylist;
3226
3227     while (p != NULL)
3228     {
3229         next = caml_alloc_tuple(2);
3230         Store_field(next, 0, caml_copy_string(p->data));
3231         Store_field(next, 1, Val_emptylist);
3232
3233         if (result == Val_emptylist)
3234             result = next;
3235
3236         if (current != Val_emptylist)
3237           Store_field(current, 1, next);
3238
3239         current = next;
3240
3241         p = p->next;
3242     }
3243
3244     CAMLreturn(result);
3245 }
3246
3247 CAMLprim value helper_curl_easy_getinfo(value conn, value option)
3248 {
3249     CAMLparam2(conn, option);
3250     CAMLlocal3(result, current, next);
3251     CURLcode curlResult;
3252     Connection *connection = Connection_val(conn);
3253     enum GetInfoResultType resultType;
3254     char *strValue = NULL;
3255     double doubleValue;
3256     long longValue;
3257     struct curl_slist *stringListValue = NULL;
3258 #if HAVE_DECL_CURLINFO_CERTINFO
3259     int i;
3260     union {
3261       struct curl_slist    *to_info;
3262       struct curl_certinfo *to_certinfo;
3263     } ptr;
3264 #endif
3265
3266     checkConnection(connection);
3267
3268     switch(Long_val(option))
3269     {
3270 #if HAVE_DECL_CURLINFO_EFFECTIVE_URL
3271     case 0: /* CURLINFO_EFFECTIVE_URL */
3272         resultType = StringValue;
3273
3274         curlResult = curl_easy_getinfo(connection->handle,
3275                                        CURLINFO_EFFECTIVE_URL,
3276                                        &strValue);
3277         break;
3278 #else
3279 #pragma message("libcurl does not provide CURLINFO_EFFECTIVE_URL")
3280 #endif
3281
3282 #if HAVE_DECL_CURLINFO_RESPONSE_CODE || HAVE_DECL_CURLINFO_HTTP_CODE
3283     case 1: /* CURLINFO_HTTP_CODE */
3284     case 2: /* CURLINFO_RESPONSE_CODE */
3285 #if HAVE_DECL_CURLINFO_RESPONSE_CODE
3286         resultType = LongValue;
3287
3288         curlResult = curl_easy_getinfo(connection->handle,
3289                                        CURLINFO_RESPONSE_CODE,
3290                                        &longValue);
3291 #else
3292         resultType = LongValue;
3293
3294         curlResult = curl_easy_getinfo(connection->handle,
3295                                        CURLINFO_HTTP_CODE,
3296                                        &longValue);
3297 #endif
3298         break;
3299 #endif
3300
3301 #if HAVE_DECL_CURLINFO_TOTAL_TIME
3302     case 3: /* CURLINFO_TOTAL_TIME */
3303         resultType = DoubleValue;
3304
3305         curlResult = curl_easy_getinfo(connection->handle,
3306                                        CURLINFO_TOTAL_TIME,
3307                                        &doubleValue);
3308         break;
3309 #endif
3310
3311 #if HAVE_DECL_CURLINFO_NAMELOOKUP_TIME
3312     case 4: /* CURLINFO_NAMELOOKUP_TIME */
3313         resultType = DoubleValue;
3314
3315         curlResult = curl_easy_getinfo(connection->handle,
3316                                        CURLINFO_NAMELOOKUP_TIME,
3317                                        &doubleValue);
3318         break;
3319 #endif
3320
3321 #if HAVE_DECL_CURLINFO_CONNECT_TIME
3322     case 5: /* CURLINFO_CONNECT_TIME */
3323         resultType = DoubleValue;
3324
3325         curlResult = curl_easy_getinfo(connection->handle,
3326                                        CURLINFO_CONNECT_TIME,
3327                                        &doubleValue);
3328         break;
3329 #endif
3330
3331 #if HAVE_DECL_CURLINFO_PRETRANSFER_TIME
3332     case 6: /* CURLINFO_PRETRANSFER_TIME */
3333         resultType = DoubleValue;
3334
3335         curlResult = curl_easy_getinfo(connection->handle,
3336                                        CURLINFO_PRETRANSFER_TIME,
3337                                        &doubleValue);
3338         break;
3339 #endif
3340
3341 #if HAVE_DECL_CURLINFO_SIZE_UPLOAD
3342     case 7: /* CURLINFO_SIZE_UPLOAD */
3343         resultType = DoubleValue;
3344
3345         curlResult = curl_easy_getinfo(connection->handle,
3346                                        CURLINFO_SIZE_UPLOAD,
3347                                        &doubleValue);
3348         break;
3349 #endif
3350
3351 #if HAVE_DECL_CURLINFO_SIZE_DOWNLOAD
3352     case 8: /* CURLINFO_SIZE_DOWNLOAD */
3353         resultType = DoubleValue;
3354
3355         curlResult = curl_easy_getinfo(connection->handle,
3356                                        CURLINFO_SIZE_DOWNLOAD,
3357                                        &doubleValue);
3358         break;
3359 #endif
3360
3361 #if HAVE_DECL_CURLINFO_SPEED_DOWNLOAD
3362     case 9: /* CURLINFO_SPEED_DOWNLOAD */
3363         resultType = DoubleValue;
3364
3365         curlResult = curl_easy_getinfo(connection->handle,
3366                                        CURLINFO_SPEED_DOWNLOAD,
3367                                        &doubleValue);
3368         break;
3369 #endif
3370
3371 #if HAVE_DECL_CURLINFO_SPEED_UPLOAD
3372     case 10: /* CURLINFO_SPEED_UPLOAD */
3373         resultType = DoubleValue;
3374
3375         curlResult = curl_easy_getinfo(connection->handle,
3376                                        CURLINFO_SPEED_UPLOAD,
3377                                        &doubleValue);
3378         break;
3379
3380 #endif
3381
3382 #if HAVE_DECL_CURLINFO_HEADER_SIZE
3383     case 11: /* CURLINFO_HEADER_SIZE */
3384         resultType = LongValue;
3385
3386         curlResult = curl_easy_getinfo(connection->handle,
3387                                        CURLINFO_HEADER_SIZE,
3388                                        &longValue);
3389         break;
3390 #endif
3391
3392 #if HAVE_DECL_CURLINFO_REQUEST_SIZE
3393     case 12: /* CURLINFO_REQUEST_SIZE */
3394         resultType = LongValue;
3395
3396         curlResult = curl_easy_getinfo(connection->handle,
3397                                        CURLINFO_REQUEST_SIZE,
3398                                        &longValue);
3399         break;
3400 #endif
3401
3402 #if HAVE_DECL_CURLINFO_SSL_VERIFYRESULT
3403     case 13: /* CURLINFO_SSL_VERIFYRESULT */
3404         resultType = LongValue;
3405
3406         curlResult = curl_easy_getinfo(connection->handle,
3407                                        CURLINFO_SSL_VERIFYRESULT,
3408                                        &longValue);
3409         break;
3410 #endif
3411
3412 #if HAVE_DECL_CURLINFO_FILETIME
3413     case 14: /* CURLINFO_FILETIME */
3414         resultType = DoubleValue;
3415
3416         curlResult = curl_easy_getinfo(connection->handle,
3417                                        CURLINFO_FILETIME,
3418                                        &longValue);
3419
3420         doubleValue = longValue;
3421         break;
3422 #endif
3423
3424 #if HAVE_DECL_CURLINFO_CONTENT_LENGTH_DOWNLOAD
3425     case 15: /* CURLINFO_CONTENT_LENGTH_DOWNLOAD */
3426         resultType = DoubleValue;
3427
3428         curlResult = curl_easy_getinfo(connection->handle,
3429                                        CURLINFO_CONTENT_LENGTH_DOWNLOAD,
3430                                        &doubleValue);
3431         break;
3432 #endif
3433
3434 #if HAVE_DECL_CURLINFO_CONTENT_LENGTH_UPLOAD
3435     case 16: /* CURLINFO_CONTENT_LENGTH_UPLOAD */
3436         resultType = DoubleValue;
3437
3438         curlResult = curl_easy_getinfo(connection->handle,
3439                                        CURLINFO_CONTENT_LENGTH_UPLOAD,
3440                                        &doubleValue);
3441         break;
3442 #endif
3443
3444 #if HAVE_DECL_CURLINFO_STARTTRANSFER_TIME
3445     case 17: /* CURLINFO_STARTTRANSFER_TIME */
3446         resultType = DoubleValue;
3447
3448         curlResult = curl_easy_getinfo(connection->handle,
3449                                        CURLINFO_STARTTRANSFER_TIME,
3450                                        &doubleValue);
3451         break;
3452 #endif
3453
3454 #if HAVE_DECL_CURLINFO_CONTENT_TYPE
3455     case 18: /* CURLINFO_CONTENT_TYPE */
3456         resultType = StringValue;
3457
3458         curlResult = curl_easy_getinfo(connection->handle,
3459                                        CURLINFO_CONTENT_TYPE,
3460                                        &strValue);
3461         break;
3462 #endif
3463
3464 #if HAVE_DECL_CURLINFO_REDIRECT_TIME
3465     case 19: /* CURLINFO_REDIRECT_TIME */
3466         resultType = DoubleValue;
3467
3468         curlResult = curl_easy_getinfo(connection->handle,
3469                                        CURLINFO_REDIRECT_TIME,
3470                                        &doubleValue);
3471         break;
3472 #endif
3473
3474 #if HAVE_DECL_CURLINFO_REDIRECT_COUNT
3475     case 20: /* CURLINFO_REDIRECT_COUNT */
3476         resultType = LongValue;
3477
3478         curlResult = curl_easy_getinfo(connection->handle,
3479                                        CURLINFO_REDIRECT_COUNT,
3480                                        &longValue);
3481         break;
3482 #endif
3483
3484     case 21: /* CURLINFO_PRIVATE */
3485         resultType = OCamlValue;
3486         curlResult = CURLE_OK;
3487         result = caml_alloc(1, StringValue);
3488         Store_field(result, 0, Field(connection->ocamlValues, Ocaml_PRIVATE));
3489         break;
3490
3491 #if HAVE_DECL_CURLINFO_HTTP_CONNECTCODE
3492     case 22: /* CURLINFO_HTTP_CONNECTCODE */
3493         resultType = LongValue;
3494
3495         curlResult = curl_easy_getinfo(connection->handle,
3496                                        CURLINFO_HTTP_CONNECTCODE,
3497                                        &longValue);
3498         break;
3499 #endif
3500
3501 #if HAVE_DECL_CURLINFO_HTTPAUTH_AVAIL
3502     case 23: /* CURLINFO_HTTPAUTH_AVAIL */
3503         resultType = LongValue;
3504
3505         curlResult = curl_easy_getinfo(connection->handle,
3506                                        CURLINFO_HTTPAUTH_AVAIL,
3507                                        &longValue);
3508         break;
3509 #endif
3510
3511 #if HAVE_DECL_CURLINFO_PROXYAUTH_AVAIL
3512     case 24: /* CURLINFO_PROXYAUTH_AVAIL */
3513         resultType = LongValue;
3514
3515         curlResult = curl_easy_getinfo(connection->handle,
3516                                        CURLINFO_PROXYAUTH_AVAIL,
3517                                        &longValue);
3518         break;
3519 #endif
3520
3521 #if HAVE_DECL_CURLINFO_OS_ERRNO
3522     case 25: /* CURLINFO_OS_ERRNO */
3523         resultType = LongValue;
3524
3525         curlResult = curl_easy_getinfo(connection->handle,
3526                                        CURLINFO_OS_ERRNO,
3527                                        &longValue);
3528         break;
3529 #endif
3530
3531 #if HAVE_DECL_CURLINFO_NUM_CONNECTS
3532     case 26: /* CURLINFO_NUM_CONNECTS */
3533         resultType = LongValue;
3534
3535         curlResult = curl_easy_getinfo(connection->handle,
3536                                        CURLINFO_NUM_CONNECTS,
3537                                        &longValue);
3538         break;
3539 #endif
3540
3541 #if HAVE_DECL_CURLINFO_SSL_ENGINES
3542     case 27: /* CURLINFO_SSL_ENGINES */
3543         resultType = StringListValue;
3544
3545         curlResult = curl_easy_getinfo(connection->handle,
3546                                        CURLINFO_SSL_ENGINES,
3547                                        &stringListValue);
3548         break;
3549 #endif
3550
3551 #if HAVE_DECL_CURLINFO_COOKIELIST
3552     case 28: /* CURLINFO_COOKIELIST */
3553         resultType = StringListValue;
3554
3555         curlResult = curl_easy_getinfo(connection->handle,
3556                                        CURLINFO_COOKIELIST,
3557                                        &stringListValue);
3558         break;
3559 #endif
3560
3561 #if HAVE_DECL_CURLINFO_LASTSOCKET
3562     case 29: /* CURLINFO_LASTSOCKET */
3563         resultType = LongValue;
3564
3565         curlResult = curl_easy_getinfo(connection->handle,
3566                                        CURLINFO_LASTSOCKET,
3567                                        &longValue);
3568         break;
3569 #endif
3570
3571 #if HAVE_DECL_CURLINFO_FTP_ENTRY_PATH
3572     case 30: /* CURLINFO_FTP_ENTRY_PATH */
3573         resultType = StringValue;
3574
3575         curlResult = curl_easy_getinfo(connection->handle,
3576                                        CURLINFO_FTP_ENTRY_PATH,
3577                                        &strValue);
3578         break;
3579 #endif
3580
3581 #if HAVE_DECL_CURLINFO_REDIRECT_URL
3582     case 31: /* CURLINFO_REDIRECT_URL */
3583         resultType = StringValue;
3584
3585         curlResult = curl_easy_getinfo(connection->handle,
3586                                        CURLINFO_REDIRECT_URL,
3587                                        &strValue);
3588         break;
3589 #else
3590 #pragma message("libcurl does not provide CURLINFO_REDIRECT_URL")
3591 #endif
3592
3593 #if HAVE_DECL_CURLINFO_PRIMARY_IP
3594     case 32: /* CURLINFO_PRIMARY_IP */
3595         resultType = StringValue;
3596
3597         curlResult = curl_easy_getinfo(connection->handle,
3598                                        CURLINFO_PRIMARY_IP,
3599                                        &strValue);
3600         break;
3601 #else
3602 #pragma message("libcurl does not provide CURLINFO_PRIMARY_IP")
3603 #endif
3604
3605 #if HAVE_DECL_CURLINFO_LOCAL_IP
3606     case 33: /* CURLINFO_LOCAL_IP */
3607         resultType = StringValue;
3608
3609         curlResult = curl_easy_getinfo(connection->handle,
3610                                        CURLINFO_LOCAL_IP,
3611                                        &strValue);
3612         break;
3613 #else
3614 #pragma message("libcurl does not provide CURLINFO_LOCAL_IP")
3615 #endif
3616
3617 #if HAVE_DECL_CURLINFO_LOCAL_PORT
3618     case 34: /* CURLINFO_LOCAL_PORT */
3619         resultType = LongValue;
3620
3621         curlResult = curl_easy_getinfo(connection->handle,
3622                                        CURLINFO_LOCAL_PORT,
3623                                        &longValue);
3624         break;
3625 #else
3626 #pragma message("libcurl does not provide CURLINFO_LOCAL_PORT")
3627 #endif
3628
3629 #if HAVE_DECL_CURLINFO_CONDITION_UNMET
3630     case 35: /* CURLINFO_CONDITION_UNMET */
3631         resultType = LongValue;
3632
3633         curlResult = curl_easy_getinfo(connection->handle,
3634                                        CURLINFO_CONDITION_UNMET,
3635                                        &longValue);
3636         break;
3637 #else
3638 #pragma message("libcurl does not provide CURLINFO_CONDITION_UNMET")
3639 #endif
3640 #if HAVE_DECL_CURLINFO_CERTINFO
3641     case 36: /* CURLINFO_CERTINFO */
3642         resultType = StringListListValue;
3643         ptr.to_info = NULL;
3644         curlResult = curl_easy_getinfo(connection->handle,
3645                                        CURLINFO_CERTINFO,
3646                                        &ptr.to_info);
3647
3648         result = Val_emptylist;
3649         current = Val_emptylist;
3650         next = Val_emptylist;
3651
3652         if (curlResult != CURLE_OK || !ptr.to_info)
3653           break;
3654
3655         for (i = 0; i < ptr.to_certinfo->num_of_certs; i++) {
3656           next = caml_alloc_tuple(2);
3657           Store_field(next, 0, convertStringList(ptr.to_certinfo->certinfo[i]));
3658           Store_field(next, 1, current);
3659           current = next;
3660         }
3661         break;
3662 #else
3663 #pragma message("libcurl does not provide CURLINFO_CERTINFO")
3664 #endif
3665     default:
3666         caml_failwith("Invalid CURLINFO Option");
3667         break;
3668     }
3669
3670     if (curlResult != CURLE_OK)
3671         raiseError(connection, curlResult);
3672
3673     switch (resultType)
3674     {
3675     case StringValue:
3676         result = caml_alloc(1, StringValue);
3677         Store_field(result, 0, caml_copy_string(strValue?strValue:""));
3678         break;
3679
3680     case LongValue:
3681         result = caml_alloc(1, LongValue);
3682         Store_field(result, 0, Val_long(longValue));
3683         break;
3684
3685     case DoubleValue:
3686         result = caml_alloc(1, DoubleValue);
3687         Store_field(result, 0, caml_copy_double(doubleValue));
3688         break;
3689
3690     case StringListValue:
3691         result = caml_alloc(1, StringListValue);
3692         Store_field(result, 0, convertStringList(stringListValue));
3693         curl_slist_free_all(stringListValue);
3694         break;
3695
3696     case StringListListValue:
3697         result = caml_alloc(1, StringListListValue);
3698         Store_field(result, 0, current);
3699         break;
3700
3701     case OCamlValue:
3702         break;
3703     }
3704
3705     CAMLreturn(result);
3706 }
3707
3708 /**
3709  **  curl_escape helper function
3710  **/
3711
3712 CAMLprim value helper_curl_escape(value str)
3713 {
3714     CAMLparam1(str);
3715     CAMLlocal1(result);
3716     char *curlResult;
3717
3718     curlResult = curl_escape(String_val(str), caml_string_length(str));
3719     result = caml_copy_string(curlResult);
3720     free(curlResult);
3721
3722     CAMLreturn(result);
3723 }
3724
3725 /**
3726  **  curl_unescape helper function
3727  **/
3728
3729 CAMLprim value helper_curl_unescape(value str)
3730 {
3731     CAMLparam1(str);
3732     CAMLlocal1(result);
3733     char *curlResult;
3734
3735     curlResult = curl_unescape(String_val(str), caml_string_length(str));
3736     result = caml_copy_string(curlResult);
3737     free(curlResult);
3738
3739     CAMLreturn(result);
3740 }
3741
3742 /**
3743  **  curl_getdate helper function
3744  **/
3745
3746 CAMLprim value helper_curl_getdate(value str, value now)
3747 {
3748     CAMLparam2(str, now);
3749     CAMLlocal1(result);
3750     time_t curlResult;
3751     time_t curlNow;
3752
3753     curlNow = (time_t)Double_val(now);
3754     curlResult = curl_getdate(String_val(str), &curlNow);
3755     result = caml_copy_double((double)curlResult);
3756
3757     CAMLreturn(result);
3758 }
3759
3760 /**
3761  **  curl_version helper function
3762  **/
3763
3764 CAMLprim value helper_curl_version(void)
3765 {
3766     CAMLparam0();
3767     CAMLlocal1(result);
3768     char *str;
3769
3770     str = curl_version();
3771     result = caml_copy_string(str);
3772
3773     CAMLreturn(result);
3774 }
3775
3776 struct CURLVersionBitsMapping
3777 {
3778     int code;
3779     char *name;
3780 };
3781
3782 struct CURLVersionBitsMapping versionBitsMap[] =
3783 {
3784     {CURL_VERSION_IPV6, "ipv6"},
3785     {CURL_VERSION_KERBEROS4, "kerberos4"},
3786     {CURL_VERSION_SSL, "ssl"},
3787     {CURL_VERSION_LIBZ, "libz"},
3788     {CURL_VERSION_NTLM, "ntlm"},
3789     {CURL_VERSION_GSSNEGOTIATE, "gssnegotiate"},
3790     {CURL_VERSION_DEBUG, "debug"},
3791     {CURL_VERSION_CURLDEBUG, "curldebug"},
3792     {CURL_VERSION_ASYNCHDNS, "asynchdns"},
3793     {CURL_VERSION_SPNEGO, "spnego"},
3794     {CURL_VERSION_LARGEFILE, "largefile"},
3795     {CURL_VERSION_IDN, "idn"},
3796     {CURL_VERSION_SSPI, "sspi"},
3797     {CURL_VERSION_CONV, "conv"},
3798 #if HAVE_DECL_CURL_VERSION_TLSAUTH_SRP
3799     {CURL_VERSION_TLSAUTH_SRP, "srp"},
3800 #endif
3801 #if HAVE_DECL_CURL_VERSION_NTLM_WB
3802     {CURL_VERSION_NTLM_WB, "wb"},
3803 #endif
3804 };
3805
3806 CAMLprim value caml_curl_version_info(value unit)
3807 {
3808   CAMLparam1(unit);
3809   CAMLlocal4(v, vlist, vnum, vfeatures);
3810   const char* const* p = NULL;
3811   size_t i = 0;
3812
3813   curl_version_info_data* data = curl_version_info(CURLVERSION_NOW);
3814   if (NULL == data) caml_failwith("curl_version_info");
3815
3816   vlist = Val_emptylist;
3817   for (p = data->protocols; NULL != *p; p++)
3818   {
3819     vlist = Val_cons(vlist, caml_copy_string(*p));
3820   }
3821
3822   vfeatures = Val_emptylist;
3823   for (i = 0; i < sizeof(versionBitsMap)/sizeof(versionBitsMap[0]); i++)
3824   {
3825     if (0 != (versionBitsMap[i].code & data->features))
3826       vfeatures = Val_cons(vfeatures, caml_copy_string(versionBitsMap[i].name));
3827   }
3828
3829   vnum = caml_alloc_tuple(3);
3830   Store_field(vnum,0,Val_int(0xFF & (data->version_num >> 16)));
3831   Store_field(vnum,1,Val_int(0xFF & (data->version_num >> 8)));
3832   Store_field(vnum,2,Val_int(0xFF & (data->version_num)));
3833
3834   v = caml_alloc_tuple(12);
3835   Store_field(v,0,caml_copy_string(data->version));
3836   Store_field(v,1,vnum);
3837   Store_field(v,2,caml_copy_string(data->host));
3838   Store_field(v,3,vfeatures);
3839   Store_field(v,4,data->ssl_version ? Val_some(caml_copy_string(data->ssl_version)) : Val_none);
3840   Store_field(v,5,data->libz_version ? Val_some(caml_copy_string(data->libz_version)) : Val_none);
3841   Store_field(v,6,vlist);
3842   Store_field(v,7,caml_copy_string((data->age >= 1 && data->ares) ? data->ares : ""));
3843   Store_field(v,8,Val_int((data->age >= 1) ? data->ares_num : 0));
3844   Store_field(v,9,caml_copy_string((data->age >= 2 && data->libidn) ? data->libidn : ""));
3845   Store_field(v,10,Val_int((data->age >= 3) ? data->iconv_ver_num : 0));
3846   Store_field(v,11,caml_copy_string((data->age >= 3 && data->libssh_version) ? data->libssh_version : ""));
3847
3848   CAMLreturn(v);
3849 }
3850
3851 CAMLprim value caml_curl_pause(value conn, value opts)
3852 {
3853   CAMLparam2(conn, opts);
3854   CAMLlocal4(v, vlist, vnum, vfeatures);
3855   Connection *connection = Connection_val(conn);
3856   int bitmask = 0;
3857   CURLcode result;
3858
3859   while (Val_emptylist != opts)
3860   {
3861     switch (Int_val(Field(opts,0)))
3862     {
3863       case 0: bitmask |= CURLPAUSE_SEND; break;
3864       case 1: bitmask |= CURLPAUSE_RECV; break;
3865       case 2: bitmask |= CURLPAUSE_ALL; break;
3866       default: caml_failwith("wrong pauseOption");
3867     }
3868     opts = Field(opts,1);
3869   }
3870
3871   result = curl_easy_pause(connection->handle,bitmask);
3872   if (result != CURLE_OK)
3873     raiseError(connection, result);
3874
3875   CAMLreturn(Val_unit);
3876 }
3877
3878 /*
3879  * Curl multi stack support
3880  *
3881  * Exported thin wrappers for libcurl are prefixed with caml_curl_multi_.
3882  * Other exported functions are prefixed with caml_curlm_, some of them
3883  * can/should be decomposed into smaller parts.
3884  */
3885
3886 struct ml_multi_handle
3887 {
3888   CURLM* handle;
3889   value values; /* callbacks */
3890 };
3891
3892 enum
3893 {
3894   curlmopt_socket_function,
3895   curlmopt_timer_function,
3896
3897   /* last, not used */
3898   multi_values_total
3899 };
3900
3901 typedef struct ml_multi_handle ml_multi_handle;
3902
3903 #define Multi_val(v) (*(ml_multi_handle**)Data_custom_val(v))
3904 #define CURLM_val(v) (Multi_val(v)->handle)
3905
3906 static struct custom_operations curl_multi_ops = {
3907   "ygrek.curl_multi",
3908   custom_finalize_default,
3909   custom_compare_default,
3910   custom_hash_default,
3911   custom_serialize_default,
3912   custom_deserialize_default,
3913 #if defined(custom_compare_ext_default)
3914   custom_compare_ext_default,
3915 #endif
3916 };
3917
3918 CAMLprim value caml_curl_multi_init(value unit)
3919 {
3920   CAMLparam1(unit);
3921   CAMLlocal1(v);
3922   ml_multi_handle* multi = (ml_multi_handle*)caml_stat_alloc(sizeof(ml_multi_handle));
3923   CURLM* h = curl_multi_init();
3924
3925   if (!h)
3926   {
3927     caml_stat_free(multi);
3928     caml_failwith("caml_curl_multi_init");
3929   }
3930
3931   multi->handle = h;
3932   multi->values = caml_alloc(multi_values_total, 0);
3933   caml_register_generational_global_root(&multi->values);
3934
3935   v = caml_alloc_custom(&curl_multi_ops, sizeof(ml_multi_handle*), 0, 1);
3936   Multi_val(v) = multi;
3937
3938   CAMLreturn(v);
3939 }
3940
3941 CAMLprim value caml_curl_multi_cleanup(value handle)
3942 {
3943   CAMLparam1(handle);
3944   ml_multi_handle* h = Multi_val(handle);
3945
3946   if (NULL == h)
3947     CAMLreturn(Val_unit);
3948
3949   caml_remove_generational_global_root(&h->values);
3950
3951   if (CURLM_OK != curl_multi_cleanup(h->handle))
3952     caml_failwith("caml_curl_multi_cleanup");
3953
3954   caml_stat_free(h);
3955   Multi_val(handle) = (ml_multi_handle*)NULL;
3956
3957   CAMLreturn(Val_unit);
3958 }
3959
3960 static CURL* curlm_remove_finished(CURLM* multi_handle, CURLcode* result)
3961 {
3962   int msgs_in_queue = 0;
3963
3964   while (1)
3965   {
3966     CURLMsg* msg = curl_multi_info_read(multi_handle, &msgs_in_queue);
3967     if (NULL == msg) return NULL;
3968     if (CURLMSG_DONE == msg->msg)
3969     {
3970       CURL* easy_handle = msg->easy_handle;
3971       if (result) *result = msg->data.result;
3972       if (CURLM_OK != curl_multi_remove_handle(multi_handle, easy_handle))
3973       {
3974         /*caml_failwith("curlm_remove_finished");*/
3975       }
3976       return easy_handle;
3977     }
3978   }
3979 }
3980
3981 CAMLprim value caml_curlm_remove_finished(value v_multi)
3982 {
3983   CAMLparam1(v_multi);
3984   CAMLlocal2(v_easy, v_tuple);
3985   CURL* handle;
3986   CURLM* multi_handle;
3987   CURLcode result;
3988   Connection* conn = NULL;
3989
3990   multi_handle = CURLM_val(v_multi);
3991
3992   caml_enter_blocking_section();
3993   handle = curlm_remove_finished(multi_handle,&result);
3994   caml_leave_blocking_section();
3995
3996   if (NULL == handle)
3997   {
3998     CAMLreturn(Val_none);
3999   }
4000   else
4001   {
4002     conn = getConnection(handle);
4003     if (conn->curl_ERRORBUFFER != NULL)
4004     {
4005         Store_field(Field(conn->ocamlValues, Ocaml_ERRORBUFFER), 0, caml_copy_string(conn->curl_ERRORBUFFER));
4006     }
4007     conn->refcount--;
4008     /* NB: same handle, but different block */
4009     v_easy = caml_curl_alloc(conn);
4010     v_tuple = caml_alloc(2, 0);
4011     Store_field(v_tuple,0,v_easy);
4012     Store_field(v_tuple,1,Val_int(result)); /* CURLcode */
4013     CAMLreturn(Val_some(v_tuple));
4014   }
4015 }
4016
4017 static int curlm_wait_data(CURLM* multi_handle)
4018 {
4019         struct timeval timeout;
4020   CURLMcode ret;
4021
4022         fd_set fdread;
4023         fd_set fdwrite;
4024         fd_set fdexcep;
4025         int maxfd = -1;
4026
4027         FD_ZERO(&fdread);
4028         FD_ZERO(&fdwrite);
4029         FD_ZERO(&fdexcep);
4030
4031         /* set a suitable timeout */
4032         timeout.tv_sec = 1;
4033         timeout.tv_usec = 0;
4034
4035         /* get file descriptors from the transfers */
4036         ret = curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
4037
4038         if (ret == CURLM_OK && maxfd >= 0)
4039         {
4040                 int rc = select(maxfd+1, &fdread, &fdwrite, &fdexcep, &timeout);
4041                 if (-1 != rc) return 0;
4042         }
4043         return 1;
4044 }
4045
4046 CAMLprim value caml_curlm_wait_data(value v_multi)
4047 {
4048   CAMLparam1(v_multi);
4049   int ret;
4050   CURLM* h = CURLM_val(v_multi);
4051
4052   caml_enter_blocking_section();
4053   ret = curlm_wait_data(h);
4054   caml_leave_blocking_section();
4055
4056   CAMLreturn(Val_bool(0 == ret));
4057 }
4058
4059 CAMLprim value caml_curl_multi_add_handle(value v_multi, value v_easy)
4060 {
4061   CAMLparam2(v_multi,v_easy);
4062   CURLM* multi = CURLM_val(v_multi);
4063   Connection* conn = Connection_val(v_easy);
4064
4065   /* prevent collection of OCaml value while the easy handle is used
4066    and may invoke callbacks registered on OCaml side */
4067   conn->refcount++;
4068
4069   /* may invoke callbacks so need to be consistent with locks */
4070   caml_enter_blocking_section();
4071   if (CURLM_OK != curl_multi_add_handle(multi, conn->handle))
4072   {
4073     conn->refcount--; /* not added, revert */
4074     caml_leave_blocking_section();
4075     caml_failwith("caml_curl_multi_add_handle");
4076   }
4077   caml_leave_blocking_section();
4078
4079   CAMLreturn(Val_unit);
4080 }
4081
4082 CAMLprim value caml_curl_multi_remove_handle(value v_multi, value v_easy)
4083 {
4084   CAMLparam2(v_multi,v_easy);
4085   CURLM* multi = CURLM_val(v_multi);
4086   Connection* conn = Connection_val(v_easy);
4087
4088   /* may invoke callbacks so need to be consistent with locks */
4089   caml_enter_blocking_section();
4090   if (CURLM_OK != curl_multi_remove_handle(multi, conn->handle))
4091   {
4092     caml_leave_blocking_section();
4093     caml_failwith("caml_curl_multi_remove_handle");
4094   }
4095   conn->refcount--;
4096   caml_leave_blocking_section();
4097
4098   CAMLreturn(Val_unit);
4099 }
4100
4101 CAMLprim value caml_curl_multi_perform_all(value v_multi)
4102 {
4103   CAMLparam1(v_multi);
4104   int still_running = 0;
4105   CURLM* h = CURLM_val(v_multi);
4106
4107   caml_enter_blocking_section();
4108   while (CURLM_CALL_MULTI_PERFORM == curl_multi_perform(h, &still_running));
4109   caml_leave_blocking_section();
4110
4111   CAMLreturn(Val_int(still_running));
4112 }
4113
4114 CAMLprim value helper_curl_easy_strerror(value v_code)
4115 {
4116   CAMLparam1(v_code);
4117   CAMLreturn(caml_copy_string(curl_easy_strerror(Int_val(v_code))));
4118 }
4119
4120 /*
4121  * Wrappers for the curl_multi_socket_action infrastructure
4122  * Based on curl hiperfifo.c example
4123  */
4124
4125 #ifdef _WIN32
4126 #ifndef Val_socket
4127 #define Val_socket(v) win_alloc_socket(v)
4128 #endif
4129 #ifndef Socket_val
4130 #error Socket_val not defined in unixsupport.h
4131 #endif
4132 #else /* _WIN32 */
4133 #ifndef Socket_val
4134 #define Socket_val(v) Long_val(v)
4135 #endif
4136 #ifndef Val_socket
4137 #define Val_socket(v) Val_int(v)
4138 #endif
4139 #endif  /* _WIN32 */
4140
4141 static void raise_multi_error(char const* msg)
4142 {
4143   static value* exception = NULL;
4144
4145   if (NULL == exception)
4146   {
4147     exception = caml_named_value("Curl.Multi.Error");
4148     if (NULL == exception) caml_invalid_argument("Curl.Multi.Error");
4149   }
4150
4151   caml_raise_with_string(*exception, msg);
4152 }
4153
4154 static void check_mcode(CURLMcode code)
4155 {
4156   char const *s = NULL;
4157   switch (code)
4158   {
4159     case CURLM_OK                  : return;
4160     case CURLM_CALL_MULTI_PERFORM  : s="CURLM_CALL_MULTI_PERFORM"; break;
4161     case CURLM_BAD_HANDLE          : s="CURLM_BAD_HANDLE";         break;
4162     case CURLM_BAD_EASY_HANDLE     : s="CURLM_BAD_EASY_HANDLE";    break;
4163     case CURLM_OUT_OF_MEMORY       : s="CURLM_OUT_OF_MEMORY";      break;
4164     case CURLM_INTERNAL_ERROR      : s="CURLM_INTERNAL_ERROR";     break;
4165     case CURLM_UNKNOWN_OPTION      : s="CURLM_UNKNOWN_OPTION";     break;
4166     case CURLM_LAST                : s="CURLM_LAST";               break;
4167     case CURLM_BAD_SOCKET          : s="CURLM_BAD_SOCKET";         break;
4168     default                        : s="CURLM_unknown";            break;
4169   }
4170   raise_multi_error(s);
4171 }
4172
4173 CAMLprim value caml_curl_multi_socket_action(value v_multi, value v_fd, value v_kind)
4174 {
4175   CAMLparam3(v_multi, v_fd, v_kind);
4176   CURLM* h = CURLM_val(v_multi);
4177   int still_running = 0;
4178   CURLMcode rc = CURLM_OK;
4179   curl_socket_t socket;
4180   int kind = 0;
4181
4182   if (Val_none == v_fd)
4183   {
4184     socket = CURL_SOCKET_TIMEOUT;
4185   }
4186   else
4187   {
4188     socket = Socket_val(Field(v_fd, 0));
4189   }
4190
4191   switch (Int_val(v_kind))
4192   {
4193     case 0 : break;
4194     case 1 : kind |= CURL_CSELECT_IN; break;
4195     case 2 : kind |= CURL_CSELECT_OUT; break;
4196     case 3 : kind |= CURL_CSELECT_IN | CURL_CSELECT_OUT; break;
4197     default:
4198       raise_multi_error("caml_curl_multi_socket_action");
4199   }
4200
4201 /*  fprintf(stdout,"fd %u kind %u\n",socket, kind); fflush(stdout); */
4202
4203   caml_enter_blocking_section();
4204   do {
4205     rc = curl_multi_socket_action(h, socket, kind, &still_running);
4206   } while (rc == CURLM_CALL_MULTI_PERFORM);
4207   caml_leave_blocking_section();
4208
4209   check_mcode(rc);
4210
4211   CAMLreturn(Val_int(still_running));
4212 }
4213
4214 CAMLprim value caml_curl_multi_socket_all(value v_multi)
4215 {
4216   CAMLparam1(v_multi);
4217   int still_running = 0;
4218   CURLMcode rc = CURLM_OK;
4219   CURLM* h = CURLM_val(v_multi);
4220
4221   caml_enter_blocking_section();
4222   do {
4223     rc = curl_multi_socket_all(h, &still_running);
4224   } while (rc == CURLM_CALL_MULTI_PERFORM);
4225   caml_leave_blocking_section();
4226
4227   check_mcode(rc);
4228
4229   CAMLreturn(Val_int(still_running));
4230 }
4231
4232 static int curlm_sock_cb(CURL *e, curl_socket_t sock, int what, void *cbp, void *sockp)
4233 {
4234   caml_leave_blocking_section();
4235
4236   CAMLparam0();
4237   CAMLlocal2(v_what,csock);
4238   (void)e;
4239   (void)sockp; /* not used */
4240
4241   /* v_what = Val_int(what); */
4242   switch (what)
4243   {
4244     case CURL_POLL_NONE   : v_what = Val_int(0); break;
4245     case CURL_POLL_IN     : v_what = Val_int(1); break;
4246     case CURL_POLL_OUT    : v_what = Val_int(2); break;
4247     case CURL_POLL_INOUT  : v_what = Val_int(3); break;
4248     case CURL_POLL_REMOVE : v_what = Val_int(4); break;
4249     default:
4250       fprintf(stderr, "curlm_sock_cb sock=%d what=%d\n", sock, what);
4251       fflush(stderr);
4252       raise_multi_error("curlm_sock_cb"); /* FIXME exception from callback */
4253   }
4254   csock=Val_socket(sock);
4255   caml_callback2(Field(((ml_multi_handle*)cbp)->values,curlmopt_socket_function),
4256                  csock, v_what);
4257   CAMLdrop;
4258
4259   caml_enter_blocking_section();
4260   return 0;
4261 }
4262
4263 CAMLprim value caml_curl_multi_socketfunction(value v_multi, value v_cb)
4264 {
4265   CAMLparam2(v_multi, v_cb);
4266   ml_multi_handle* multi = Multi_val(v_multi);
4267
4268   Store_field(multi->values, curlmopt_socket_function, v_cb);
4269
4270   curl_multi_setopt(multi->handle, CURLMOPT_SOCKETFUNCTION, curlm_sock_cb);
4271   curl_multi_setopt(multi->handle, CURLMOPT_SOCKETDATA, multi);
4272
4273   CAMLreturn(Val_unit);
4274 }
4275
4276 static int curlm_timer_cb(CURLM *multi, long timeout_ms, void *userp)
4277 {
4278   caml_leave_blocking_section();
4279
4280   CAMLparam0();
4281   (void)multi;
4282   caml_callback(Field(((ml_multi_handle*)userp)->values,curlmopt_timer_function), Val_long(timeout_ms));
4283   CAMLdrop;
4284
4285   caml_enter_blocking_section();
4286   return 0;
4287 }
4288
4289 CAMLprim value caml_curl_multi_timerfunction(value v_multi, value v_cb)
4290 {
4291   CAMLparam2(v_multi, v_cb);
4292   ml_multi_handle* multi = Multi_val(v_multi);
4293
4294   Store_field(multi->values, curlmopt_timer_function, v_cb);
4295
4296   curl_multi_setopt(multi->handle, CURLMOPT_TIMERFUNCTION, curlm_timer_cb);
4297   curl_multi_setopt(multi->handle, CURLMOPT_TIMERDATA, multi);
4298
4299   CAMLreturn(Val_unit);
4300 }
4301
4302 CAMLprim value caml_curl_multi_timeout(value v_multi)
4303 {
4304   CAMLparam1(v_multi);
4305   long ms = 0;
4306   CURLMcode rc = CURLM_OK;
4307   ml_multi_handle* multi = Multi_val(v_multi);
4308
4309   rc = curl_multi_timeout(multi->handle, &ms);
4310
4311   check_mcode(rc);
4312
4313   CAMLreturn(Val_long(ms));
4314 }
4315
4316 #define SETMOPT_VAL_(func_name, curl_option, conv_val) \
4317 static void func_name(CURLM *handle, value option) \
4318 { \
4319     CAMLparam1(option); \
4320     CURLMcode result = CURLM_OK; \
4321 \
4322     result = curl_multi_setopt(handle, curl_option, conv_val(option)); \
4323 \
4324     check_mcode(result); \
4325 \
4326     CAMLreturn0; \
4327 }
4328
4329 #define SETMOPT_VAL(name, conv) SETMOPT_VAL_(handle_multi_##name, CURLMOPT_##name, conv)
4330 #define SETMOPT_BOOL(name) SETMOPT_VAL(name, Bool_val)
4331 #define SETMOPT_LONG(name) SETMOPT_VAL(name, Long_val)
4332 #define SETMOPT_INT64(name) SETMOPT_VAL(name, Int64_val)
4333
4334 long pipeliningMap[] =
4335 {
4336   0, /* CURLPIPE_NOTHING */
4337   1, /* CURLPIPE_HTTP1 */
4338   2, /* CURLPIPE_MULTIPLEX */
4339 };
4340
4341 static void handle_multi_PIPELINING(CURLM* handle, value option)
4342 {
4343   CAMLparam1(option);
4344   CURLMcode result = CURLM_OK;
4345
4346   long bits = convert_bit_list(pipeliningMap, sizeof(pipeliningMap) / sizeof(pipeliningMap[0]), option);
4347
4348   result = curl_multi_setopt(handle, CURLMOPT_PIPELINING, bits);
4349
4350   check_mcode(result);
4351
4352   CAMLreturn0;
4353 }
4354
4355 #if HAVE_DECL_CURLMOPT_MAXCONNECTS
4356 SETMOPT_LONG( MAXCONNECTS)
4357 #endif
4358
4359 #if HAVE_DECL_CURLMOPT_MAX_PIPELINE_LENGTH
4360 SETMOPT_LONG( MAX_PIPELINE_LENGTH)
4361 #endif
4362
4363 #if HAVE_DECL_CURLMOPT_MAX_HOST_CONNECTIONS
4364 SETMOPT_LONG( MAX_HOST_CONNECTIONS)
4365 #endif
4366
4367 typedef struct CURLMOptionMapping CURLMOptionMapping;
4368 #define OPT(name) { handle_multi_## name, "CURLMOPT_"#name}
4369 #define NO_OPT(name) { NULL, "CURLMOPT_"#name}
4370
4371 struct CURLMOptionMapping
4372 {
4373     void (*optionHandler)(CURLM *, value);
4374     char *name;
4375 };
4376
4377 CURLMOptionMapping implementedMOptionMap[] = {
4378   OPT( PIPELINING),
4379 #if HAVE_DECL_CURLMOPT_MAXCONNECTS
4380   OPT( MAXCONNECTS),
4381 #else
4382   NO_OPT( MAXCONNECTS),
4383 #endif
4384 #if HAVE_DECL_CURLMOPT_MAX_PIPELINE_LENGTH
4385   OPT( MAX_PIPELINE_LENGTH),
4386 #else
4387   NO_OPT( MAX_PIPELINE_LENGTH),
4388 #endif
4389 #if HAVE_DECL_CURLMOPT_MAX_HOST_CONNECTIONS
4390   OPT( MAX_HOST_CONNECTIONS),
4391 #else
4392   NO_OPT( MAX_HOST_CONNECTIONS),
4393 #endif
4394 };
4395
4396 CAMLprim value caml_curl_multi_setopt(value v_multi, value option)
4397 {
4398     CAMLparam2(v_multi, option);
4399     CAMLlocal1(data);
4400     CURLM *handle = Multi_val(v_multi)->handle;
4401     CURLMOptionMapping* thisOption = NULL;
4402     static value* exception = NULL;
4403
4404     data = Field(option, 0);
4405
4406     if (Tag_val(option) < sizeof(implementedMOptionMap)/sizeof(CURLMOptionMapping))
4407     {
4408       thisOption = &implementedMOptionMap[Tag_val(option)];
4409       if (thisOption->optionHandler)
4410       {
4411         thisOption->optionHandler(handle, data);
4412       }
4413       else
4414       {
4415         if (NULL == exception)
4416         {
4417           exception = caml_named_value("Curl.NotImplemented");
4418           if (NULL == exception) caml_invalid_argument("Curl.NotImplemented");
4419         }
4420
4421         caml_raise_with_string(*exception, thisOption->name);
4422       }
4423     }
4424     else
4425     {
4426       caml_failwith("Invalid CURLMOPT Option");
4427     }
4428
4429     CAMLreturn(Val_unit);
4430 }