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