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       version = CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE;
2040       break;
2041     default:
2042       caml_invalid_argument("CURLOPT_HTTP_VERSION");
2043       break;
2044     }
2045
2046     result = curl_easy_setopt(conn->handle, CURLOPT_HTTP_VERSION, version);
2047
2048     if (result != CURLE_OK)
2049         raiseError(conn, result);
2050
2051     CAMLreturn0;
2052 }
2053
2054 SETOPT_BOOL( FTP_USE_EPSV)
2055 SETOPT_LONG( DNS_CACHE_TIMEOUT)
2056 SETOPT_BOOL( DNS_USE_GLOBAL_CACHE)
2057
2058 static void handle_PRIVATE(Connection *conn, value option)
2059 {
2060     CAMLparam1(option);
2061     Store_field(conn->ocamlValues, Ocaml_PRIVATE, option);
2062     CAMLreturn0;
2063 }
2064
2065 #if HAVE_DECL_CURLOPT_HTTP200ALIASES
2066 SETOPT_SLIST( HTTP200ALIASES)
2067 #endif
2068
2069 #if HAVE_DECL_CURLOPT_UNRESTRICTED_AUTH
2070 SETOPT_BOOL( UNRESTRICTED_AUTH)
2071 #endif
2072
2073 #if HAVE_DECL_CURLOPT_FTP_USE_EPRT
2074 SETOPT_BOOL( FTP_USE_EPRT)
2075 #endif
2076
2077 #if HAVE_DECL_CURLOPT_HTTPAUTH
2078 static void handle_HTTPAUTH(Connection *conn, value option)
2079 {
2080     CAMLparam1(option);
2081     CAMLlocal1(listIter);
2082     CURLcode result = CURLE_OK;
2083     long auth = CURLAUTH_NONE;
2084
2085     listIter = option;
2086
2087     while (!Is_long(listIter))
2088     {
2089         switch (Long_val(Field(listIter, 0)))
2090         {
2091         case 0: /* CURLAUTH_BASIC */
2092             auth |= CURLAUTH_BASIC;
2093             break;
2094
2095         case 1: /* CURLAUTH_DIGEST */
2096             auth |= CURLAUTH_DIGEST;
2097             break;
2098
2099         case 2: /* CURLAUTH_GSSNEGOTIATE */
2100             auth |= CURLAUTH_GSSNEGOTIATE;
2101             break;
2102
2103         case 3: /* CURLAUTH_NTLM */
2104             auth |= CURLAUTH_NTLM;
2105             break;
2106
2107         case 4: /* CURLAUTH_ANY */
2108             auth |= CURLAUTH_ANY;
2109             break;
2110
2111         case 5: /* CURLAUTH_ANYSAFE */
2112             auth |= CURLAUTH_ANYSAFE;
2113             break;
2114
2115         default:
2116             caml_failwith("Invalid HTTPAUTH Value");
2117             break;
2118         }
2119
2120         listIter = Field(listIter, 1);
2121     }
2122
2123     result = curl_easy_setopt(conn->handle,
2124                               CURLOPT_HTTPAUTH,
2125                               auth);
2126
2127     if (result != CURLE_OK)
2128         raiseError(conn, result);
2129
2130     CAMLreturn0;
2131 }
2132 #endif
2133
2134 #if HAVE_DECL_CURLOPT_FTP_CREATE_MISSING_DIRS
2135 SETOPT_BOOL( FTP_CREATE_MISSING_DIRS)
2136 #endif
2137
2138 #if HAVE_DECL_CURLOPT_PROXYAUTH
2139 static void handle_PROXYAUTH(Connection *conn, value option)
2140 {
2141     CAMLparam1(option);
2142     CAMLlocal1(listIter);
2143     CURLcode result = CURLE_OK;
2144     long auth = CURLAUTH_NONE;
2145
2146     listIter = option;
2147
2148     while (!Is_long(listIter))
2149     {
2150         switch (Long_val(Field(listIter, 0)))
2151         {
2152         case 0: /* CURLAUTH_BASIC */
2153             auth |= CURLAUTH_BASIC;
2154             break;
2155
2156         case 1: /* CURLAUTH_DIGEST */
2157             auth |= CURLAUTH_DIGEST;
2158             break;
2159
2160         case 2: /* CURLAUTH_GSSNEGOTIATE */
2161             auth |= CURLAUTH_GSSNEGOTIATE;
2162             break;
2163
2164         case 3: /* CURLAUTH_NTLM */
2165             auth |= CURLAUTH_NTLM;
2166             break;
2167
2168         case 4: /* CURLAUTH_ANY */
2169             auth |= CURLAUTH_ANY;
2170             break;
2171
2172         case 5: /* CURLAUTH_ANYSAFE */
2173             auth |= CURLAUTH_ANYSAFE;
2174             break;
2175
2176         default:
2177             caml_failwith("Invalid HTTPAUTH Value");
2178             break;
2179         }
2180
2181         listIter = Field(listIter, 1);
2182     }
2183
2184     result = curl_easy_setopt(conn->handle,
2185                               CURLOPT_PROXYAUTH,
2186                               auth);
2187
2188     if (result != CURLE_OK)
2189         raiseError(conn, result);
2190
2191     CAMLreturn0;
2192 }
2193 #endif
2194
2195 #if HAVE_DECL_CURLOPT_FTP_RESPONSE_TIMEOUT
2196 SETOPT_LONG( FTP_RESPONSE_TIMEOUT)
2197 #endif
2198
2199 #if HAVE_DECL_CURLOPT_IPRESOLVE
2200 static void handle_IPRESOLVE(Connection *conn, value option)
2201 {
2202     CAMLparam1(option);
2203     CURLcode result = CURLE_OK;
2204
2205     switch (Long_val(option))
2206     {
2207     case 0: /* CURL_IPRESOLVE_WHATEVER */
2208         result = curl_easy_setopt(conn->handle,
2209                                   CURLOPT_IPRESOLVE,
2210                                   CURL_IPRESOLVE_WHATEVER);
2211         break;
2212
2213     case 1: /* CURL_IPRESOLVE_V4 */
2214         result = curl_easy_setopt(conn->handle,
2215                                   CURLOPT_IPRESOLVE,
2216                                   CURL_IPRESOLVE_V4);
2217         break;
2218
2219     case 2: /* CURL_IPRESOLVE_V6 */
2220         result = curl_easy_setopt(conn->handle,
2221                                   CURLOPT_IPRESOLVE,
2222                                   CURL_IPRESOLVE_V6);
2223         break;
2224
2225     default:
2226         caml_failwith("Invalid IPRESOLVE Value");
2227         break;
2228     }
2229
2230     if (result != CURLE_OK)
2231         raiseError(conn, result);
2232
2233     CAMLreturn0;
2234 }
2235 #endif
2236
2237 #if HAVE_DECL_CURLOPT_MAXFILESIZE
2238 SETOPT_VAL( MAXFILESIZE, Int32_val)
2239 #endif
2240
2241 #if HAVE_DECL_CURLOPT_INFILESIZE_LARGE
2242 SETOPT_INT64( INFILESIZE_LARGE)
2243 #endif
2244
2245 #if HAVE_DECL_CURLOPT_RESUME_FROM_LARGE
2246 SETOPT_INT64( RESUME_FROM_LARGE)
2247 #endif
2248
2249 #if HAVE_DECL_CURLOPT_MAXFILESIZE_LARGE
2250 SETOPT_INT64( MAXFILESIZE_LARGE)
2251 #endif
2252
2253 #if HAVE_DECL_CURLOPT_NETRC_FILE
2254 SETOPT_STRING( NETRC_FILE)
2255 #endif
2256
2257 #if HAVE_DECL_CURLOPT_FTP_SSL
2258 static void handle_FTP_SSL(Connection *conn, value option)
2259 {
2260     CAMLparam1(option);
2261     CURLcode result = CURLE_OK;
2262
2263     switch (Long_val(option))
2264     {
2265     case 0: /* CURLFTPSSL_NONE */
2266         result = curl_easy_setopt(conn->handle,
2267                                   CURLOPT_FTP_SSL,
2268                                   CURLFTPSSL_NONE);
2269         break;
2270
2271     case 1: /* CURLFTPSSL_TRY */
2272         result = curl_easy_setopt(conn->handle,
2273                                   CURLOPT_FTP_SSL,
2274                                   CURLFTPSSL_TRY);
2275         break;
2276
2277     case 2: /* CURLFTPSSL_CONTROL */
2278         result = curl_easy_setopt(conn->handle,
2279                                   CURLOPT_FTP_SSL,
2280                                   CURLFTPSSL_CONTROL);
2281         break;
2282
2283     case 3: /* CURLFTPSSL_ALL */
2284         result = curl_easy_setopt(conn->handle,
2285                                   CURLOPT_FTP_SSL,
2286                                   CURLFTPSSL_ALL);
2287         break;
2288
2289     default:
2290         caml_failwith("Invalid FTP_SSL Value");
2291         break;
2292     }
2293
2294     if (result != CURLE_OK)
2295         raiseError(conn, result);
2296
2297     CAMLreturn0;
2298 }
2299 #endif
2300
2301 #if HAVE_DECL_CURLOPT_POSTFIELDSIZE_LARGE
2302 SETOPT_INT64( POSTFIELDSIZE_LARGE)
2303 #endif
2304
2305 #if HAVE_DECL_CURLOPT_TCP_NODELAY
2306 /* not using SETOPT_BOOL here because of TCP_NODELAY defined in winsock.h */
2307 SETOPT_VAL_( handle_TCP_NODELAY, CURLOPT_TCP_NODELAY, Bool_val)
2308 #endif
2309
2310 #if HAVE_DECL_CURLOPT_FTPSSLAUTH
2311 static void handle_FTPSSLAUTH(Connection *conn, value option)
2312 {
2313     CAMLparam1(option);
2314     CURLcode result = CURLE_OK;
2315
2316     switch (Long_val(option))
2317     {
2318     case 0: /* CURLFTPAUTH_DEFAULT */
2319         result = curl_easy_setopt(conn->handle,
2320                                   CURLOPT_FTPSSLAUTH,
2321                                   CURLFTPAUTH_DEFAULT);
2322         break;
2323
2324     case 1: /* CURLFTPAUTH_SSL */
2325         result = curl_easy_setopt(conn->handle,
2326                                   CURLOPT_FTPSSLAUTH,
2327                                   CURLFTPAUTH_SSL);
2328         break;
2329
2330     case 2: /* CURLFTPAUTH_TLS */
2331         result = curl_easy_setopt(conn->handle,
2332                                   CURLOPT_FTPSSLAUTH,
2333                                   CURLFTPAUTH_TLS);
2334         break;
2335
2336     default:
2337         caml_failwith("Invalid FTPSSLAUTH value");
2338         break;
2339     }
2340
2341     if (result != CURLE_OK)
2342         raiseError(conn, result);
2343
2344     CAMLreturn0;
2345 }
2346 #endif
2347
2348 #if HAVE_DECL_CURLOPT_FTP_ACCOUNT
2349 SETOPT_STRING( FTP_ACCOUNT)
2350 #endif
2351
2352 #if HAVE_DECL_CURLOPT_COOKIELIST
2353 SETOPT_STRING( COOKIELIST)
2354 #endif
2355
2356 #if HAVE_DECL_CURLOPT_IGNORE_CONTENT_LENGTH
2357 SETOPT_BOOL( IGNORE_CONTENT_LENGTH)
2358 #endif
2359
2360 #if HAVE_DECL_CURLOPT_FTP_SKIP_PASV_IP
2361 SETOPT_BOOL( FTP_SKIP_PASV_IP)
2362 #endif
2363
2364 #if HAVE_DECL_CURLOPT_FTP_FILEMETHOD
2365 static void handle_FTP_FILEMETHOD(Connection *conn, value option)
2366 {
2367     CAMLparam1(option);
2368     CURLcode result = CURLE_OK;
2369
2370     switch (Long_val(option))
2371     {
2372     case 0: /* CURLFTPMETHOD_DEFAULT */
2373         result = curl_easy_setopt(conn->handle,
2374                                   CURLOPT_FTP_FILEMETHOD,
2375                                   CURLFTPMETHOD_DEFAULT);
2376         break;
2377
2378     case 1: /* CURLFTMETHOD_MULTICWD */
2379         result = curl_easy_setopt(conn->handle,
2380                                   CURLOPT_FTP_FILEMETHOD,
2381                                   CURLFTPMETHOD_MULTICWD);
2382         break;
2383
2384     case 2: /* CURLFTPMETHOD_NOCWD */
2385         result = curl_easy_setopt(conn->handle,
2386                                   CURLOPT_FTP_FILEMETHOD,
2387                                   CURLFTPMETHOD_NOCWD);
2388         break;
2389
2390     case 3: /* CURLFTPMETHOD_SINGLECWD */
2391         result = curl_easy_setopt(conn->handle,
2392                                   CURLOPT_FTP_FILEMETHOD,
2393                                   CURLFTPMETHOD_SINGLECWD);
2394
2395     default:
2396         caml_failwith("Invalid FTP_FILEMETHOD value");
2397         break;
2398     }
2399
2400     if (result != CURLE_OK)
2401         raiseError(conn, result);
2402
2403     CAMLreturn0;
2404 }
2405 #endif
2406
2407 #if HAVE_DECL_CURLOPT_LOCALPORT
2408 SETOPT_LONG( LOCALPORT)
2409 #endif
2410
2411 #if HAVE_DECL_CURLOPT_LOCALPORTRANGE
2412 SETOPT_LONG( LOCALPORTRANGE)
2413 #endif
2414
2415 #if HAVE_DECL_CURLOPT_CONNECT_ONLY
2416 SETOPT_BOOL( CONNECT_ONLY)
2417 #endif
2418
2419 #if HAVE_DECL_CURLOPT_MAX_SEND_SPEED_LARGE
2420 SETOPT_INT64( MAX_SEND_SPEED_LARGE)
2421 #endif
2422
2423 #if HAVE_DECL_CURLOPT_MAX_RECV_SPEED_LARGE
2424 SETOPT_INT64( MAX_RECV_SPEED_LARGE)
2425 #endif
2426
2427 #if HAVE_DECL_CURLOPT_FTP_ALTERNATIVE_TO_USER
2428 SETOPT_STRING( FTP_ALTERNATIVE_TO_USER)
2429 #endif
2430
2431 #if HAVE_DECL_CURLOPT_SSL_SESSIONID_CACHE
2432 SETOPT_BOOL( SSL_SESSIONID_CACHE)
2433 #endif
2434
2435 #if HAVE_DECL_CURLOPT_SSH_AUTH_TYPES
2436 static void handle_SSH_AUTH_TYPES(Connection *conn, value option)
2437 {
2438     CAMLparam1(option);
2439     CAMLlocal1(listIter);
2440     CURLcode result = CURLE_OK;
2441     long authTypes = CURLSSH_AUTH_NONE;
2442
2443     listIter = option;
2444
2445     while (!Is_long(listIter))
2446     {
2447         switch (Long_val(Field(listIter, 0)))
2448         {
2449         case 0: /* CURLSSH_AUTH_ANY */
2450             authTypes |= CURLSSH_AUTH_ANY;
2451             break;
2452
2453         case 1: /* CURLSSH_AUTH_PUBLICKEY */
2454             authTypes |= CURLSSH_AUTH_PUBLICKEY;
2455             break;
2456
2457         case 2: /* CURLSSH_AUTH_PASSWORD */
2458             authTypes |= CURLSSH_AUTH_PASSWORD;
2459             break;
2460
2461         case 3: /* CURLSSH_AUTH_HOST */
2462             authTypes |= CURLSSH_AUTH_HOST;
2463             break;
2464
2465         case 4: /* CURLSSH_AUTH_KEYBOARD */
2466             authTypes |= CURLSSH_AUTH_KEYBOARD;
2467             break;
2468
2469         default:
2470             caml_failwith("Invalid CURLSSH_AUTH_TYPES Value");
2471             break;
2472         }
2473
2474         listIter = Field(listIter, 1);
2475     }
2476
2477     result = curl_easy_setopt(conn->handle,
2478                               CURLOPT_SSH_AUTH_TYPES,
2479                               authTypes);
2480
2481     if (result != CURLE_OK)
2482         raiseError(conn, result);
2483
2484     CAMLreturn0;
2485 }
2486 #endif
2487
2488 #if HAVE_DECL_CURLOPT_SSH_PUBLIC_KEYFILE
2489 SETOPT_STRING( SSH_PUBLIC_KEYFILE)
2490 #endif
2491
2492 #if HAVE_DECL_CURLOPT_SSH_PRIVATE_KEYFILE
2493 SETOPT_STRING( SSH_PRIVATE_KEYFILE)
2494 #endif
2495
2496 #if HAVE_DECL_CURLOPT_FTP_SSL_CCC
2497 static void handle_FTP_SSL_CCC(Connection *conn, value option)
2498 {
2499     CAMLparam1(option);
2500     CURLcode result = CURLE_OK;
2501
2502     switch (Long_val(option))
2503     {
2504     case 0: /* CURLFTPSSL_CCC_NONE */
2505         result = curl_easy_setopt(conn->handle,
2506                                   CURLOPT_FTP_SSL_CCC,
2507                                   CURLFTPSSL_CCC_NONE);
2508         break;
2509
2510     case 1: /* CURLFTPSSL_CCC_PASSIVE */
2511         result = curl_easy_setopt(conn->handle,
2512                                   CURLOPT_FTP_SSL_CCC,
2513                                   CURLFTPSSL_CCC_PASSIVE);
2514         break;
2515
2516     case 2: /* CURLFTPSSL_CCC_ACTIVE */
2517         result = curl_easy_setopt(conn->handle,
2518                                   CURLOPT_FTP_SSL_CCC,
2519                                   CURLFTPSSL_CCC_ACTIVE);
2520         break;
2521
2522     default:
2523         caml_failwith("Invalid FTPSSL_CCC value");
2524         break;
2525     }
2526
2527     if (result != CURLE_OK)
2528         raiseError(conn, result);
2529
2530     CAMLreturn0;
2531 }
2532 #endif
2533
2534 #if HAVE_DECL_CURLOPT_TIMEOUT_MS
2535 SETOPT_LONG( TIMEOUT_MS)
2536 #endif
2537
2538 #if HAVE_DECL_CURLOPT_CONNECTTIMEOUT_MS
2539 SETOPT_LONG( CONNECTTIMEOUT_MS)
2540 #endif
2541
2542 #if HAVE_DECL_CURLOPT_HTTP_TRANSFER_DECODING
2543 SETOPT_BOOL( HTTP_TRANSFER_DECODING)
2544 #endif
2545
2546 #if HAVE_DECL_CURLOPT_HTTP_CONTENT_DECODING
2547 SETOPT_BOOL( HTTP_CONTENT_DECODING)
2548 #endif
2549
2550 #if HAVE_DECL_CURLOPT_NEW_FILE_PERMS
2551 SETOPT_LONG( NEW_FILE_PERMS)
2552 #endif
2553
2554 #if HAVE_DECL_CURLOPT_NEW_DIRECTORY_PERMS
2555 SETOPT_LONG( NEW_DIRECTORY_PERMS)
2556 #endif
2557
2558 #if HAVE_DECL_CURLOPT_POST301
2559 SETOPT_BOOL( POST301)
2560 #endif
2561
2562 #if HAVE_DECL_CURLOPT_SSH_HOST_PUBLIC_KEY_MD5
2563 SETOPT_STRING( SSH_HOST_PUBLIC_KEY_MD5)
2564 #endif
2565
2566 #if HAVE_DECL_CURLOPT_COPYPOSTFIELDS
2567 SETOPT_STRING( COPYPOSTFIELDS)
2568 #endif
2569
2570 #if HAVE_DECL_CURLOPT_PROXY_TRANSFER_MODE
2571 SETOPT_BOOL( PROXY_TRANSFER_MODE)
2572 #endif
2573
2574 #if HAVE_DECL_CURLOPT_AUTOREFERER
2575 SETOPT_BOOL( AUTOREFERER)
2576 #endif
2577
2578 #if HAVE_DECL_CURLOPT_PROXYTYPE
2579 static void handle_PROXYTYPE(Connection *conn, value option)
2580 {
2581     CAMLparam1(option);
2582     CURLcode result = CURLE_OK;
2583     long proxy_type;
2584
2585     switch (Long_val(option))
2586     {
2587       case 0: proxy_type = CURLPROXY_HTTP; break;
2588       case 1: proxy_type = CURLPROXY_HTTP_1_0; break;
2589       case 2: proxy_type = CURLPROXY_SOCKS4; break;
2590       case 3: proxy_type = CURLPROXY_SOCKS5; break;
2591       case 4: proxy_type = CURLPROXY_SOCKS4A; break;
2592       case 5: proxy_type = CURLPROXY_SOCKS5_HOSTNAME; break;
2593       default:
2594         caml_failwith("Invalid curl proxy type");
2595     }
2596
2597     result = curl_easy_setopt(conn->handle,
2598                               CURLOPT_PROXYTYPE,
2599                               proxy_type);
2600
2601     if (result != CURLE_OK)
2602         raiseError(conn, result);
2603
2604     CAMLreturn0;
2605 }
2606 #endif
2607
2608 #if HAVE_DECL_CURLOPT_PROTOCOLS || HAVE_DECL_CURLOPT_REDIR_PROTOCOLS
2609
2610 long protoMap[] =
2611 {
2612   CURLPROTO_ALL,
2613   CURLPROTO_HTTP, CURLPROTO_HTTPS, CURLPROTO_FTP, CURLPROTO_FTPS, CURLPROTO_SCP, CURLPROTO_SFTP,
2614   CURLPROTO_TELNET, CURLPROTO_LDAP, CURLPROTO_LDAPS, CURLPROTO_DICT, CURLPROTO_FILE, CURLPROTO_TFTP,
2615 /* factor out with autoconf? */
2616 #if defined(CURLPROTO_IMAP)
2617   CURLPROTO_IMAP,
2618 #else
2619   0,
2620 #endif
2621 #if defined(CURLPROTO_IMAPS)
2622   CURLPROTO_IMAPS,
2623 #else
2624   0,
2625 #endif
2626 #if defined(CURLPROTO_POP3)
2627   CURLPROTO_POP3,
2628 #else
2629   0,
2630 #endif
2631 #if defined(CURLPROTO_POP3S)
2632   CURLPROTO_POP3S,
2633 #else
2634   0,
2635 #endif
2636 #if defined(CURLPROTO_SMTP)
2637   CURLPROTO_SMTP,
2638 #else
2639   0,
2640 #endif
2641 #if defined(CURLPROTO_SMTPS)
2642   CURLPROTO_SMTPS,
2643 #else
2644   0,
2645 #endif
2646 #if defined(CURLPROTO_RTSP)
2647   CURLPROTO_RTSP,
2648 #else
2649   0,
2650 #endif
2651 #if defined(CURLPROTO_RTMP)
2652   CURLPROTO_RTMP,
2653 #else
2654   0,
2655 #endif
2656 #if defined(CURLPROTO_RTMPT)
2657   CURLPROTO_RTMPT,
2658 #else
2659   0,
2660 #endif
2661 #if defined(CURLPROTO_RTMPE)
2662   CURLPROTO_RTMPE,
2663 #else
2664   0,
2665 #endif
2666 #if defined(CURLPROTO_RTMPTE)
2667   CURLPROTO_RTMPTE,
2668 #else
2669   0,
2670 #endif
2671 #if defined(CURLPROTO_RTMPS)
2672   CURLPROTO_RTMPS,
2673 #else
2674   0,
2675 #endif
2676 #if defined(CURLPROTO_RTMPTS)
2677   CURLPROTO_RTMPTS,
2678 #else
2679   0,
2680 #endif
2681 #if defined(CURLPROTO_GOPHER)
2682   CURLPROTO_GOPHER,
2683 #else
2684   0,
2685 #endif
2686 };
2687
2688 static void handle_PROTOCOLSOPTION(CURLoption curlopt, Connection *conn, value option)
2689 {
2690     CAMLparam1(option);
2691     CURLcode result = CURLE_OK;
2692     long bits = convert_bit_list(protoMap, sizeof(protoMap) / sizeof(protoMap[0]), option);
2693
2694     result = curl_easy_setopt(conn->handle, curlopt, bits);
2695
2696     if (result != CURLE_OK)
2697         raiseError(conn, result);
2698
2699     CAMLreturn0;
2700 }
2701 #endif
2702
2703 #if HAVE_DECL_CURLOPT_PROTOCOLS
2704 static void handle_PROTOCOLS(Connection *conn, value option)
2705 {
2706   handle_PROTOCOLSOPTION(CURLOPT_PROTOCOLS, conn, option);
2707 }
2708 #endif
2709
2710 #if HAVE_DECL_CURLOPT_REDIR_PROTOCOLS
2711 static void handle_REDIR_PROTOCOLS(Connection *conn, value option)
2712 {
2713   handle_PROTOCOLSOPTION(CURLOPT_REDIR_PROTOCOLS, conn, option);
2714 }
2715 #endif
2716
2717 #if HAVE_DECL_CURLOPT_RESOLVE
2718 SETOPT_SLIST( RESOLVE)
2719 #endif
2720
2721 #if HAVE_DECL_CURLOPT_DNS_SERVERS
2722 SETOPT_STRING( DNS_SERVERS)
2723 #endif
2724
2725 #if HAVE_DECL_CURLOPT_MAIL_FROM
2726 SETOPT_STRING( MAIL_FROM)
2727 #endif
2728
2729 #if HAVE_DECL_CURLOPT_MAIL_RCPT
2730 SETOPT_SLIST( MAIL_RCPT)
2731 #endif
2732
2733 #if HAVE_DECL_CURLOPT_PIPEWAIT
2734 SETOPT_BOOL( PIPEWAIT)
2735 #endif
2736
2737 #if HAVE_DECL_CURLOPT_USERNAME
2738 SETOPT_STRING( USERNAME)
2739 #endif
2740
2741 #if HAVE_DECL_CURLOPT_PASSWORD
2742 SETOPT_STRING( PASSWORD)
2743 #endif
2744
2745 #if HAVE_DECL_CURLOPT_LOGIN_OPTIONS
2746 SETOPT_STRING( LOGIN_OPTIONS)
2747 #endif
2748
2749 #if HAVE_DECL_CURLOPT_CONNECT_TO
2750 SETOPT_SLIST( CONNECT_TO)
2751 #endif
2752
2753 #if HAVE_DECL_CURLOPT_POSTREDIR
2754
2755 static int curlPostRedir_table[] = {
2756  CURL_REDIR_POST_ALL,
2757 #if defined(CURL_REDIR_POST_301)
2758   CURL_REDIR_POST_301,
2759 #else
2760   0,
2761 #endif
2762 #if defined(CURL_REDIR_POST_302)
2763   CURL_REDIR_POST_302,
2764 #else
2765   0,
2766 #endif
2767 #if defined(CURL_REDIR_POST_303)
2768   CURL_REDIR_POST_303,
2769 #else
2770   0,
2771 #endif
2772 };
2773
2774 static void handle_POSTREDIR(Connection *conn, value option)
2775 {
2776     CAMLparam1(option);
2777     CURLcode result = CURLE_OK;
2778     long bitmask = caml_convert_flag_list(option, curlPostRedir_table);
2779
2780     result = curl_easy_setopt(conn->handle,
2781                               CURLOPT_POSTREDIR,
2782                               bitmask);
2783
2784     if (result != CURLE_OK)
2785         raiseError(conn, result);
2786
2787     CAMLreturn0;
2788 }
2789 #endif
2790
2791 /**
2792  **  curl_easy_setopt helper function
2793  **/
2794
2795 #define MAP(name) { handle_ ## name, "CURLOPT_"#name, Ocaml_##name }
2796 #define MAP_NO(name) { NULL, "CURLOPT_"#name , Ocaml_##name }
2797 #define IMM(name) { handle_ ## name, "CURLOPT_"#name, (OcamlValue)(-1) }
2798 #define IMM_NO(name) { NULL, "CURLOPT_"#name , (OcamlValue)(-1) }
2799
2800 CURLOptionMapping implementedOptionMap[] =
2801 {
2802   MAP(WRITEFUNCTION),
2803   MAP(READFUNCTION),
2804   IMM(INFILESIZE),
2805   MAP(URL),
2806   MAP(PROXY),
2807   IMM(PROXYPORT),
2808   IMM(HTTPPROXYTUNNEL),
2809   IMM(VERBOSE),
2810   IMM(HEADER),
2811   IMM(NOPROGRESS),
2812 #if HAVE_DECL_CURLOPT_NOSIGNAL
2813   IMM(NOSIGNAL),
2814 #else
2815   IMM_NO(NOSIGNAL),
2816 #endif
2817   IMM(NOBODY),
2818   IMM(FAILONERROR),
2819   IMM(UPLOAD),
2820   IMM(POST),
2821   IMM(FTPLISTONLY),
2822   IMM(FTPAPPEND),
2823   IMM(NETRC),
2824 #if HAVE_DECL_CURLOPT_ENCODING
2825   IMM(ENCODING),
2826 #else
2827   IMM_NO(ENCODING),
2828 #endif
2829   IMM(FOLLOWLOCATION),
2830   IMM(TRANSFERTEXT),
2831   IMM(PUT),
2832   MAP(USERPWD),
2833   MAP(PROXYUSERPWD),
2834   MAP(RANGE),
2835   IMM(ERRORBUFFER), /* mutable buffer, as output value, do not duplicate */
2836   IMM(TIMEOUT),
2837   MAP(POSTFIELDS),
2838   IMM(POSTFIELDSIZE),
2839   MAP(REFERER),
2840   MAP(USERAGENT),
2841   MAP(FTPPORT),
2842   IMM(LOW_SPEED_LIMIT),
2843   IMM(LOW_SPEED_TIME),
2844   IMM(RESUME_FROM),
2845   MAP(COOKIE),
2846   MAP(HTTPHEADER),
2847   MAP(HTTPPOST),
2848   MAP(SSLCERT),
2849   MAP(SSLCERTTYPE),
2850   MAP(SSLCERTPASSWD),
2851   MAP(SSLKEY),
2852   MAP(SSLKEYTYPE),
2853   MAP(SSLKEYPASSWD),
2854   MAP(SSLENGINE),
2855   IMM(SSLENGINE_DEFAULT),
2856   IMM(CRLF),
2857   MAP(QUOTE),
2858   MAP(POSTQUOTE),
2859   MAP(HEADERFUNCTION),
2860   MAP(COOKIEFILE),
2861   IMM(SSLVERSION),
2862   IMM(TIMECONDITION),
2863   IMM(TIMEVALUE),
2864   MAP(CUSTOMREQUEST),
2865   MAP(INTERFACE),
2866   IMM(KRB4LEVEL),
2867   MAP(PROGRESSFUNCTION),
2868   IMM(SSL_VERIFYPEER),
2869   MAP(CAINFO),
2870   MAP(CAPATH),
2871   IMM(FILETIME),
2872   IMM(MAXREDIRS),
2873   IMM(MAXCONNECTS),
2874   IMM(CLOSEPOLICY),
2875   IMM(FRESH_CONNECT),
2876   IMM(FORBID_REUSE),
2877   MAP(RANDOM_FILE),
2878   MAP(EGDSOCKET),
2879   IMM(CONNECTTIMEOUT),
2880   IMM(HTTPGET),
2881   IMM(SSL_VERIFYHOST),
2882   MAP(COOKIEJAR),
2883   MAP(SSL_CIPHER_LIST),
2884   IMM(HTTP_VERSION),
2885   IMM(FTP_USE_EPSV),
2886   IMM(DNS_CACHE_TIMEOUT),
2887   IMM(DNS_USE_GLOBAL_CACHE),
2888   MAP(DEBUGFUNCTION),
2889   MAP(PRIVATE),
2890 #if HAVE_DECL_CURLOPT_HTTP200ALIASES
2891   MAP(HTTP200ALIASES),
2892 #else
2893   MAP_NO(HTTP200ALIASES),
2894 #endif
2895 #if HAVE_DECL_CURLOPT_UNRESTRICTED_AUTH
2896   IMM(UNRESTRICTED_AUTH),
2897 #else
2898   IMM_NO(UNRESTRICTED_AUTH),
2899 #endif
2900 #if HAVE_DECL_CURLOPT_FTP_USE_EPRT
2901   IMM(FTP_USE_EPRT),
2902 #else
2903   IMM_NO(FTP_USE_EPRT),
2904 #endif
2905 #if HAVE_DECL_CURLOPT_HTTPAUTH
2906   IMM(HTTPAUTH),
2907 #else
2908   IMM_NO(HTTPAUTH),
2909 #endif
2910 #if HAVE_DECL_CURLOPT_FTP_CREATE_MISSING_DIRS
2911   IMM(FTP_CREATE_MISSING_DIRS),
2912 #else
2913   IMM_NO(FTP_CREATE_MISSING_DIRS),
2914 #endif
2915 #if HAVE_DECL_CURLOPT_PROXYAUTH
2916   IMM(PROXYAUTH),
2917 #else
2918   IMM_NO(PROXYAUTH),
2919 #endif
2920 #if HAVE_DECL_CURLOPT_FTP_RESPONSE_TIMEOUT
2921   IMM(FTP_RESPONSE_TIMEOUT),
2922 #else
2923   IMM_NO(FTP_RESPONSE_TIMEOUT),
2924 #endif
2925 #if HAVE_DECL_CURLOPT_IPRESOLVE
2926   IMM(IPRESOLVE),
2927 #else
2928   IMM_NO(IPRESOLVE),
2929 #endif
2930 #if HAVE_DECL_CURLOPT_MAXFILESIZE
2931   IMM(MAXFILESIZE),
2932 #else
2933   IMM_NO(MAXFILESIZE),
2934 #endif
2935 #if HAVE_DECL_CURLOPT_INFILESIZE_LARGE
2936   IMM(INFILESIZE_LARGE),
2937 #else
2938   IMM_NO(INFILESIZE_LARGE),
2939 #endif
2940 #if HAVE_DECL_CURLOPT_RESUME_FROM_LARGE
2941   IMM(RESUME_FROM_LARGE),
2942 #else
2943   IMM_NO(RESUME_FROM_LARGE),
2944 #endif
2945 #if HAVE_DECL_CURLOPT_MAXFILESIZE_LARGE
2946   IMM(MAXFILESIZE_LARGE),
2947 #else
2948   IMM_NO(MAXFILESIZE_LARGE),
2949 #endif
2950 #if HAVE_DECL_CURLOPT_NETRC_FILE
2951   MAP(NETRC_FILE),
2952 #else
2953   MAP_NO(NETRC_FILE),
2954 #endif
2955 #if HAVE_DECL_CURLOPT_FTP_SSL
2956   IMM(FTP_SSL),
2957 #else
2958   IMM_NO(FTP_SSL),
2959 #endif
2960 #if HAVE_DECL_CURLOPT_POSTFIELDSIZE_LARGE
2961   IMM(POSTFIELDSIZE_LARGE),
2962 #else
2963   IMM_NO(POSTFIELDSIZE_LARGE),
2964 #endif
2965 #if HAVE_DECL_CURLOPT_TCP_NODELAY
2966   IMM(TCP_NODELAY),
2967 #else
2968   IMM_NO(TCP_NODELAY),
2969 #endif
2970 #if HAVE_DECL_CURLOPT_FTPSSLAUTH
2971   IMM(FTPSSLAUTH),
2972 #else
2973   IMM_NO(FTPSSLAUTH),
2974 #endif
2975 #if HAVE_DECL_CURLOPT_IOCTLFUNCTION
2976   MAP(IOCTLFUNCTION),
2977 #else
2978   MAP_NO(IOCTLFUNCTION),
2979 #endif
2980 #if HAVE_DECL_CURLOPT_FTP_ACCOUNT
2981   MAP(FTP_ACCOUNT),
2982 #else
2983   MAP_NO(FTP_ACCOUNT),
2984 #endif
2985 #if HAVE_DECL_CURLOPT_COOKIELIST
2986   MAP(COOKIELIST),
2987 #else
2988   MAP_NO(COOKIELIST),
2989 #endif
2990 #if HAVE_DECL_CURLOPT_IGNORE_CONTENT_LENGTH
2991   IMM(IGNORE_CONTENT_LENGTH),
2992 #else
2993   IMM_NO(IGNORE_CONTENT_LENGTH),
2994 #endif
2995 #if HAVE_DECL_CURLOPT_FTP_SKIP_PASV_IP
2996   IMM(FTP_SKIP_PASV_IP),
2997 #else
2998   IMM_NO(FTP_SKIP_PASV_IP),
2999 #endif
3000 #if HAVE_DECL_CURLOPT_FTP_FILEMETHOD
3001   IMM(FTP_FILEMETHOD),
3002 #else
3003   IMM_NO(FTP_FILEMETHOD),
3004 #endif
3005 #if HAVE_DECL_CURLOPT_LOCALPORT
3006   IMM(LOCALPORT),
3007 #else
3008   IMM_NO(LOCALPORT),
3009 #endif
3010 #if HAVE_DECL_CURLOPT_LOCALPORTRANGE
3011   IMM(LOCALPORTRANGE),
3012 #else
3013   IMM_NO(LOCALPORTRANGE),
3014 #endif
3015 #if HAVE_DECL_CURLOPT_CONNECT_ONLY
3016   IMM(CONNECT_ONLY),
3017 #else
3018   IMM_NO(CONNECT_ONLY),
3019 #endif
3020 #if HAVE_DECL_CURLOPT_MAX_SEND_SPEED_LARGE
3021   IMM(MAX_SEND_SPEED_LARGE),
3022 #else
3023   IMM_NO(MAX_SEND_SPEED_LARGE),
3024 #endif
3025 #if HAVE_DECL_CURLOPT_MAX_RECV_SPEED_LARGE
3026   IMM(MAX_RECV_SPEED_LARGE),
3027 #else
3028   IMM_NO(MAX_RECV_SPEED_LARGE),
3029 #endif
3030 #if HAVE_DECL_CURLOPT_FTP_ALTERNATIVE_TO_USER
3031   MAP(FTP_ALTERNATIVE_TO_USER),
3032 #else
3033   MAP_NO(FTP_ALTERNATIVE_TO_USER),
3034 #endif
3035 #if HAVE_DECL_CURLOPT_SSL_SESSIONID_CACHE
3036   IMM(SSL_SESSIONID_CACHE),
3037 #else
3038   IMM_NO(SSL_SESSIONID_CACHE),
3039 #endif
3040 #if HAVE_DECL_CURLOPT_SSH_AUTH_TYPES
3041   IMM(SSH_AUTH_TYPES),
3042 #else
3043   IMM_NO(SSH_AUTH_TYPES),
3044 #endif
3045 #if HAVE_DECL_CURLOPT_SSH_PUBLIC_KEYFILE
3046   MAP(SSH_PUBLIC_KEYFILE),
3047 #else
3048   MAP_NO(SSH_PUBLIC_KEYFILE),
3049 #endif
3050 #if HAVE_DECL_CURLOPT_SSH_PRIVATE_KEYFILE
3051   MAP(SSH_PRIVATE_KEYFILE),
3052 #else
3053   MAP_NO(SSH_PRIVATE_KEYFILE),
3054 #endif
3055 #if HAVE_DECL_CURLOPT_FTP_SSL_CCC
3056   IMM(FTP_SSL_CCC),
3057 #else
3058   IMM_NO(FTP_SSL_CCC),
3059 #endif
3060 #if HAVE_DECL_CURLOPT_TIMEOUT_MS
3061   IMM(TIMEOUT_MS),
3062 #else
3063   IMM_NO(TIMEOUT_MS),
3064 #endif
3065 #if HAVE_DECL_CURLOPT_CONNECTTIMEOUT_MS
3066   IMM(CONNECTTIMEOUT_MS),
3067 #else
3068   IMM_NO(CONNECTTIMEOUT_MS),
3069 #endif
3070 #if HAVE_DECL_CURLOPT_HTTP_TRANSFER_DECODING
3071   IMM(HTTP_TRANSFER_DECODING),
3072 #else
3073   IMM_NO(HTTP_TRANSFER_DECODING),
3074 #endif
3075 #if HAVE_DECL_CURLOPT_HTTP_CONTENT_DECODING
3076   IMM(HTTP_CONTENT_DECODING),
3077 #else
3078   IMM_NO(HTTP_CONTENT_DECODING),
3079 #endif
3080 #if HAVE_DECL_CURLOPT_NEW_FILE_PERMS
3081   IMM(NEW_FILE_PERMS),
3082 #else
3083   IMM_NO(NEW_FILE_PERMS),
3084 #endif
3085 #if HAVE_DECL_CURLOPT_NEW_DIRECTORY_PERMS
3086   IMM(NEW_DIRECTORY_PERMS),
3087 #else
3088   IMM_NO(NEW_DIRECTORY_PERMS),
3089 #endif
3090 #if HAVE_DECL_CURLOPT_POST301
3091   IMM(POST301),
3092 #else
3093   IMM_NO(POST301),
3094 #endif
3095 #if HAVE_DECL_CURLOPT_SSH_HOST_PUBLIC_KEY_MD5
3096   MAP(SSH_HOST_PUBLIC_KEY_MD5),
3097 #else
3098   MAP_NO(SSH_HOST_PUBLIC_KEY_MD5),
3099 #endif
3100 #if HAVE_DECL_CURLOPT_COPYPOSTFIELDS
3101   MAP(COPYPOSTFIELDS),
3102 #else
3103   MAP_NO(COPYPOSTFIELDS),
3104 #endif
3105 #if HAVE_DECL_CURLOPT_PROXY_TRANSFER_MODE
3106   IMM(PROXY_TRANSFER_MODE),
3107 #else
3108   IMM_NO(PROXY_TRANSFER_MODE),
3109 #endif
3110 #if HAVE_DECL_CURLOPT_SEEKFUNCTION
3111   MAP(SEEKFUNCTION),
3112 #else
3113   MAP_NO(SEEKFUNCTION),
3114 #endif
3115 #if HAVE_DECL_CURLOPT_AUTOREFERER
3116   IMM(AUTOREFERER),
3117 #else
3118   IMM_NO(AUTOREFERER),
3119 #endif
3120 #if HAVE_DECL_CURLOPT_OPENSOCKETFUNCTION
3121   MAP(OPENSOCKETFUNCTION),
3122 #else
3123   MAP_NO(OPENSOCKETFUNCTION),
3124 #endif
3125 #if HAVE_DECL_CURLOPT_PROXYTYPE
3126   IMM(PROXYTYPE),
3127 #else
3128   IMM_NO(PROXYTYPE),
3129 #endif
3130 #if HAVE_DECL_CURLOPT_PROTOCOLS
3131   IMM(PROTOCOLS),
3132 #else
3133   IMM_NO(PROTOCOLS),
3134 #endif
3135 #if HAVE_DECL_CURLOPT_REDIR_PROTOCOLS
3136   IMM(REDIR_PROTOCOLS),
3137 #else
3138   IMM_NO(REDIR_PROTOCOLS),
3139 #endif
3140 #if HAVE_DECL_CURLOPT_RESOLVE
3141   MAP(RESOLVE),
3142 #else
3143   MAP_NO(RESOLVE),
3144 #endif
3145 #if HAVE_DECL_CURLOPT_DNS_SERVERS
3146   MAP(DNS_SERVERS),
3147 #else
3148   MAP_NO(DNS_SERVERS),
3149 #endif
3150 #if HAVE_DECL_CURLOPT_MAIL_FROM
3151   MAP(MAIL_FROM),
3152 #else
3153   MAP_NO(MAIL_FROM),
3154 #endif
3155 #if HAVE_DECL_CURLOPT_MAIL_RCPT
3156   MAP(MAIL_RCPT),
3157 #else
3158   MAP_NO(MAIL_RCPT),
3159 #endif
3160 #if HAVE_DECL_CURLOPT_PIPEWAIT
3161   IMM(PIPEWAIT),
3162 #else
3163   IMM_NO(PIPEWAIT),
3164 #endif
3165 #if HAVE_DECL_CURLOPT_CERTINFO
3166   IMM(CERTINFO),
3167 #else
3168   IMM_NO(CERTINFO),
3169 #endif
3170 #if HAVE_DECL_CURLOPT_USERNAME
3171   MAP(USERNAME),
3172 #else
3173   MAP_NO(USERNAME),
3174 #endif
3175 #if HAVE_DECL_CURLOPT_PASSWORD
3176   MAP(PASSWORD),
3177 #else
3178   MAP_NO(PASSWORD),
3179 #endif
3180 #if HAVE_DECL_CURLOPT_LOGIN_OPTIONS
3181   MAP(LOGIN_OPTIONS),
3182 #else
3183   MAP_NO(LOGIN_OPTIONS),
3184 #endif
3185 #if HAVE_DECL_CURLOPT_CONNECT_TO
3186   MAP(CONNECT_TO),
3187 #else
3188   MAP_NO(CONNECT_TO),
3189 #endif
3190 #if HAVE_DECL_CURLOPT_POSTREDIR
3191   MAP(POSTREDIR),
3192 #else
3193   MAP_NO(POSTREDIR),
3194 #endif
3195 #if HAVE_DECL_CURLOPT_MIMEPOST
3196   MAP(MIMEPOST),
3197 #else
3198   MAP_NO(MIMEPOST),
3199 #endif
3200 };
3201
3202 static Connection *duplicateConnection(Connection *original)
3203 {
3204     Connection *connection = NULL;
3205     CURL* h = NULL;
3206     size_t i = 0;
3207     CURLOptionMapping* self = NULL;
3208
3209     caml_enter_blocking_section();
3210     h  = curl_easy_duphandle(original->handle);
3211     caml_leave_blocking_section();
3212
3213     connection = allocConnection(h);
3214
3215     for (i = 0; i < sizeof(implementedOptionMap)/sizeof(CURLOptionMapping); i++)
3216     {
3217       self = &implementedOptionMap[i];
3218       if (-1 == self->ocamlValue) continue;
3219       if (self->optionHandler && (Field(original->ocamlValues, self->ocamlValue) != Val_unit))
3220       {
3221         self->optionHandler(connection, Field(original->ocamlValues, self->ocamlValue));
3222       }
3223     }
3224
3225     return connection;
3226 }
3227
3228 value caml_curl_easy_setopt(value conn, value option)
3229 {
3230     CAMLparam2(conn, option);
3231     CAMLlocal1(data);
3232     Connection *connection = Connection_val(conn);
3233     CURLOptionMapping* thisOption = NULL;
3234     static value* exception = NULL;
3235
3236     checkConnection(connection);
3237
3238     data = Field(option, 0);
3239
3240     if (Tag_val(option) < sizeof(implementedOptionMap)/sizeof(CURLOptionMapping))
3241     {
3242       thisOption = &implementedOptionMap[Tag_val(option)];
3243       if (thisOption->optionHandler)
3244       {
3245         thisOption->optionHandler(connection, data);
3246       }
3247       else
3248       {
3249         if (NULL == exception)
3250         {
3251           exception = caml_named_value("Curl.NotImplemented");
3252           if (NULL == exception) caml_invalid_argument("Curl.NotImplemented");
3253         }
3254
3255         caml_raise_with_string(*exception, thisOption->name);
3256       }
3257     }
3258     else
3259     {
3260       caml_failwith("Invalid CURLOPT Option");
3261     }
3262
3263     CAMLreturn(Val_unit);
3264 }
3265
3266 /**
3267  **  curl_easy_perform helper function
3268  **/
3269
3270 value caml_curl_easy_perform(value conn)
3271 {
3272     CAMLparam1(conn);
3273     CURLcode result = CURLE_OK;
3274     Connection *connection = Connection_val(conn);
3275
3276     checkConnection(connection);
3277
3278     caml_enter_blocking_section();
3279     result = curl_easy_perform(connection->handle);
3280     caml_leave_blocking_section();
3281
3282     if (result != CURLE_OK)
3283         raiseError(connection, result);
3284
3285     CAMLreturn(Val_unit);
3286 }
3287
3288 /**
3289  **  curl_easy_cleanup helper function
3290  **/
3291
3292 value caml_curl_easy_cleanup(value conn)
3293 {
3294     CAMLparam1(conn);
3295     Connection *connection = Connection_val(conn);
3296
3297     checkConnection(connection);
3298
3299     removeConnection(connection, 0);
3300
3301     CAMLreturn(Val_unit);
3302 }
3303
3304 /**
3305  **  curl_easy_duphandle helper function
3306  **/
3307
3308 value caml_curl_easy_duphandle(value conn)
3309 {
3310     CAMLparam1(conn);
3311     CAMLlocal1(result);
3312     Connection *connection = Connection_val(conn);
3313
3314     checkConnection(connection);
3315
3316     result = caml_curl_alloc(duplicateConnection(connection));
3317
3318     CAMLreturn(result);
3319 }
3320
3321 /**
3322  **  curl_easy_getinfo helper function
3323  **/
3324
3325 enum GetInfoResultType {
3326     StringValue, LongValue, DoubleValue, StringListValue, StringListListValue,
3327     OCamlValue, /* keep last - no matching OCaml CURLINFO_ constructor */
3328 };
3329
3330 value convertStringList(struct curl_slist *p)
3331 {
3332     CAMLparam0();
3333     CAMLlocal3(result, current, next);
3334
3335     result = Val_emptylist;
3336     current = Val_emptylist;
3337     next = Val_emptylist;
3338
3339     while (p != NULL)
3340     {
3341         next = caml_alloc_tuple(2);
3342         Store_field(next, 0, caml_copy_string(p->data));
3343         Store_field(next, 1, Val_emptylist);
3344
3345         if (result == Val_emptylist)
3346             result = next;
3347
3348         if (current != Val_emptylist)
3349           Store_field(current, 1, next);
3350
3351         current = next;
3352
3353         p = p->next;
3354     }
3355
3356     CAMLreturn(result);
3357 }
3358
3359 value caml_curl_easy_getinfo(value conn, value option)
3360 {
3361     CAMLparam2(conn, option);
3362     CAMLlocal3(result, current, next);
3363     CURLcode curlResult;
3364     Connection *connection = Connection_val(conn);
3365     enum GetInfoResultType resultType;
3366     char *strValue = NULL;
3367     double doubleValue;
3368     long longValue;
3369     struct curl_slist *stringListValue = NULL;
3370 #if HAVE_DECL_CURLINFO_CERTINFO
3371     int i;
3372     union {
3373       struct curl_slist    *to_info;
3374       struct curl_certinfo *to_certinfo;
3375     } ptr;
3376 #endif
3377
3378     checkConnection(connection);
3379
3380     switch(Long_val(option))
3381     {
3382 #if HAVE_DECL_CURLINFO_EFFECTIVE_URL
3383     case 0: /* CURLINFO_EFFECTIVE_URL */
3384         resultType = StringValue;
3385
3386         curlResult = curl_easy_getinfo(connection->handle,
3387                                        CURLINFO_EFFECTIVE_URL,
3388                                        &strValue);
3389         break;
3390 #else
3391 #pragma message("libcurl does not provide CURLINFO_EFFECTIVE_URL")
3392 #endif
3393
3394 #if HAVE_DECL_CURLINFO_RESPONSE_CODE || HAVE_DECL_CURLINFO_HTTP_CODE
3395     case 1: /* CURLINFO_HTTP_CODE */
3396     case 2: /* CURLINFO_RESPONSE_CODE */
3397 #if HAVE_DECL_CURLINFO_RESPONSE_CODE
3398         resultType = LongValue;
3399
3400         curlResult = curl_easy_getinfo(connection->handle,
3401                                        CURLINFO_RESPONSE_CODE,
3402                                        &longValue);
3403 #else
3404         resultType = LongValue;
3405
3406         curlResult = curl_easy_getinfo(connection->handle,
3407                                        CURLINFO_HTTP_CODE,
3408                                        &longValue);
3409 #endif
3410         break;
3411 #endif
3412
3413 #if HAVE_DECL_CURLINFO_TOTAL_TIME
3414     case 3: /* CURLINFO_TOTAL_TIME */
3415         resultType = DoubleValue;
3416
3417         curlResult = curl_easy_getinfo(connection->handle,
3418                                        CURLINFO_TOTAL_TIME,
3419                                        &doubleValue);
3420         break;
3421 #endif
3422
3423 #if HAVE_DECL_CURLINFO_NAMELOOKUP_TIME
3424     case 4: /* CURLINFO_NAMELOOKUP_TIME */
3425         resultType = DoubleValue;
3426
3427         curlResult = curl_easy_getinfo(connection->handle,
3428                                        CURLINFO_NAMELOOKUP_TIME,
3429                                        &doubleValue);
3430         break;
3431 #endif
3432
3433 #if HAVE_DECL_CURLINFO_CONNECT_TIME
3434     case 5: /* CURLINFO_CONNECT_TIME */
3435         resultType = DoubleValue;
3436
3437         curlResult = curl_easy_getinfo(connection->handle,
3438                                        CURLINFO_CONNECT_TIME,
3439                                        &doubleValue);
3440         break;
3441 #endif
3442
3443 #if HAVE_DECL_CURLINFO_PRETRANSFER_TIME
3444     case 6: /* CURLINFO_PRETRANSFER_TIME */
3445         resultType = DoubleValue;
3446
3447         curlResult = curl_easy_getinfo(connection->handle,
3448                                        CURLINFO_PRETRANSFER_TIME,
3449                                        &doubleValue);
3450         break;
3451 #endif
3452
3453 #if HAVE_DECL_CURLINFO_SIZE_UPLOAD
3454     case 7: /* CURLINFO_SIZE_UPLOAD */
3455         resultType = DoubleValue;
3456
3457         curlResult = curl_easy_getinfo(connection->handle,
3458                                        CURLINFO_SIZE_UPLOAD,
3459                                        &doubleValue);
3460         break;
3461 #endif
3462
3463 #if HAVE_DECL_CURLINFO_SIZE_DOWNLOAD
3464     case 8: /* CURLINFO_SIZE_DOWNLOAD */
3465         resultType = DoubleValue;
3466
3467         curlResult = curl_easy_getinfo(connection->handle,
3468                                        CURLINFO_SIZE_DOWNLOAD,
3469                                        &doubleValue);
3470         break;
3471 #endif
3472
3473 #if HAVE_DECL_CURLINFO_SPEED_DOWNLOAD
3474     case 9: /* CURLINFO_SPEED_DOWNLOAD */
3475         resultType = DoubleValue;
3476
3477         curlResult = curl_easy_getinfo(connection->handle,
3478                                        CURLINFO_SPEED_DOWNLOAD,
3479                                        &doubleValue);
3480         break;
3481 #endif
3482
3483 #if HAVE_DECL_CURLINFO_SPEED_UPLOAD
3484     case 10: /* CURLINFO_SPEED_UPLOAD */
3485         resultType = DoubleValue;
3486
3487         curlResult = curl_easy_getinfo(connection->handle,
3488                                        CURLINFO_SPEED_UPLOAD,
3489                                        &doubleValue);
3490         break;
3491
3492 #endif
3493
3494 #if HAVE_DECL_CURLINFO_HEADER_SIZE
3495     case 11: /* CURLINFO_HEADER_SIZE */
3496         resultType = LongValue;
3497
3498         curlResult = curl_easy_getinfo(connection->handle,
3499                                        CURLINFO_HEADER_SIZE,
3500                                        &longValue);
3501         break;
3502 #endif
3503
3504 #if HAVE_DECL_CURLINFO_REQUEST_SIZE
3505     case 12: /* CURLINFO_REQUEST_SIZE */
3506         resultType = LongValue;
3507
3508         curlResult = curl_easy_getinfo(connection->handle,
3509                                        CURLINFO_REQUEST_SIZE,
3510                                        &longValue);
3511         break;
3512 #endif
3513
3514 #if HAVE_DECL_CURLINFO_SSL_VERIFYRESULT
3515     case 13: /* CURLINFO_SSL_VERIFYRESULT */
3516         resultType = LongValue;
3517
3518         curlResult = curl_easy_getinfo(connection->handle,
3519                                        CURLINFO_SSL_VERIFYRESULT,
3520                                        &longValue);
3521         break;
3522 #endif
3523
3524 #if HAVE_DECL_CURLINFO_FILETIME
3525     case 14: /* CURLINFO_FILETIME */
3526         resultType = DoubleValue;
3527
3528         curlResult = curl_easy_getinfo(connection->handle,
3529                                        CURLINFO_FILETIME,
3530                                        &longValue);
3531
3532         doubleValue = longValue;
3533         break;
3534 #endif
3535
3536 #if HAVE_DECL_CURLINFO_CONTENT_LENGTH_DOWNLOAD
3537     case 15: /* CURLINFO_CONTENT_LENGTH_DOWNLOAD */
3538         resultType = DoubleValue;
3539
3540         curlResult = curl_easy_getinfo(connection->handle,
3541                                        CURLINFO_CONTENT_LENGTH_DOWNLOAD,
3542                                        &doubleValue);
3543         break;
3544 #endif
3545
3546 #if HAVE_DECL_CURLINFO_CONTENT_LENGTH_UPLOAD
3547     case 16: /* CURLINFO_CONTENT_LENGTH_UPLOAD */
3548         resultType = DoubleValue;
3549
3550         curlResult = curl_easy_getinfo(connection->handle,
3551                                        CURLINFO_CONTENT_LENGTH_UPLOAD,
3552                                        &doubleValue);
3553         break;
3554 #endif
3555
3556 #if HAVE_DECL_CURLINFO_STARTTRANSFER_TIME
3557     case 17: /* CURLINFO_STARTTRANSFER_TIME */
3558         resultType = DoubleValue;
3559
3560         curlResult = curl_easy_getinfo(connection->handle,
3561                                        CURLINFO_STARTTRANSFER_TIME,
3562                                        &doubleValue);
3563         break;
3564 #endif
3565
3566 #if HAVE_DECL_CURLINFO_CONTENT_TYPE
3567     case 18: /* CURLINFO_CONTENT_TYPE */
3568         resultType = StringValue;
3569
3570         curlResult = curl_easy_getinfo(connection->handle,
3571                                        CURLINFO_CONTENT_TYPE,
3572                                        &strValue);
3573         break;
3574 #endif
3575
3576 #if HAVE_DECL_CURLINFO_REDIRECT_TIME
3577     case 19: /* CURLINFO_REDIRECT_TIME */
3578         resultType = DoubleValue;
3579
3580         curlResult = curl_easy_getinfo(connection->handle,
3581                                        CURLINFO_REDIRECT_TIME,
3582                                        &doubleValue);
3583         break;
3584 #endif
3585
3586 #if HAVE_DECL_CURLINFO_REDIRECT_COUNT
3587     case 20: /* CURLINFO_REDIRECT_COUNT */
3588         resultType = LongValue;
3589
3590         curlResult = curl_easy_getinfo(connection->handle,
3591                                        CURLINFO_REDIRECT_COUNT,
3592                                        &longValue);
3593         break;
3594 #endif
3595
3596     case 21: /* CURLINFO_PRIVATE */
3597         resultType = OCamlValue;
3598         curlResult = CURLE_OK;
3599         result = caml_alloc(1, StringValue);
3600         Store_field(result, 0, Field(connection->ocamlValues, Ocaml_PRIVATE));
3601         break;
3602
3603 #if HAVE_DECL_CURLINFO_HTTP_CONNECTCODE
3604     case 22: /* CURLINFO_HTTP_CONNECTCODE */
3605         resultType = LongValue;
3606
3607         curlResult = curl_easy_getinfo(connection->handle,
3608                                        CURLINFO_HTTP_CONNECTCODE,
3609                                        &longValue);
3610         break;
3611 #endif
3612
3613 #if HAVE_DECL_CURLINFO_HTTPAUTH_AVAIL
3614     case 23: /* CURLINFO_HTTPAUTH_AVAIL */
3615         resultType = LongValue;
3616
3617         curlResult = curl_easy_getinfo(connection->handle,
3618                                        CURLINFO_HTTPAUTH_AVAIL,
3619                                        &longValue);
3620         break;
3621 #endif
3622
3623 #if HAVE_DECL_CURLINFO_PROXYAUTH_AVAIL
3624     case 24: /* CURLINFO_PROXYAUTH_AVAIL */
3625         resultType = LongValue;
3626
3627         curlResult = curl_easy_getinfo(connection->handle,
3628                                        CURLINFO_PROXYAUTH_AVAIL,
3629                                        &longValue);
3630         break;
3631 #endif
3632
3633 #if HAVE_DECL_CURLINFO_OS_ERRNO
3634     case 25: /* CURLINFO_OS_ERRNO */
3635         resultType = LongValue;
3636
3637         curlResult = curl_easy_getinfo(connection->handle,
3638                                        CURLINFO_OS_ERRNO,
3639                                        &longValue);
3640         break;
3641 #endif
3642
3643 #if HAVE_DECL_CURLINFO_NUM_CONNECTS
3644     case 26: /* CURLINFO_NUM_CONNECTS */
3645         resultType = LongValue;
3646
3647         curlResult = curl_easy_getinfo(connection->handle,
3648                                        CURLINFO_NUM_CONNECTS,
3649                                        &longValue);
3650         break;
3651 #endif
3652
3653 #if HAVE_DECL_CURLINFO_SSL_ENGINES
3654     case 27: /* CURLINFO_SSL_ENGINES */
3655         resultType = StringListValue;
3656
3657         curlResult = curl_easy_getinfo(connection->handle,
3658                                        CURLINFO_SSL_ENGINES,
3659                                        &stringListValue);
3660         break;
3661 #endif
3662
3663 #if HAVE_DECL_CURLINFO_COOKIELIST
3664     case 28: /* CURLINFO_COOKIELIST */
3665         resultType = StringListValue;
3666
3667         curlResult = curl_easy_getinfo(connection->handle,
3668                                        CURLINFO_COOKIELIST,
3669                                        &stringListValue);
3670         break;
3671 #endif
3672
3673 #if HAVE_DECL_CURLINFO_LASTSOCKET
3674     case 29: /* CURLINFO_LASTSOCKET */
3675         resultType = LongValue;
3676
3677         curlResult = curl_easy_getinfo(connection->handle,
3678                                        CURLINFO_LASTSOCKET,
3679                                        &longValue);
3680         break;
3681 #endif
3682
3683 #if HAVE_DECL_CURLINFO_FTP_ENTRY_PATH
3684     case 30: /* CURLINFO_FTP_ENTRY_PATH */
3685         resultType = StringValue;
3686
3687         curlResult = curl_easy_getinfo(connection->handle,
3688                                        CURLINFO_FTP_ENTRY_PATH,
3689                                        &strValue);
3690         break;
3691 #endif
3692
3693 #if HAVE_DECL_CURLINFO_REDIRECT_URL
3694     case 31: /* CURLINFO_REDIRECT_URL */
3695         resultType = StringValue;
3696
3697         curlResult = curl_easy_getinfo(connection->handle,
3698                                        CURLINFO_REDIRECT_URL,
3699                                        &strValue);
3700         break;
3701 #else
3702 #pragma message("libcurl does not provide CURLINFO_REDIRECT_URL")
3703 #endif
3704
3705 #if HAVE_DECL_CURLINFO_PRIMARY_IP
3706     case 32: /* CURLINFO_PRIMARY_IP */
3707         resultType = StringValue;
3708
3709         curlResult = curl_easy_getinfo(connection->handle,
3710                                        CURLINFO_PRIMARY_IP,
3711                                        &strValue);
3712         break;
3713 #else
3714 #pragma message("libcurl does not provide CURLINFO_PRIMARY_IP")
3715 #endif
3716
3717 #if HAVE_DECL_CURLINFO_LOCAL_IP
3718     case 33: /* CURLINFO_LOCAL_IP */
3719         resultType = StringValue;
3720
3721         curlResult = curl_easy_getinfo(connection->handle,
3722                                        CURLINFO_LOCAL_IP,
3723                                        &strValue);
3724         break;
3725 #else
3726 #pragma message("libcurl does not provide CURLINFO_LOCAL_IP")
3727 #endif
3728
3729 #if HAVE_DECL_CURLINFO_LOCAL_PORT
3730     case 34: /* CURLINFO_LOCAL_PORT */
3731         resultType = LongValue;
3732
3733         curlResult = curl_easy_getinfo(connection->handle,
3734                                        CURLINFO_LOCAL_PORT,
3735                                        &longValue);
3736         break;
3737 #else
3738 #pragma message("libcurl does not provide CURLINFO_LOCAL_PORT")
3739 #endif
3740
3741 #if HAVE_DECL_CURLINFO_CONDITION_UNMET
3742     case 35: /* CURLINFO_CONDITION_UNMET */
3743         resultType = LongValue;
3744
3745         curlResult = curl_easy_getinfo(connection->handle,
3746                                        CURLINFO_CONDITION_UNMET,
3747                                        &longValue);
3748         break;
3749 #else
3750 #pragma message("libcurl does not provide CURLINFO_CONDITION_UNMET")
3751 #endif
3752 #if HAVE_DECL_CURLINFO_CERTINFO
3753     case 36: /* CURLINFO_CERTINFO */
3754         resultType = StringListListValue;
3755         ptr.to_info = NULL;
3756         curlResult = curl_easy_getinfo(connection->handle,
3757                                        CURLINFO_CERTINFO,
3758                                        &ptr.to_info);
3759
3760         result = Val_emptylist;
3761         current = Val_emptylist;
3762         next = Val_emptylist;
3763
3764         if (curlResult != CURLE_OK || !ptr.to_info)
3765           break;
3766
3767         for (i = 0; i < ptr.to_certinfo->num_of_certs; i++) {
3768           next = caml_alloc_tuple(2);
3769           Store_field(next, 0, convertStringList(ptr.to_certinfo->certinfo[i]));
3770           Store_field(next, 1, current);
3771           current = next;
3772         }
3773         break;
3774 #else
3775 #pragma message("libcurl does not provide CURLINFO_CERTINFO")
3776 #endif
3777     default:
3778         caml_failwith("Invalid CURLINFO Option");
3779         break;
3780     }
3781
3782     if (curlResult != CURLE_OK)
3783         raiseError(connection, curlResult);
3784
3785     switch (resultType)
3786     {
3787     case StringValue:
3788         result = caml_alloc(1, StringValue);
3789         Store_field(result, 0, caml_copy_string(strValue?strValue:""));
3790         break;
3791
3792     case LongValue:
3793         result = caml_alloc(1, LongValue);
3794         Store_field(result, 0, Val_long(longValue));
3795         break;
3796
3797     case DoubleValue:
3798         result = caml_alloc(1, DoubleValue);
3799         Store_field(result, 0, caml_copy_double(doubleValue));
3800         break;
3801
3802     case StringListValue:
3803         result = caml_alloc(1, StringListValue);
3804         Store_field(result, 0, convertStringList(stringListValue));
3805         curl_slist_free_all(stringListValue);
3806         break;
3807
3808     case StringListListValue:
3809         result = caml_alloc(1, StringListListValue);
3810         Store_field(result, 0, current);
3811         break;
3812
3813     case OCamlValue:
3814         break;
3815     }
3816
3817     CAMLreturn(result);
3818 }
3819
3820 /**
3821  **  curl_escape helper function
3822  **/
3823
3824 value caml_curl_escape(value str)
3825 {
3826     CAMLparam1(str);
3827     CAMLlocal1(result);
3828     char *curlResult;
3829
3830     curlResult = curl_escape(String_val(str), caml_string_length(str));
3831     result = caml_copy_string(curlResult);
3832     free(curlResult);
3833
3834     CAMLreturn(result);
3835 }
3836
3837 /**
3838  **  curl_unescape helper function
3839  **/
3840
3841 value caml_curl_unescape(value str)
3842 {
3843     CAMLparam1(str);
3844     CAMLlocal1(result);
3845     char *curlResult;
3846
3847     curlResult = curl_unescape(String_val(str), caml_string_length(str));
3848     result = caml_copy_string(curlResult);
3849     free(curlResult);
3850
3851     CAMLreturn(result);
3852 }
3853
3854 /**
3855  **  curl_getdate helper function
3856  **/
3857
3858 value caml_curl_getdate(value str, value now)
3859 {
3860     CAMLparam2(str, now);
3861     CAMLlocal1(result);
3862     time_t curlResult;
3863     time_t curlNow;
3864
3865     curlNow = (time_t)Double_val(now);
3866     curlResult = curl_getdate(String_val(str), &curlNow);
3867     result = caml_copy_double((double)curlResult);
3868
3869     CAMLreturn(result);
3870 }
3871
3872 /**
3873  **  curl_version helper function
3874  **/
3875
3876 value caml_curl_version(void)
3877 {
3878     CAMLparam0();
3879     CAMLlocal1(result);
3880     char *str;
3881
3882     str = curl_version();
3883     result = caml_copy_string(str);
3884
3885     CAMLreturn(result);
3886 }
3887
3888 struct CURLVersionBitsMapping
3889 {
3890     int code;
3891     char *name;
3892 };
3893
3894 struct CURLVersionBitsMapping versionBitsMap[] =
3895 {
3896     {CURL_VERSION_IPV6, "ipv6"},
3897     {CURL_VERSION_KERBEROS4, "kerberos4"},
3898     {CURL_VERSION_SSL, "ssl"},
3899     {CURL_VERSION_LIBZ, "libz"},
3900     {CURL_VERSION_NTLM, "ntlm"},
3901     {CURL_VERSION_GSSNEGOTIATE, "gssnegotiate"},
3902     {CURL_VERSION_DEBUG, "debug"},
3903     {CURL_VERSION_CURLDEBUG, "curldebug"},
3904     {CURL_VERSION_ASYNCHDNS, "asynchdns"},
3905     {CURL_VERSION_SPNEGO, "spnego"},
3906     {CURL_VERSION_LARGEFILE, "largefile"},
3907     {CURL_VERSION_IDN, "idn"},
3908     {CURL_VERSION_SSPI, "sspi"},
3909     {CURL_VERSION_CONV, "conv"},
3910 #if HAVE_DECL_CURL_VERSION_TLSAUTH_SRP
3911     {CURL_VERSION_TLSAUTH_SRP, "srp"},
3912 #endif
3913 #if HAVE_DECL_CURL_VERSION_NTLM_WB
3914     {CURL_VERSION_NTLM_WB, "wb"},
3915 #endif
3916 };
3917
3918 value caml_curl_version_info(value unit)
3919 {
3920   CAMLparam1(unit);
3921   CAMLlocal4(v, vlist, vnum, vfeatures);
3922   const char* const* p = NULL;
3923   size_t i = 0;
3924
3925   curl_version_info_data* data = curl_version_info(CURLVERSION_NOW);
3926   if (NULL == data) caml_failwith("curl_version_info");
3927
3928   vlist = Val_emptylist;
3929   for (p = data->protocols; NULL != *p; p++)
3930   {
3931     vlist = Val_cons(vlist, caml_copy_string(*p));
3932   }
3933
3934   vfeatures = Val_emptylist;
3935   for (i = 0; i < sizeof(versionBitsMap)/sizeof(versionBitsMap[0]); i++)
3936   {
3937     if (0 != (versionBitsMap[i].code & data->features))
3938       vfeatures = Val_cons(vfeatures, caml_copy_string(versionBitsMap[i].name));
3939   }
3940
3941   vnum = caml_alloc_tuple(3);
3942   Store_field(vnum,0,Val_int(0xFF & (data->version_num >> 16)));
3943   Store_field(vnum,1,Val_int(0xFF & (data->version_num >> 8)));
3944   Store_field(vnum,2,Val_int(0xFF & (data->version_num)));
3945
3946   v = caml_alloc_tuple(12);
3947   Store_field(v,0,caml_copy_string(data->version));
3948   Store_field(v,1,vnum);
3949   Store_field(v,2,caml_copy_string(data->host));
3950   Store_field(v,3,vfeatures);
3951   Store_field(v,4,data->ssl_version ? Val_some(caml_copy_string(data->ssl_version)) : Val_none);
3952   Store_field(v,5,data->libz_version ? Val_some(caml_copy_string(data->libz_version)) : Val_none);
3953   Store_field(v,6,vlist);
3954   Store_field(v,7,caml_copy_string((data->age >= 1 && data->ares) ? data->ares : ""));
3955   Store_field(v,8,Val_int((data->age >= 1) ? data->ares_num : 0));
3956   Store_field(v,9,caml_copy_string((data->age >= 2 && data->libidn) ? data->libidn : ""));
3957   Store_field(v,10,Val_int((data->age >= 3) ? data->iconv_ver_num : 0));
3958   Store_field(v,11,caml_copy_string((data->age >= 3 && data->libssh_version) ? data->libssh_version : ""));
3959
3960   CAMLreturn(v);
3961 }
3962
3963 value caml_curl_pause(value conn, value opts)
3964 {
3965   CAMLparam2(conn, opts);
3966   CAMLlocal4(v, vlist, vnum, vfeatures);
3967   Connection *connection = Connection_val(conn);
3968   int bitmask = 0;
3969   CURLcode result;
3970
3971   while (Val_emptylist != opts)
3972   {
3973     switch (Int_val(Field(opts,0)))
3974     {
3975       case 0: bitmask |= CURLPAUSE_SEND; break;
3976       case 1: bitmask |= CURLPAUSE_RECV; break;
3977       case 2: bitmask |= CURLPAUSE_ALL; break;
3978       default: caml_failwith("wrong pauseOption");
3979     }
3980     opts = Field(opts,1);
3981   }
3982
3983   result = curl_easy_pause(connection->handle,bitmask);
3984   if (result != CURLE_OK)
3985     raiseError(connection, result);
3986
3987   CAMLreturn(Val_unit);
3988 }
3989
3990 /*
3991  * Curl multi stack support
3992  *
3993  * Exported thin wrappers for libcurl are prefixed with caml_curl_multi_.
3994  * Other exported functions are prefixed with caml_curlm_, some of them
3995  * can/should be decomposed into smaller parts.
3996  */
3997
3998 struct ml_multi_handle
3999 {
4000   CURLM* handle;
4001   value values; /* callbacks */
4002 };
4003
4004 enum
4005 {
4006   curlmopt_socket_function,
4007   curlmopt_timer_function,
4008
4009   /* last, not used */
4010   multi_values_total
4011 };
4012
4013 typedef struct ml_multi_handle ml_multi_handle;
4014
4015 #define Multi_val(v) (*(ml_multi_handle**)Data_custom_val(v))
4016 #define CURLM_val(v) (Multi_val(v)->handle)
4017
4018 static struct custom_operations curl_multi_ops = {
4019   "ygrek.curl_multi",
4020   custom_finalize_default,
4021   custom_compare_default,
4022   custom_hash_default,
4023   custom_serialize_default,
4024   custom_deserialize_default,
4025 #if defined(custom_compare_ext_default)
4026   custom_compare_ext_default,
4027 #endif
4028 };
4029
4030 value caml_curl_multi_init(value unit)
4031 {
4032   CAMLparam1(unit);
4033   CAMLlocal1(v);
4034   ml_multi_handle* multi = (ml_multi_handle*)caml_stat_alloc(sizeof(ml_multi_handle));
4035   CURLM* h = curl_multi_init();
4036
4037   if (!h)
4038   {
4039     caml_stat_free(multi);
4040     caml_failwith("caml_curl_multi_init");
4041   }
4042
4043   multi->handle = h;
4044   multi->values = caml_alloc(multi_values_total, 0);
4045   caml_register_generational_global_root(&multi->values);
4046
4047   v = caml_alloc_custom(&curl_multi_ops, sizeof(ml_multi_handle*), 0, 1);
4048   Multi_val(v) = multi;
4049
4050   CAMLreturn(v);
4051 }
4052
4053 value caml_curl_multi_cleanup(value handle)
4054 {
4055   CAMLparam1(handle);
4056   ml_multi_handle* h = Multi_val(handle);
4057
4058   if (NULL == h)
4059     CAMLreturn(Val_unit);
4060
4061   caml_remove_generational_global_root(&h->values);
4062
4063   if (CURLM_OK != curl_multi_cleanup(h->handle))
4064     caml_failwith("caml_curl_multi_cleanup");
4065
4066   caml_stat_free(h);
4067   Multi_val(handle) = (ml_multi_handle*)NULL;
4068
4069   CAMLreturn(Val_unit);
4070 }
4071
4072 static CURL* curlm_remove_finished(CURLM* multi_handle, CURLcode* result)
4073 {
4074   int msgs_in_queue = 0;
4075
4076   while (1)
4077   {
4078     CURLMsg* msg = curl_multi_info_read(multi_handle, &msgs_in_queue);
4079     if (NULL == msg) return NULL;
4080     if (CURLMSG_DONE == msg->msg)
4081     {
4082       CURL* easy_handle = msg->easy_handle;
4083       if (result) *result = msg->data.result;
4084       if (CURLM_OK != curl_multi_remove_handle(multi_handle, easy_handle))
4085       {
4086         /*caml_failwith("curlm_remove_finished");*/
4087       }
4088       return easy_handle;
4089     }
4090   }
4091 }
4092
4093 value caml_curlm_remove_finished(value v_multi)
4094 {
4095   CAMLparam1(v_multi);
4096   CAMLlocal2(v_easy, v_tuple);
4097   CURL* handle;
4098   CURLM* multi_handle;
4099   CURLcode result;
4100   Connection* conn = NULL;
4101
4102   multi_handle = CURLM_val(v_multi);
4103
4104   caml_enter_blocking_section();
4105   handle = curlm_remove_finished(multi_handle,&result);
4106   caml_leave_blocking_section();
4107
4108   if (NULL == handle)
4109   {
4110     CAMLreturn(Val_none);
4111   }
4112   else
4113   {
4114     conn = getConnection(handle);
4115     if (conn->curl_ERRORBUFFER != NULL)
4116     {
4117         Store_field(Field(conn->ocamlValues, Ocaml_ERRORBUFFER), 0, caml_copy_string(conn->curl_ERRORBUFFER));
4118     }
4119     conn->refcount--;
4120     /* NB: same handle, but different block */
4121     v_easy = caml_curl_alloc(conn);
4122     v_tuple = caml_alloc(2, 0);
4123     Store_field(v_tuple,0,v_easy);
4124     Store_field(v_tuple,1,Val_int(result)); /* CURLcode */
4125     CAMLreturn(Val_some(v_tuple));
4126   }
4127 }
4128
4129 value caml_curl_multi_wait(value v_timeout_ms, value v_multi)
4130 {
4131   CAMLparam2(v_timeout_ms,v_multi);
4132   CURLM *multi_handle = CURLM_val(v_multi);
4133   int timeout_ms = Int_val(v_timeout_ms);
4134   int numfds = -1;
4135   CURLMcode ret;
4136
4137   caml_enter_blocking_section();
4138   ret = curl_multi_wait(multi_handle, NULL, 0, timeout_ms, &numfds);
4139   caml_leave_blocking_section();
4140
4141   if (ret != CURLM_OK) caml_failwith("caml_curl_multi_wait");
4142
4143   CAMLreturn(Val_bool(numfds != 0));
4144 }
4145
4146 value caml_curl_multi_add_handle(value v_multi, value v_easy)
4147 {
4148   CAMLparam2(v_multi,v_easy);
4149   CURLM* multi = CURLM_val(v_multi);
4150   Connection* conn = Connection_val(v_easy);
4151
4152   /* prevent collection of OCaml value while the easy handle is used
4153    and may invoke callbacks registered on OCaml side */
4154   conn->refcount++;
4155
4156   /* may invoke callbacks so need to be consistent with locks */
4157   caml_enter_blocking_section();
4158   if (CURLM_OK != curl_multi_add_handle(multi, conn->handle))
4159   {
4160     conn->refcount--; /* not added, revert */
4161     caml_leave_blocking_section();
4162     caml_failwith("caml_curl_multi_add_handle");
4163   }
4164   caml_leave_blocking_section();
4165
4166   CAMLreturn(Val_unit);
4167 }
4168
4169 value caml_curl_multi_remove_handle(value v_multi, value v_easy)
4170 {
4171   CAMLparam2(v_multi,v_easy);
4172   CURLM* multi = CURLM_val(v_multi);
4173   Connection* conn = Connection_val(v_easy);
4174
4175   /* may invoke callbacks so need to be consistent with locks */
4176   caml_enter_blocking_section();
4177   if (CURLM_OK != curl_multi_remove_handle(multi, conn->handle))
4178   {
4179     caml_leave_blocking_section();
4180     caml_failwith("caml_curl_multi_remove_handle");
4181   }
4182   conn->refcount--;
4183   caml_leave_blocking_section();
4184
4185   CAMLreturn(Val_unit);
4186 }
4187
4188 value caml_curl_multi_perform_all(value v_multi)
4189 {
4190   CAMLparam1(v_multi);
4191   int still_running = 0;
4192   CURLM* h = CURLM_val(v_multi);
4193
4194   caml_enter_blocking_section();
4195   while (CURLM_CALL_MULTI_PERFORM == curl_multi_perform(h, &still_running));
4196   caml_leave_blocking_section();
4197
4198   CAMLreturn(Val_int(still_running));
4199 }
4200
4201 /* currently curlCode repr tag matches CURLE_ value
4202  * this is exploited below, but generally should use errorMap */
4203
4204 value caml_curl_strerror(value v_code)
4205 {
4206   CAMLparam1(v_code);
4207   CAMLreturn(caml_copy_string(curl_easy_strerror((CURLcode)Int_val(v_code))));
4208 }
4209
4210 value caml_curl_int_of_curlCode(value v_code)
4211 {
4212   return v_code;
4213 }
4214
4215 value caml_curl_curlCode_of_int(value v)
4216 {
4217   return (Int_val(v) < sizeof(errorMap) / sizeof(errorMap[0]) ? Val_some(v) : Val_none);
4218 }
4219
4220 /*
4221  * Wrappers for the curl_multi_socket_action infrastructure
4222  * Based on curl hiperfifo.c example
4223  */
4224
4225 #ifdef _WIN32
4226 #ifndef Val_socket
4227 #define Val_socket(v) win_alloc_socket(v)
4228 #endif
4229 #ifndef Socket_val
4230 #error Socket_val not defined in unixsupport.h
4231 #endif
4232 #else /* _WIN32 */
4233 #ifndef Socket_val
4234 #define Socket_val(v) Long_val(v)
4235 #endif
4236 #ifndef Val_socket
4237 #define Val_socket(v) Val_int(v)
4238 #endif
4239 #endif  /* _WIN32 */
4240
4241 static void raise_multi_error(char const* msg)
4242 {
4243   static value* exception = NULL;
4244
4245   if (NULL == exception)
4246   {
4247     exception = caml_named_value("Curl.Multi.Error");
4248     if (NULL == exception) caml_invalid_argument("Curl.Multi.Error");
4249   }
4250
4251   caml_raise_with_string(*exception, msg);
4252 }
4253
4254 static void check_mcode(CURLMcode code)
4255 {
4256   char const *s = NULL;
4257   switch (code)
4258   {
4259     case CURLM_OK                  : return;
4260     case CURLM_CALL_MULTI_PERFORM  : s="CURLM_CALL_MULTI_PERFORM"; break;
4261     case CURLM_BAD_HANDLE          : s="CURLM_BAD_HANDLE";         break;
4262     case CURLM_BAD_EASY_HANDLE     : s="CURLM_BAD_EASY_HANDLE";    break;
4263     case CURLM_OUT_OF_MEMORY       : s="CURLM_OUT_OF_MEMORY";      break;
4264     case CURLM_INTERNAL_ERROR      : s="CURLM_INTERNAL_ERROR";     break;
4265     case CURLM_UNKNOWN_OPTION      : s="CURLM_UNKNOWN_OPTION";     break;
4266     case CURLM_LAST                : s="CURLM_LAST";               break;
4267     case CURLM_BAD_SOCKET          : s="CURLM_BAD_SOCKET";         break;
4268     default                        : s="CURLM_unknown";            break;
4269   }
4270   raise_multi_error(s);
4271 }
4272
4273 value caml_curl_multi_socket_action(value v_multi, value v_fd, value v_kind)
4274 {
4275   CAMLparam3(v_multi, v_fd, v_kind);
4276   CURLM* h = CURLM_val(v_multi);
4277   int still_running = 0;
4278   CURLMcode rc = CURLM_OK;
4279   curl_socket_t socket;
4280   int kind = 0;
4281
4282   if (Val_none == v_fd)
4283   {
4284     socket = CURL_SOCKET_TIMEOUT;
4285   }
4286   else
4287   {
4288     socket = Socket_val(Field(v_fd, 0));
4289   }
4290
4291   switch (Int_val(v_kind))
4292   {
4293     case 0 : break;
4294     case 1 : kind |= CURL_CSELECT_IN; break;
4295     case 2 : kind |= CURL_CSELECT_OUT; break;
4296     case 3 : kind |= CURL_CSELECT_IN | CURL_CSELECT_OUT; break;
4297     default:
4298       raise_multi_error("caml_curl_multi_socket_action");
4299   }
4300
4301 /*  fprintf(stdout,"fd %u kind %u\n",socket, kind); fflush(stdout); */
4302
4303   caml_enter_blocking_section();
4304   do {
4305     rc = curl_multi_socket_action(h, socket, kind, &still_running);
4306   } while (rc == CURLM_CALL_MULTI_PERFORM);
4307   caml_leave_blocking_section();
4308
4309   check_mcode(rc);
4310
4311   CAMLreturn(Val_int(still_running));
4312 }
4313
4314 value caml_curl_multi_socket_all(value v_multi)
4315 {
4316   CAMLparam1(v_multi);
4317   int still_running = 0;
4318   CURLMcode rc = CURLM_OK;
4319   CURLM* h = CURLM_val(v_multi);
4320
4321   caml_enter_blocking_section();
4322   do {
4323     rc = curl_multi_socket_all(h, &still_running);
4324   } while (rc == CURLM_CALL_MULTI_PERFORM);
4325   caml_leave_blocking_section();
4326
4327   check_mcode(rc);
4328
4329   CAMLreturn(Val_int(still_running));
4330 }
4331
4332 static int curlm_sock_cb(CURL *e, curl_socket_t sock, int what, void *cbp, void *sockp)
4333 {
4334   caml_leave_blocking_section();
4335
4336   CAMLparam0();
4337   CAMLlocal2(v_what,csock);
4338   (void)e;
4339   (void)sockp; /* not used */
4340
4341   /* v_what = Val_int(what); */
4342   switch (what)
4343   {
4344     case CURL_POLL_NONE   : v_what = Val_int(0); break;
4345     case CURL_POLL_IN     : v_what = Val_int(1); break;
4346     case CURL_POLL_OUT    : v_what = Val_int(2); break;
4347     case CURL_POLL_INOUT  : v_what = Val_int(3); break;
4348     case CURL_POLL_REMOVE : v_what = Val_int(4); break;
4349     default:
4350       fprintf(stderr, "curlm_sock_cb sock=%lld what=%d\n", (long long)sock, what);
4351       fflush(stderr);
4352       raise_multi_error("curlm_sock_cb"); /* FIXME exception from callback */
4353   }
4354   csock=Val_socket(sock);
4355   caml_callback2(Field(((ml_multi_handle*)cbp)->values,curlmopt_socket_function),
4356                  csock, v_what);
4357   CAMLdrop;
4358
4359   caml_enter_blocking_section();
4360   return 0;
4361 }
4362
4363 value caml_curl_multi_socketfunction(value v_multi, value v_cb)
4364 {
4365   CAMLparam2(v_multi, v_cb);
4366   ml_multi_handle* multi = Multi_val(v_multi);
4367
4368   Store_field(multi->values, curlmopt_socket_function, v_cb);
4369
4370   curl_multi_setopt(multi->handle, CURLMOPT_SOCKETFUNCTION, curlm_sock_cb);
4371   curl_multi_setopt(multi->handle, CURLMOPT_SOCKETDATA, multi);
4372
4373   CAMLreturn(Val_unit);
4374 }
4375
4376 static int curlm_timer_cb(CURLM *multi, long timeout_ms, void *userp)
4377 {
4378   caml_leave_blocking_section();
4379
4380   CAMLparam0();
4381   (void)multi;
4382   caml_callback(Field(((ml_multi_handle*)userp)->values,curlmopt_timer_function), Val_long(timeout_ms));
4383   CAMLdrop;
4384
4385   caml_enter_blocking_section();
4386   return 0;
4387 }
4388
4389 value caml_curl_multi_timerfunction(value v_multi, value v_cb)
4390 {
4391   CAMLparam2(v_multi, v_cb);
4392   ml_multi_handle* multi = Multi_val(v_multi);
4393
4394   Store_field(multi->values, curlmopt_timer_function, v_cb);
4395
4396   curl_multi_setopt(multi->handle, CURLMOPT_TIMERFUNCTION, curlm_timer_cb);
4397   curl_multi_setopt(multi->handle, CURLMOPT_TIMERDATA, multi);
4398
4399   CAMLreturn(Val_unit);
4400 }
4401
4402 value caml_curl_multi_timeout(value v_multi)
4403 {
4404   CAMLparam1(v_multi);
4405   long ms = 0;
4406   CURLMcode rc = CURLM_OK;
4407   ml_multi_handle* multi = Multi_val(v_multi);
4408
4409   rc = curl_multi_timeout(multi->handle, &ms);
4410
4411   check_mcode(rc);
4412
4413   CAMLreturn(Val_long(ms));
4414 }
4415
4416 #define SETMOPT_VAL_(func_name, curl_option, conv_val) \
4417 static void func_name(CURLM *handle, value option) \
4418 { \
4419     CAMLparam1(option); \
4420     CURLMcode result = CURLM_OK; \
4421 \
4422     result = curl_multi_setopt(handle, curl_option, conv_val(option)); \
4423 \
4424     check_mcode(result); \
4425 \
4426     CAMLreturn0; \
4427 }
4428
4429 #define SETMOPT_VAL(name, conv) SETMOPT_VAL_(handle_multi_##name, CURLMOPT_##name, conv)
4430 #define SETMOPT_BOOL(name) SETMOPT_VAL(name, Bool_val)
4431 #define SETMOPT_LONG(name) SETMOPT_VAL(name, Long_val)
4432 #define SETMOPT_INT64(name) SETMOPT_VAL(name, Int64_val)
4433
4434 long pipeliningMap[] =
4435 {
4436   0, /* CURLPIPE_NOTHING */
4437   1, /* CURLPIPE_HTTP1 */
4438   2, /* CURLPIPE_MULTIPLEX */
4439 };
4440
4441 static void handle_multi_PIPELINING(CURLM* handle, value option)
4442 {
4443   CAMLparam1(option);
4444   CURLMcode result = CURLM_OK;
4445
4446   long bits = convert_bit_list(pipeliningMap, sizeof(pipeliningMap) / sizeof(pipeliningMap[0]), option);
4447
4448   result = curl_multi_setopt(handle, CURLMOPT_PIPELINING, bits);
4449
4450   check_mcode(result);
4451
4452   CAMLreturn0;
4453 }
4454
4455 #if HAVE_DECL_CURLMOPT_MAXCONNECTS
4456 SETMOPT_LONG( MAXCONNECTS)
4457 #endif
4458
4459 #if HAVE_DECL_CURLMOPT_MAX_PIPELINE_LENGTH
4460 SETMOPT_LONG( MAX_PIPELINE_LENGTH)
4461 #endif
4462
4463 #if HAVE_DECL_CURLMOPT_MAX_HOST_CONNECTIONS
4464 SETMOPT_LONG( MAX_HOST_CONNECTIONS)
4465 #endif
4466
4467 typedef struct CURLMOptionMapping CURLMOptionMapping;
4468 #define OPT(name) { handle_multi_## name, "CURLMOPT_"#name}
4469 #define NO_OPT(name) { NULL, "CURLMOPT_"#name}
4470
4471 struct CURLMOptionMapping
4472 {
4473     void (*optionHandler)(CURLM *, value);
4474     char *name;
4475 };
4476
4477 CURLMOptionMapping implementedMOptionMap[] = {
4478   OPT( PIPELINING),
4479 #if HAVE_DECL_CURLMOPT_MAXCONNECTS
4480   OPT( MAXCONNECTS),
4481 #else
4482   NO_OPT( MAXCONNECTS),
4483 #endif
4484 #if HAVE_DECL_CURLMOPT_MAX_PIPELINE_LENGTH
4485   OPT( MAX_PIPELINE_LENGTH),
4486 #else
4487   NO_OPT( MAX_PIPELINE_LENGTH),
4488 #endif
4489 #if HAVE_DECL_CURLMOPT_MAX_HOST_CONNECTIONS
4490   OPT( MAX_HOST_CONNECTIONS),
4491 #else
4492   NO_OPT( MAX_HOST_CONNECTIONS),
4493 #endif
4494 };
4495
4496 value caml_curl_multi_setopt(value v_multi, value option)
4497 {
4498     CAMLparam2(v_multi, option);
4499     CAMLlocal1(data);
4500     CURLM *handle = Multi_val(v_multi)->handle;
4501     CURLMOptionMapping* thisOption = NULL;
4502     static value* exception = NULL;
4503
4504     data = Field(option, 0);
4505
4506     if (Tag_val(option) < sizeof(implementedMOptionMap)/sizeof(CURLMOptionMapping))
4507     {
4508       thisOption = &implementedMOptionMap[Tag_val(option)];
4509       if (thisOption->optionHandler)
4510       {
4511         thisOption->optionHandler(handle, data);
4512       }
4513       else
4514       {
4515         if (NULL == exception)
4516         {
4517           exception = caml_named_value("Curl.NotImplemented");
4518           if (NULL == exception) caml_invalid_argument("Curl.NotImplemented");
4519         }
4520
4521         caml_raise_with_string(*exception, thisOption->name);
4522       }
4523     }
4524     else
4525     {
4526       caml_failwith("Invalid CURLMOPT Option");
4527     }
4528
4529     CAMLreturn(Val_unit);
4530 }
4531
4532 struct used_enum
4533 {
4534   int last_used;
4535   int last;
4536   char const* name;
4537 };
4538
4539 #define CURL_ENUM(name,last_used) { CURL_ ## name ## _ ## last_used, CURL_ ## name ## _LAST, #name }
4540
4541 struct used_enum check_enums[] = {
4542   { CURLINFO_SSL_DATA_OUT, CURLINFO_END, "CURLINFO" },
4543 #if defined(CURL_HTTP_VERSION_2TLS) /* FIXME */
4544   CURL_ENUM(HTTP_VERSION, 2TLS),
4545 #endif
4546 };
4547
4548 value caml_curl_outdated_enums(value v_unit)
4549 {
4550   CAMLparam0();
4551   CAMLlocal1(v);
4552   size_t i;
4553
4554   v = Val_emptylist;
4555
4556   for (i = 0; i < sizeof(check_enums) / sizeof(struct used_enum); i++)
4557   {
4558     if (check_enums[i].last_used + 1 != check_enums[i].last)
4559     {
4560       v = Val_cons(v, caml_copy_string(check_enums[i].name));
4561     }
4562   }
4563
4564   CAMLreturn(v);
4565 }
4566
4567 #ifdef __cplusplus
4568 }
4569 #endif