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