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