curl-helper.c

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