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