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