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