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