;;
;; Copyright 2017 Aldo Nicolas Bruno
;;
;; Licensed under the Apache License, Version 2.0 (the "License");
;; you may not use this file except in compliance with the License.
;; You may obtain a copy of the License at
;;
;;     http://www.apache.org/licenses/LICENSE-2.0
;;
;; Unless required by applicable law or agreed to in writing, software
;; distributed under the License is distributed on an "AS IS" BASIS,
;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
;; See the License for the specific language governing permissions and
;; limitations under the License.

(library (curl)
  (export curl-global-init
	  curl-easy-init
	  curl-easy-perform
	  curl-easy-setopt/function
	  curl-easy-setopt/offset
	  curl-easy-setopt/scheme-object
	  curl-easy-setopt/object
	  curl-easy-setopt/string
	  curl-easy-setopt/long
	  curl-easy-cleanup
	  curl-slist-free-all
	  curl-slist-append
	  curl_slist
	  
	  curl-read-callback
	  curl-write-callback

	  CURLUSESSL
	  
	  CURL_GLOBAL_SSL
	  CURL_GLOBAL_WIN32
	  CURL_GLOBAL_ALL
	  CURL_GLOBAL_NOTHING
	  CURL_GLOBAL_DEFAULT
	  CURL_GLOBAL_ACK_EINTR 
	  CURLFTP_CREATE_DIR_NONE
	  CURLFTP_CREATE_DIR
	  CURLFTP_CREATE_DIR_RETRY

	  CURLOPT_WRITEDATA CURLOPT_URL CURLOPT_PORT CURLOPT_PROXY
	  CURLOPT_USERPWD CURLOPT_PROXYUSERPWD CURLOPT_RANGE CURLOPT_READDATA
	  CURLOPT_ERRORBUFFER CURLOPT_WRITEFUNCTION CURLOPT_READFUNCTION
	  CURLOPT_TIMEOUT CURLOPT_INFILESIZE CURLOPT_POSTFIELDS CURLOPT_REFERER
	  CURLOPT_FTPPORT CURLOPT_USERAGENT CURLOPT_LOW_SPEED_LIMIT
	  CURLOPT_LOW_SPEED_TIME CURLOPT_RESUME_FROM CURLOPT_COOKIE
	  CURLOPT_HTTPHEADER CURLOPT_HTTPPOST CURLOPT_SSLCERT CURLOPT_KEYPASSWD
	  CURLOPT_CRLF CURLOPT_QUOTE CURLOPT_HEADERDATA CURLOPT_COOKIEFILE
	  CURLOPT_SSLVERSION CURLOPT_TIMECONDITION CURLOPT_TIMEVALUE
	  CURLOPT_CUSTOMREQUEST CURLOPT_STDERR CURLOPT_POSTQUOTE
	  CURLOPT_OBSOLETE40 CURLOPT_VERBOSE CURLOPT_HEADER CURLOPT_NOPROGRESS
	  CURLOPT_NOBODY CURLOPT_FAILONERROR CURLOPT_UPLOAD CURLOPT_POST
	  CURLOPT_DIRLISTONLY CURLOPT_APPEND CURLOPT_NETRC
	  CURLOPT_FOLLOWLOCATION CURLOPT_TRANSFERTEXT CURLOPT_PUT
	  CURLOPT_PROGRESSFUNCTION CURLOPT_PROGRESSDATA CURLOPT_AUTOREFERER
	  CURLOPT_PROXYPORT CURLOPT_POSTFIELDSIZE CURLOPT_HTTPPROXYTUNNEL
	  CURLOPT_INTERFACE CURLOPT_KRBLEVEL CURLOPT_SSL_VERIFYPEER
	  CURLOPT_CAINFO CURLOPT_MAXREDIRS CURLOPT_FILETIME
	  CURLOPT_TELNETOPTIONS CURLOPT_MAXCONNECTS CURLOPT_OBSOLETE72
	  CURLOPT_FRESH_CONNECT CURLOPT_FORBID_REUSE CURLOPT_RANDOM_FILE
	  CURLOPT_EGDSOCKET CURLOPT_CONNECTTIMEOUT CURLOPT_HEADERFUNCTION
	  CURLOPT_HTTPGET CURLOPT_SSL_VERIFYHOST CURLOPT_COOKIEJAR
	  CURLOPT_SSL_CIPHER_LIST CURLOPT_HTTP_VERSION CURLOPT_FTP_USE_EPSV
	  CURLOPT_SSLCERTTYPE CURLOPT_SSLKEY CURLOPT_SSLKEYTYPE
	  CURLOPT_SSLENGINE CURLOPT_SSLENGINE_DEFAULT
	  CURLOPT_DNS_USE_GLOBAL_CACHE CURLOPT_DNS_CACHE_TIMEOUT
	  CURLOPT_PREQUOTE CURLOPT_DEBUGFUNCTION CURLOPT_DEBUGDATA
	  CURLOPT_COOKIESESSION CURLOPT_CAPATH CURLOPT_BUFFERSIZE
	  CURLOPT_NOSIGNAL CURLOPT_SHARE CURLOPT_PROXYTYPE
	  CURLOPT_ACCEPT_ENCODING CURLOPT_PRIVATE CURLOPT_HTTP200ALIASES
	  CURLOPT_UNRESTRICTED_AUTH CURLOPT_FTP_USE_EPRT CURLOPT_HTTPAUTH
	  CURLOPT_SSL_CTX_FUNCTION CURLOPT_SSL_CTX_DATA
	  CURLOPT_FTP_CREATE_MISSING_DIRS CURLOPT_PROXYAUTH
	  CURLOPT_FTP_RESPONSE_TIMEOUT CURLOPT_IPRESOLVE CURLOPT_MAXFILESIZE
	  CURLOPT_INFILESIZE_LARGE CURLOPT_RESUME_FROM_LARGE
	  CURLOPT_MAXFILESIZE_LARGE CURLOPT_NETRC_FILE CURLOPT_USE_SSL
	  CURLOPT_POSTFIELDSIZE_LARGE CURLOPT_TCP_NODELAY CURLOPT_FTPSSLAUTH
	  CURLOPT_IOCTLFUNCTION CURLOPT_IOCTLDATA CURLOPT_FTP_ACCOUNT
	  CURLOPT_COOKIELIST CURLOPT_IGNORE_CONTENT_LENGTH
	  CURLOPT_FTP_SKIP_PASV_IP CURLOPT_FTP_FILEMETHOD CURLOPT_LOCALPORT
	  CURLOPT_LOCALPORTRANGE CURLOPT_CONNECT_ONLY
	  CURLOPT_CONV_FROM_NETWORK_FUNCTION CURLOPT_CONV_TO_NETWORK_FUNCTION
	  CURLOPT_CONV_FROM_UTF8_FUNCTION CURLOPT_MAX_SEND_SPEED_LARGE
	  CURLOPT_MAX_RECV_SPEED_LARGE CURLOPT_FTP_ALTERNATIVE_TO_USER
	  CURLOPT_SOCKOPTFUNCTION CURLOPT_SOCKOPTDATA
	  CURLOPT_SSL_SESSIONID_CACHE CURLOPT_SSH_AUTH_TYPES
	  CURLOPT_SSH_PUBLIC_KEYFILE CURLOPT_SSH_PRIVATE_KEYFILE
	  CURLOPT_FTP_SSL_CCC CURLOPT_TIMEOUT_MS CURLOPT_CONNECTTIMEOUT_MS
	  CURLOPT_HTTP_TRANSFER_DECODING CURLOPT_HTTP_CONTENT_DECODING
	  CURLOPT_NEW_FILE_PERMS CURLOPT_NEW_DIRECTORY_PERMS CURLOPT_POSTREDIR
	  CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 CURLOPT_OPENSOCKETFUNCTION
	  CURLOPT_OPENSOCKETDATA CURLOPT_COPYPOSTFIELDS
	  CURLOPT_PROXY_TRANSFER_MODE CURLOPT_SEEKFUNCTION CURLOPT_SEEKDATA
	  CURLOPT_CRLFILE CURLOPT_ISSUERCERT CURLOPT_ADDRESS_SCOPE
	  CURLOPT_CERTINFO CURLOPT_USERNAME CURLOPT_PASSWORD
	  CURLOPT_PROXYUSERNAME CURLOPT_PROXYPASSWORD CURLOPT_NOPROXY
	  CURLOPT_TFTP_BLKSIZE CURLOPT_SOCKS5_GSSAPI_SERVICE
	  CURLOPT_SOCKS5_GSSAPI_NEC CURLOPT_PROTOCOLS CURLOPT_REDIR_PROTOCOLS
	  CURLOPT_SSH_KNOWNHOSTS CURLOPT_SSH_KEYFUNCTION CURLOPT_SSH_KEYDATA
	  CURLOPT_MAIL_FROM CURLOPT_MAIL_RCPT CURLOPT_FTP_USE_PRET
	  CURLOPT_RTSP_REQUEST CURLOPT_RTSP_SESSION_ID CURLOPT_RTSP_STREAM_URI
	  CURLOPT_RTSP_TRANSPORT CURLOPT_RTSP_CLIENT_CSEQ
	  CURLOPT_RTSP_SERVER_CSEQ CURLOPT_INTERLEAVEDATA
	  CURLOPT_INTERLEAVEFUNCTION CURLOPT_WILDCARDMATCH
	  CURLOPT_CHUNK_BGN_FUNCTION CURLOPT_CHUNK_END_FUNCTION
	  CURLOPT_FNMATCH_FUNCTION CURLOPT_CHUNK_DATA CURLOPT_FNMATCH_DATA
	  CURLOPT_RESOLVE CURLOPT_TLSAUTH_USERNAME CURLOPT_TLSAUTH_PASSWORD
	  CURLOPT_TLSAUTH_TYPE CURLOPT_TRANSFER_ENCODING
	  CURLOPT_CLOSESOCKETFUNCTION CURLOPT_CLOSESOCKETDATA
	  CURLOPT_GSSAPI_DELEGATION CURLOPT_DNS_SERVERS CURLOPT_ACCEPTTIMEOUT_MS
	  CURLOPT_TCP_KEEPALIVE CURLOPT_TCP_KEEPIDLE CURLOPT_TCP_KEEPINTVL
	  CURLOPT_SSL_OPTIONS CURLOPT_MAIL_AUTH CURLOPT_SASL_IR
	  CURLOPT_XFERINFOFUNCTION CURLOPT_XOAUTH2_BEARER CURLOPT_DNS_INTERFACE
	  CURLOPT_DNS_LOCAL_IP4 CURLOPT_DNS_LOCAL_IP6 CURLOPT_LOGIN_OPTIONS
	  CURLOPT_SSL_ENABLE_NPN CURLOPT_SSL_ENABLE_ALPN
	  CURLOPT_EXPECT_100_TIMEOUT_MS CURLOPT_PROXYHEADER CURLOPT_HEADEROPT
	  CURLOPT_PINNEDPUBLICKEY CURLOPT_UNIX_SOCKET_PATH
	  CURLOPT_SSL_VERIFYSTATUS CURLOPT_SSL_FALSESTART CURLOPT_PATH_AS_IS
	  CURLOPT_PROXY_SERVICE_NAME CURLOPT_SERVICE_NAME CURLOPT_PIPEWAIT
	  CURLOPT_DEFAULT_PROTOCOL CURLOPT_STREAM_WEIGHT CURLOPT_STREAM_DEPENDS
	  CURLOPT_STREAM_DEPENDS_E CURLOPT_TFTP_NO_OPTIONS CURLOPT_CONNECT_TO
	  CURLOPT_TCP_FASTOPEN

	  CURLPROTO_HTTP CURLPROTO_HTTPS CURLPROTO_FTP CURLPROTO_FTPS
	  CURLPROTO_SCP CURLPROTO_SFTP CURLPROTO_TELNET CURLPROTO_LDAP
	  CURLPROTO_LDAPS CURLPROTO_DICT CURLPROTO_FILE CURLPROTO_TFTP
	  CURLPROTO_IMAP CURLPROTO_IMAPS CURLPROTO_POP3 CURLPROTO_POP3S
	  CURLPROTO_SMTP CURLPROTO_SMTPS

	  CURLcode)
  
  (import (chezscheme)
	  (ffi-utils))

  (define-ftype CURL (struct))
  (define-ftype CURLoption int)

  (define CURLPROTO_HTTP  1)
  (define CURLPROTO_HTTPS 2)  
  (define CURLPROTO_FTP   4)
  (define CURLPROTO_FTPS  8)
  (define CURLPROTO_SCP  16)
  (define CURLPROTO_SFTP 32)
  (define CURLPROTO_TELNET 64)
  (define CURLPROTO_LDAP 128)
  (define CURLPROTO_LDAPS 256)
  (define CURLPROTO_DICT 512)
  (define CURLPROTO_FILE 1024)
  (define CURLPROTO_TFTP 2048)
  (define CURLPROTO_IMAP  4096)
  (define CURLPROTO_IMAPS 8192)
  (define CURLPROTO_POP3 16384)
  (define CURLPROTO_POP3S 32768)
  (define CURLPROTO_SMTP 65536)
  (define CURLPROTO_SMTPS 131072)
  
  (define-enumeration* CURLUSESSL
    (NONE TRY CONTROL ALL LAST))

  (define-enumeration* CURLcode
    (CURLE_OK
     CURLE_UNSUPPORTED_PROTOCOL   ;  /* 1 */
     CURLE_FAILED_INIT   ;           /* 2 */
     CURLE_URL_MALFORMAT   ;         /* 3 */
     CURLE_NOT_BUILT_IN   ;          /* 4 - [was obsoleted in August 2007 for
					; 7.17.0, reused in April 2011 for 7.21.5] */
     CURLE_COULDNT_RESOLVE_PROXY   ; /* 5 */
     CURLE_COULDNT_RESOLVE_HOST   ;  /* 6 */
     CURLE_COULDNT_CONNECT   ;       /* 7 */
     CURLE_WEIRD_SERVER_REPLY   ;    /* 8 */
     CURLE_REMOTE_ACCESS_DENIED   ;  /* 9 a service was denied by the server
					;  due to lack of access - when login fails
					;  this is not returned. */
     CURLE_FTP_ACCEPT_FAILED   ;     /* 10 - [was obsoleted in April 2006 for
					;  7.15.4, reused in Dec 2011 for 7.24.0]*/
     CURLE_FTP_WEIRD_PASS_REPLY   ;  /* 11 */
     CURLE_FTP_ACCEPT_TIMEOUT   ;    /* 12 - timeout occurred accepting server
					;  [was obsoleted in August 2007 for 7.17.0,
					;  reused in Dec 2011 for 7.24.0]*/
     CURLE_FTP_WEIRD_PASV_REPLY   ;  /* 13 */
     CURLE_FTP_WEIRD_227_FORMAT   ;  /* 14 */
     CURLE_FTP_CANT_GET_HOST   ;     /* 15 */
     CURLE_HTTP2   ;                 /* 16 - A problem in the http2 framing layer.
					;  [was obsoleted in August 2007 for 7.17.0,
					;  reused in July 2014 for 7.38.0] */
     CURLE_FTP_COULDNT_SET_TYPE   ;  /* 17 */
     CURLE_PARTIAL_FILE   ;          /* 18 */
     CURLE_FTP_COULDNT_RETR_FILE   ; /* 19 */
     CURLE_OBSOLETE20   ;            /* 20 - NOT USED */
     CURLE_QUOTE_ERROR   ;           /* 21 - quote command failure */
     CURLE_HTTP_RETURNED_ERROR   ;   /* 22 */
     CURLE_WRITE_ERROR   ;           /* 23 */
     CURLE_OBSOLETE24   ;            /* 24 - NOT USED */
     CURLE_UPLOAD_FAILED   ;         /* 25 - failed upload "command" */
     CURLE_READ_ERROR   ;            /* 26 - couldn't open/read from file */
     CURLE_OUT_OF_MEMORY   ;         /* 27 */
     ;; /* Note: CURLE_OUT_OF_MEMORY may sometimes indicate a conversion error
     ;;          instead of a memory allocation error if CURL_DOES_CONVERSIONS
     ;;          is defined
     ;; */
     CURLE_OPERATION_TIMEDOUT   ;    /* 28 - the timeout time was reached */
     CURLE_OBSOLETE29   ;            /* 29 - NOT USED */
     CURLE_FTP_PORT_FAILED   ;       /* 30 - FTP PORT operation failed */
     CURLE_FTP_COULDNT_USE_REST   ;  /* 31 - the REST command failed */
     CURLE_OBSOLETE32   ;            /* 32 - NOT USED */
     CURLE_RANGE_ERROR   ;           /* 33 - RANGE "command" didn't work */
     CURLE_HTTP_POST_ERROR   ;       /* 34 */
     CURLE_SSL_CONNECT_ERROR   ;     /* 35 - wrong when connecting with SSL */
     CURLE_BAD_DOWNLOAD_RESUME   ;   /* 36 - couldn't resume download */
     CURLE_FILE_COULDNT_READ_FILE   ;/* 37 */
     CURLE_LDAP_CANNOT_BIND   ;      /* 38 */
     CURLE_LDAP_SEARCH_FAILED   ;    /* 39 */
     CURLE_OBSOLETE40   ;            /* 40 - NOT USED */
     CURLE_FUNCTION_NOT_FOUND   ;    /* 41 */
     CURLE_ABORTED_BY_CALLBACK   ;   /* 42 */
     CURLE_BAD_FUNCTION_ARGUMENT   ; /* 43 */
     CURLE_OBSOLETE44   ;            /* 44 - NOT USED */
     CURLE_INTERFACE_FAILED   ;      /* 45 - CURLOPT_INTERFACE failed */
     CURLE_OBSOLETE46   ;            /* 46 - NOT USED */
     CURLE_TOO_MANY_REDIRECTS   ;    /* 47 - catch endless re-direct loops */
     CURLE_UNKNOWN_OPTION   ;        /* 48 - User specified an unknown option */
     CURLE_TELNET_OPTION_SYNTAX   ;  /* 49 - Malformed telnet option */
     CURLE_OBSOLETE50   ;            /* 50 - NOT USED */
     CURLE_PEER_FAILED_VERIFICATION ; /* 51 - peer's certificate or fingerprint
					;   wasn't verified fine */
     CURLE_GOT_NOTHING   ;           /* 52 - when this is a specific error */
     CURLE_SSL_ENGINE_NOTFOUND   ;   /* 53 - SSL crypto engine not found */
     CURLE_SSL_ENGINE_SETFAILED   ;  /* 54 - can not set SSL crypto engine as
					;  default */
     CURLE_SEND_ERROR   ;            /* 55 - failed sending network data */
     CURLE_RECV_ERROR   ;            /* 56 - failure in receiving network data */
     CURLE_OBSOLETE57   ;            /* 57 - NOT IN USE */
     CURLE_SSL_CERTPROBLEM   ;       /* 58 - problem with the local certificate */
     CURLE_SSL_CIPHER   ;            /* 59 - couldn't use specified cipher */
     CURLE_SSL_CACERT   ;            /* 60 - problem with the CA cert (path?) */
     CURLE_BAD_CONTENT_ENCODING   ;  /* 61 - Unrecognized/bad encoding */
     CURLE_LDAP_INVALID_URL   ;      /* 62 - Invalid LDAP URL */
     CURLE_FILESIZE_EXCEEDED   ;     /* 63 - Maximum file size exceeded */
     CURLE_USE_SSL_FAILED   ;        /* 64 - Requested FTP SSL level failed */
     CURLE_SEND_FAIL_REWIND   ;      /* 65 - Sending the data requires a rewind
					;   that failed */
     CURLE_SSL_ENGINE_INITFAILED   ; /* 66 - failed to initialise ENGINE */
     CURLE_LOGIN_DENIED   ;          /* 67 - user, password or similar was not
					;   accepted and we failed to login */
     CURLE_TFTP_NOTFOUND   ;         /* 68 - file not found on server */
     CURLE_TFTP_PERM   ;             /* 69 - permission problem on server */
     CURLE_REMOTE_DISK_FULL   ;      /* 70 - out of disk space on server */
     CURLE_TFTP_ILLEGAL   ;          /* 71 - Illegal TFTP operation */
     CURLE_TFTP_UNKNOWNID   ;        /* 72 - Unknown transfer ID */
     CURLE_REMOTE_FILE_EXISTS   ;    /* 73 - File already exists */
     CURLE_TFTP_NOSUCHUSER   ;       /* 74 - No such user */
     CURLE_CONV_FAILED   ;           /* 75 - conversion failed */
     CURLE_CONV_REQD   ;             /* 76 - caller must register conversion
					;   callbacks using curl_easy_setopt options
					;   CURLOPT_CONV_FROM_NETWORK_FUNCTION,
					;   CURLOPT_CONV_TO_NETWORK_FUNCTION, and
					;   CURLOPT_CONV_FROM_UTF8_FUNCTION */
     CURLE_SSL_CACERT_BADFILE   ;    /* 77 - could not load CACERT file, missing
					;    or wrong format */
     CURLE_REMOTE_FILE_NOT_FOUND   ; /* 78 - remote file not found */
     CURLE_SSH   ;                   /* 79 - error from the SSH layer, somewhat
					;     generic so the error message will be of
					;     interest when this has happened */

     CURLE_SSL_SHUTDOWN_FAILED   ;   /* 80 - Failed to shut down the SSL
					;      connection */
     CURLE_AGAIN   ;                 /* 81 - socket is not ready for send/recv,
					;         wait till it's ready and try again (Added
					;         in 7.18.2) */
     CURLE_SSL_CRL_BADFILE   ;       /* 82 - could not load CRL file, missing or
					;         wrong format (Added in 7.19.0) */
     CURLE_SSL_ISSUER_ERROR   ;      /* 83 - Issuer check failed.  (Added in
					;         7.19.0) */
     CURLE_FTP_PRET_FAILED   ;       /* 84 - a PRET command failed */
     CURLE_RTSP_CSEQ_ERROR   ;       /* 85 - mismatch of RTSP CSeq numbers */
     CURLE_RTSP_SESSION_ERROR   ;    /* 86 - mismatch of RTSP Session Ids */
     CURLE_FTP_BAD_FILE_LIST   ;     /* 87 - unable to parse FTP file list */
     CURLE_CHUNK_FAILED   ;          /* 88 - chunk callback reported error */
     CURLE_NO_CONNECTION_AVAILABLE  ;/* 89 - No connection available, the
					;    session will be queued */
     CURLE_SSL_PINNEDPUBKEYNOTMATCH ; /* 90 - specified pinned public key did not
					;    match */
     CURLE_SSL_INVALIDCERTSTATUS   ; /* 91 - invalid certificate status */
     CURLE_HTTP2_STREAM   ;          /* 92 - stream error in HTTP/2 framing layer
     */
     CURL_LAST))
					;/* never use! */))

  (define LONG 0)
  (define OBJECTPOINT 10000)
  (define STRINGPOINT 10000)
  (define FUNCTIONPOINT 20000)
  (define OFF_T 30000)

  (define-syntax CINIT
    (lambda (x)
      (define gen-id
	(lambda (template-id . args)
	  (datum->syntax
	   template-id
	   (string->symbol
	    (apply string-append
		   (map (lambda (x)
			  (if (string? x) x (symbol->string (syntax->datum x))))
			args))))))
      (syntax-case x ()
	[(_ name type value)
	 (with-syntax ([opt-name (gen-id #'name "CURLOPT_" #'name)])
	   #'(define opt-name (fx+ type value)))])))


  (CINIT WRITEDATA OBJECTPOINT 1)

					; The full URL to get/put 
  (CINIT URL STRINGPOINT 2)

					; Port number to connect to if other than default. 
  (CINIT PORT LONG 3)

					; Name of proxy to use. 
  (CINIT PROXY STRINGPOINT 4)

					; "user:password;options" to use when fetching. 
  (CINIT USERPWD STRINGPOINT 5)

					; "user:password" to use with proxy. 
  (CINIT PROXYUSERPWD STRINGPOINT 6)

					; Range to get specified as an ASCII string. 
  (CINIT RANGE STRINGPOINT 7)

					; not used 

					; Specified file stream to upload from (use as input): 
  (CINIT READDATA OBJECTPOINT 9)

  ;; /* Buffer to receive error messages in must be at least CURL_ERROR_SIZE
  ;;  * bytes big. If this is not used error messages go to stderr instead: */
  (CINIT ERRORBUFFER OBJECTPOINT 10)

  ;; /* Function that will be called to store the output (instead of fwrite). The
  ;;  * parameters will use fwrite() syntax make sure to follow them. */
  (CINIT WRITEFUNCTION FUNCTIONPOINT 11)

  ;; /* Function that will be called to read the input (instead of fread). The
  ;;  * parameters will use fread() syntax make sure to follow them. */
  (CINIT READFUNCTION FUNCTIONPOINT 12)

					; Time-out the read operation after this amount of seconds 
  (CINIT TIMEOUT LONG 13)

  ;; /* If the CURLOPT_INFILE is used this can be used to inform libcurl about
  ;;  * how large the file being sent really is. That allows better error
  ;;  * checking and better verifies that the upload was successful. -1 means
  ;;  * unknown size.
  ;;  *
  ;;  * For large file support there is also a _LARGE version of the key
  ;;  * which takes an off_t type allowing platforms with larger off_t
  ;;  * sizes to handle larger files.  See below for INFILESIZE_LARGE.
  ;;  */
  (CINIT INFILESIZE LONG 14)

					; POST static input fields. 
  (CINIT POSTFIELDS OBJECTPOINT 15)

					; Set the referrer page (needed by some CGIs) 
  (CINIT REFERER STRINGPOINT 16)

  ;; /* Set the FTP PORT string (interface name named or numerical IP address)
  ;;    Use i.e '-' to use default address. */
  (CINIT FTPPORT STRINGPOINT 17)

					; Set the User-Agent string (examined by some CGIs) 
  (CINIT USERAGENT STRINGPOINT 18)

  ;; /* If the download receives less than "low speed limit" bytes/second
  ;;  * during "low speed time" seconds the operations is aborted.
  ;;  * You could i.e if you have a pretty high speed connection abort if
  ;;  * it is less than 2000 bytes/sec during 20 seconds.
  ;;  */

					; Set the "low speed limit" 
  (CINIT LOW_SPEED_LIMIT LONG 19)

					; Set the "low speed time" 
  (CINIT LOW_SPEED_TIME LONG 20)

  ;; /* Set the continuation offset.
  ;;  *
  ;;  * Note there is also a _LARGE version of this key which uses
  ;;  * off_t types allowing for large file offsets on platforms which
  ;;  * use larger-than-32-bit off_t's.  Look below for RESUME_FROM_LARGE.
  ;;  */
  (CINIT RESUME_FROM LONG 21)

					; Set cookie in request: 
  (CINIT COOKIE STRINGPOINT 22)

  ;; /* This points to a linked list of headers struct curl_slist kind. This
  ;;    list is also used for RTSP (in spite of its name) */
  (CINIT HTTPHEADER OBJECTPOINT 23)

					; This points to a linked list of post entries struct curl_httppost 
  (CINIT HTTPPOST OBJECTPOINT 24)

					; name of the file keeping your private SSL-certificate 
  (CINIT SSLCERT STRINGPOINT 25)

					; password for the SSL or SSH private key 
  (CINIT KEYPASSWD STRINGPOINT 26)

					; send TYPE parameter? 
  (CINIT CRLF LONG 27)

					; send linked-list of QUOTE commands 
  (CINIT QUOTE OBJECTPOINT 28)

  ;; /* send FILE * or void * to store headers to if you use a callback it
  ;;    is simply passed to the callback unmodified */
  (CINIT HEADERDATA OBJECTPOINT 29)

  ;; /* point to a file to read the initial cookies from also enables
  ;;    "cookie awareness" */
  (CINIT COOKIEFILE STRINGPOINT 31)

  ;; /* What version to specifically try to use.
  ;;    See CURL_SSLVERSION defines below. */
  (CINIT SSLVERSION LONG 32)

					; What kind of HTTP time condition to use see defines 
  (CINIT TIMECONDITION LONG 33)

  ;; /* Time to use with the above condition. Specified in number of seconds
  ;;    since 1 Jan 1970 */
  (CINIT TIMEVALUE LONG 34)

					; 35 = OBSOLETE 

  ;; /* Custom request for customizing the get command like
  ;;    HTTP: DELETE TRACE and others
  ;;    FTP: to use a different list command
  ;;    */
  (CINIT CUSTOMREQUEST STRINGPOINT 36)

					; FILE handle to use instead of stderr 
  (CINIT STDERR OBJECTPOINT 37)

					; 38 is not used 

					; send linked-list of post-transfer QUOTE commands 
  (CINIT POSTQUOTE OBJECTPOINT 39)

  (CINIT OBSOLETE40 OBJECTPOINT 40) ; OBSOLETE do not use! 

  (CINIT VERBOSE LONG 41)      ; talk a lot 
  (CINIT HEADER LONG 42)       ; throw the header out too 
  (CINIT NOPROGRESS LONG 43)   ; shut off the progress meter 
  (CINIT NOBODY LONG 44)       ; use HEAD to get http document 
  (CINIT FAILONERROR LONG 45)  ; no output on http error codes >= 400 
  (CINIT UPLOAD LONG 46)       ; this is an upload 
  (CINIT POST LONG 47)         ; HTTP POST method 
  (CINIT DIRLISTONLY LONG 48)  ; bare names when listing directories 

  (CINIT APPEND LONG 50)       ; Append instead of overwrite on upload! 

  ;; /* Specify whether to read the user+password from the .netrc or the URL.
  ;;  * This must be one of the CURL_NETRC_* enums below. */
  (CINIT NETRC LONG 51)

  (CINIT FOLLOWLOCATION LONG 52)  ; use Location: Luke! 

  (CINIT TRANSFERTEXT LONG 53) ; transfer data in text/ASCII format 
  (CINIT PUT LONG 54)          ; HTTP PUT 

					; 55 = OBSOLETE 

  ;; /* DEPRECATED
  ;;  * Function that will be called instead of the internal progress display
  ;;  * function. This function should be defined as the curl_progress_callback
  ;;  * prototype defines. */
  (CINIT PROGRESSFUNCTION FUNCTIONPOINT 56)

  ;; /* Data passed to the CURLOPT_PROGRESSFUNCTION and CURLOPT_XFERINFOFUNCTION
  ;;    callbacks */
  (CINIT PROGRESSDATA OBJECTPOINT 57)
  (define CURLOPT_XFERINFODATA CURLOPT_PROGRESSDATA)

					; We want the referrer field set automatically when following locations 
  (CINIT AUTOREFERER LONG 58)

  ;; /* Port of the proxy can be set in the proxy string as well with:
  ;;    "[host]:[port]" */
  (CINIT PROXYPORT LONG 59)

					; size of the POST input data if strlen() is not good to use 
  (CINIT POSTFIELDSIZE LONG 60)

					; tunnel non-http operations through a HTTP proxy 
  (CINIT HTTPPROXYTUNNEL LONG 61)

					; Set the interface string to use as outgoing network interface 
  (CINIT INTERFACE STRINGPOINT 62)

  ;; /* Set the krb4/5 security level this also enables krb4/5 awareness.  This
  ;;  * is a string 'clear' 'safe' 'confidential' or 'private'.  If the string
  ;;  * is set but doesn't match one of these 'private' will be used.  */
  (CINIT KRBLEVEL STRINGPOINT 63)

					; Set if we should verify the peer in ssl handshake set 1 to verify. 
  (CINIT SSL_VERIFYPEER LONG 64)

  ;; /* The CApath or CAfile used to validate the peer certificate
  ;;    this option is used only if SSL_VERIFYPEER is true */
  (CINIT CAINFO STRINGPOINT 65)

					; 66 = OBSOLETE 
					; 67 = OBSOLETE 

					; Maximum number of http redirects to follow 
  (CINIT MAXREDIRS LONG 68)

  ;; /* Pass a long set to 1 to get the date of the requested document (if
  ;;    possible)! Pass a zero to shut it off. */
  (CINIT FILETIME LONG 69)

					; This points to a linked list of telnet options 
  (CINIT TELNETOPTIONS OBJECTPOINT 70)

					; Max amount of cached alive connections 
  (CINIT MAXCONNECTS LONG 71)

  (CINIT OBSOLETE72 LONG 72) ; OBSOLETE do not use! 

					; 73 = OBSOLETE 

  ;; /* Set to explicitly use a new connection for the upcoming transfer.
  ;;    Do not use this unless you're absolutely sure of this as it makes the
  ;;    operation slower and is less friendly for the network. */
  (CINIT FRESH_CONNECT LONG 74)

  ;; /* Set to explicitly forbid the upcoming transfer's connection to be re-used
  ;;    when done. Do not use this unless you're absolutely sure of this as it
  ;;    makes the operation slower and is less friendly for the network. */
  (CINIT FORBID_REUSE LONG 75)

  ;; /* Set to a file name that contains random data for libcurl to use to
  ;;    seed the random engine when doing SSL connects. */
  (CINIT RANDOM_FILE STRINGPOINT 76)

					; Set to the Entropy Gathering Daemon socket pathname 
  (CINIT EGDSOCKET STRINGPOINT 77)

  ;; /* Time-out connect operations after this amount of seconds if connects are
  ;;    OK within this time then fine... This only aborts the connect phase. */
  (CINIT CONNECTTIMEOUT LONG 78)

  ;; /* Function that will be called to store headers (instead of fwrite). The
  ;;  * parameters will use fwrite() syntax make sure to follow them. */
  (CINIT HEADERFUNCTION FUNCTIONPOINT 79)

  ;; /* Set this to force the HTTP request to get back to GET. Only really usable
  ;;    if POST PUT or a custom request have been used first.
  ;;  */
  (CINIT HTTPGET LONG 80)

  ;; /* Set if we should verify the Common name from the peer certificate in ssl
  ;;  * handshake set 1 to check existence 2 to ensure that it matches the
  ;;  * provided hostname. */
  (CINIT SSL_VERIFYHOST LONG 81)

  ;; /* Specify which file name to write all known cookies in after completed
  ;;    operation. Set file name to "-" (dash) to make it go to stdout. */
  (CINIT COOKIEJAR STRINGPOINT 82)

					; Specify which SSL ciphers to use 
  (CINIT SSL_CIPHER_LIST STRINGPOINT 83)

  ;; /* Specify which HTTP version to use! This must be set to one of the
  ;;    CURL_HTTP_VERSION* enums set below. */
  (CINIT HTTP_VERSION LONG 84)

  ;; /* Specifically switch on or off the FTP engine's use of the EPSV command. By
  ;;    default that one will always be attempted before the more traditional
  ;;    PASV command. */
  (CINIT FTP_USE_EPSV LONG 85)

					; type of the file keeping your SSL-certificate ("DER" "PEM" "ENG") 
  (CINIT SSLCERTTYPE STRINGPOINT 86)

					; name of the file keeping your private SSL-key 
  (CINIT SSLKEY STRINGPOINT 87)

					; type of the file keeping your private SSL-key ("DER" "PEM" "ENG") 
  (CINIT SSLKEYTYPE STRINGPOINT 88)

					; crypto engine for the SSL-sub system 
  (CINIT SSLENGINE STRINGPOINT 89)

  ;; /* set the crypto engine for the SSL-sub system as default
  ;;    the param has no meaning...
  ;;  */
  (CINIT SSLENGINE_DEFAULT LONG 90)

					; Non-zero value means to use the global dns cache 
  (CINIT DNS_USE_GLOBAL_CACHE LONG 91) ; DEPRECATED do not use! 

					; DNS cache timeout 
  (CINIT DNS_CACHE_TIMEOUT LONG 92)

					; send linked-list of pre-transfer QUOTE commands 
  (CINIT PREQUOTE OBJECTPOINT 93)

					; set the debug function 
  (CINIT DEBUGFUNCTION FUNCTIONPOINT 94)

					; set the data for the debug function 
  (CINIT DEBUGDATA OBJECTPOINT 95)

					; mark this as start of a cookie session 
  (CINIT COOKIESESSION LONG 96)

  ;; /* The CApath directory used to validate the peer certificate
  ;;    this option is used only if SSL_VERIFYPEER is true */
  (CINIT CAPATH STRINGPOINT 97)

					; Instruct libcurl to use a smaller receive buffer 
  (CINIT BUFFERSIZE LONG 98)

  ;; /* Instruct libcurl to not use any signal/alarm handlers even when using
  ;;    timeouts. This option is useful for multi-threaded applications.
  ;;    See libcurl-the-guide for more background information. */
  (CINIT NOSIGNAL LONG 99)

					; Provide a CURLShare for mutexing non-ts data 
  (CINIT SHARE OBJECTPOINT 100)

  ;; /* indicates type of proxy. accepted values are CURLPROXY_HTTP (default)
  ;;    CURLPROXY_SOCKS4 CURLPROXY_SOCKS4A and CURLPROXY_SOCKS5. */
  (CINIT PROXYTYPE LONG 101)

  ;; /* Set the Accept-Encoding string. Use this to tell a server you would like
  ;;    the response to be compressed. Before 7.21.6 this was known as
  ;;    CURLOPT_ENCODING */
  (CINIT ACCEPT_ENCODING STRINGPOINT 102)

					; Set pointer to private data 
  (CINIT PRIVATE OBJECTPOINT 103)

					; Set aliases for HTTP 200 in the HTTP Response header 
  (CINIT HTTP200ALIASES OBJECTPOINT 104)

  ;; /* Continue to send authentication (user+password) when following locations,
  ;;    even when hostname changed. This can potentially send off the name
  ;;    and password to whatever host the server decides. */
  (CINIT UNRESTRICTED_AUTH LONG 105)

  ;; /* Specifically switch on or off the FTP engine's use of the EPRT command (
  ;;    it also disables the LPRT attempt). By default those ones will always be
  ;;    attempted before the good old traditional PORT command. */
  (CINIT FTP_USE_EPRT LONG 106)

  ;; /* Set this to a bitmask value to enable the particular authentications
  ;;    methods you like. Use this in combination with CURLOPT_USERPWD.
  ;;    Note that setting multiple bits may cause extra network round-trips. */
  (CINIT HTTPAUTH LONG 107)

  ;; /* Set the ssl context callback function currently only for OpenSSL ssl_ctx
  ;;    in second argument. The function must be matching the
  ;;    curl_ssl_ctx_callback proto. */
  (CINIT SSL_CTX_FUNCTION FUNCTIONPOINT 108)

  ;; /* Set the userdata for the ssl context callback function's third
  ;;    argument */
  (CINIT SSL_CTX_DATA OBJECTPOINT 109)

  ;; /* FTP Option that causes missing dirs to be created on the remote server.
  ;;    In 7.19.4 we introduced the convenience enums for this option using the
  ;;    CURLFTP_CREATE_DIR prefix.
  ;; */
  (CINIT FTP_CREATE_MISSING_DIRS LONG 110)

  ;; /* Set this to a bitmask value to enable the particular authentications
  ;;    methods you like. Use this in combination with CURLOPT_PROXYUSERPWD.
  ;;    Note that setting multiple bits may cause extra network round-trips. */
  (CINIT PROXYAUTH LONG 111)

  ;; /* FTP option that changes the timeout in seconds associated with
  ;;    getting a response.  This is different from transfer timeout time and
  ;;    essentially places a demand on the FTP server to acknowledge commands
  ;;    in a timely manner. */
  (CINIT FTP_RESPONSE_TIMEOUT LONG 112)
  (define CURLOPT_SERVER_RESPONSE_TIMEOUT CURLOPT_FTP_RESPONSE_TIMEOUT)

  ;; /* Set this option to one of the CURL_IPRESOLVE_* defines (see below) to
  ;;    tell libcurl to resolve names to those IP versions only. This only has
  ;;    affect on systems with support for more than one i.e IPv4 _and_ IPv6. */
  (CINIT IPRESOLVE LONG 113)

  ;; /* Set this option to limit the size of a file that will be downloaded from
  ;;    an HTTP or FTP server.

  ;;    Note there is also _LARGE version which adds large file support for
  ;;    platforms which have larger off_t sizes.  See MAXFILESIZE_LARGE below. */
  (CINIT MAXFILESIZE LONG 114)

  ;; /* See the comment for INFILESIZE above but in short specifies
  ;;  * the size of the file being uploaded.  -1 means unknown.
  ;;  */
  (CINIT INFILESIZE_LARGE OFF_T 115)

  ;; /* Sets the continuation offset.  There is also a LONG version of this;
  ;;  * look above for RESUME_FROM.
  ;;  */
  (CINIT RESUME_FROM_LARGE OFF_T 116)

  ;; /* Sets the maximum size of data that will be downloaded from
  ;;  * an HTTP or FTP server.  See MAXFILESIZE above for the LONG version.
  ;;  */
  (CINIT MAXFILESIZE_LARGE OFF_T 117)

  ;; /* Set this option to the file name of your .netrc file you want libcurl
  ;;    to parse (using the CURLOPT_NETRC option). If not set libcurl will do
  ;;    a poor attempt to find the user's home directory and check for a .netrc
  ;;    file in there. */
  (CINIT NETRC_FILE STRINGPOINT 118)

  ;; /* Enable SSL/TLS for FTP pick one of:
  ;;    CURLUSESSL_TRY     - try using SSL proceed anyway otherwise
  ;;    CURLUSESSL_CONTROL - SSL for the control connection or fail
  ;;    CURLUSESSL_ALL     - SSL for all communication or fail
  ;; */
  (CINIT USE_SSL LONG 119)

					; The _LARGE version of the standard POSTFIELDSIZE option 
  (CINIT POSTFIELDSIZE_LARGE OFF_T 120)

					; Enable/disable the TCP Nagle algorithm 
  (CINIT TCP_NODELAY LONG 121)

					; 122 OBSOLETE used in 7.12.3. Gone in 7.13.0 
					; 123 OBSOLETE. Gone in 7.16.0 
					; 124 OBSOLETE used in 7.12.3. Gone in 7.13.0 
					; 125 OBSOLETE used in 7.12.3. Gone in 7.13.0 
					; 126 OBSOLETE used in 7.12.3. Gone in 7.13.0 
					; 127 OBSOLETE. Gone in 7.16.0 
					; 128 OBSOLETE. Gone in 7.16.0 

  ;; /* When FTP over SSL/TLS is selected (with CURLOPT_USE_SSL) this option
  ;;    can be used to change libcurl's default action which is to first try
  ;;    "AUTH SSL" and then "AUTH TLS" in this order and proceed when a OK
  ;;    response has been received.

  ;;    Available parameters are:
  ;;    CURLFTPAUTH_DEFAULT - let libcurl decide
  ;;    CURLFTPAUTH_SSL     - try "AUTH SSL" first then TLS
  ;;    CURLFTPAUTH_TLS     - try "AUTH TLS" first then SSL
  ;; */
  (CINIT FTPSSLAUTH LONG 129)

  (CINIT IOCTLFUNCTION FUNCTIONPOINT 130)
  (CINIT IOCTLDATA OBJECTPOINT 131)

					; 132 OBSOLETE. Gone in 7.16.0 
					; 133 OBSOLETE. Gone in 7.16.0 

  ;; /* zero terminated string for pass on to the FTP server when asked for
  ;;    "account" info */
  (CINIT FTP_ACCOUNT STRINGPOINT 134)

					; feed cookie into cookie engine 
  (CINIT COOKIELIST STRINGPOINT 135)

					; ignore Content-Length 
  (CINIT IGNORE_CONTENT_LENGTH LONG 136)

  ;; /* Set to non-zero to skip the IP address received in a 227 PASV FTP server
  ;;    response. Typically used for FTP-SSL purposes but is not restricted to
  ;;    that. libcurl will then instead use the same IP address it used for the
  ;;    control connection. */
  (CINIT FTP_SKIP_PASV_IP LONG 137)

  ;; /* Select "file method" to use when doing FTP see the curl_ftpmethod
  ;;    above. */
  (CINIT FTP_FILEMETHOD LONG 138)

					; Local port number to bind the socket to 
  (CINIT LOCALPORT LONG 139)

  ;; /* Number of ports to try including the first one set with LOCALPORT.
  ;;    Thus setting it to 1 will make no additional attempts but the first.
  ;; */
  (CINIT LOCALPORTRANGE LONG 140)

  ;; /* no transfer set up connection and let application use the socket by
  ;;    extracting it with CURLINFO_LASTSOCKET */
  (CINIT CONNECT_ONLY LONG 141)

  ;; /* Function that will be called to convert from the
  ;;    network encoding (instead of using the iconv calls in libcurl) */
  (CINIT CONV_FROM_NETWORK_FUNCTION FUNCTIONPOINT 142)

  ;; /* Function that will be called to convert to the
  ;;    network encoding (instead of using the iconv calls in libcurl) */
  (CINIT CONV_TO_NETWORK_FUNCTION FUNCTIONPOINT 143)

  ;; /* Function that will be called to convert from UTF8
  ;;    (instead of using the iconv calls in libcurl)
  ;;    Note that this is used only for SSL certificate processing */
  (CINIT CONV_FROM_UTF8_FUNCTION FUNCTIONPOINT 144)

					; if the connection proceeds too quickly then need to slow it down 
					; limit-rate: maximum number of bytes per second to send or receive 
  (CINIT MAX_SEND_SPEED_LARGE OFF_T 145)
  (CINIT MAX_RECV_SPEED_LARGE OFF_T 146)

					; Pointer to command string to send if USER/PASS fails. 
  (CINIT FTP_ALTERNATIVE_TO_USER STRINGPOINT 147)

					; callback function for setting socket options 
  (CINIT SOCKOPTFUNCTION FUNCTIONPOINT 148)
  (CINIT SOCKOPTDATA OBJECTPOINT 149)

  ;; /* set to 0 to disable session ID re-use for this transfer default is
  ;;    enabled (== 1) */
  (CINIT SSL_SESSIONID_CACHE LONG 150)

					; allowed SSH authentication methods 
  (CINIT SSH_AUTH_TYPES LONG 151)

					; Used by scp/sftp to do public/private key authentication 
  (CINIT SSH_PUBLIC_KEYFILE STRINGPOINT 152)
  (CINIT SSH_PRIVATE_KEYFILE STRINGPOINT 153)

					; Send CCC (Clear Command Channel) after authentication 
  (CINIT FTP_SSL_CCC LONG 154)

					; Same as TIMEOUT and CONNECTTIMEOUT but with ms resolution 
  (CINIT TIMEOUT_MS LONG 155)
  (CINIT CONNECTTIMEOUT_MS LONG 156)

  ;; /* set to zero to disable the libcurl's decoding and thus pass the raw body
  ;;    data to the application even when it is encoded/compressed */
  (CINIT HTTP_TRANSFER_DECODING LONG 157)
  (CINIT HTTP_CONTENT_DECODING LONG 158)

  ;; /* Permission used when creating new files and directories on the remote
  ;;    server for protocols that support it SFTP/SCP/FILE */
  (CINIT NEW_FILE_PERMS LONG 159)
  (CINIT NEW_DIRECTORY_PERMS LONG 160)

  ;; /* Set the behaviour of POST when redirecting. Values must be set to one
  ;;    of CURL_REDIR* defines below. This used to be called CURLOPT_POST301 */
  (CINIT POSTREDIR LONG 161)

					; used by scp/sftp to verify the host's public key 
  (CINIT SSH_HOST_PUBLIC_KEY_MD5 STRINGPOINT 162)

  ;; /* Callback function for opening socket (instead of socket(2)). Optionally,
  ;;    callback is able change the address or refuse to connect returning
  ;;    CURL_SOCKET_BAD.  The callback should have type
  ;;    curl_opensocket_callback */
  (CINIT OPENSOCKETFUNCTION FUNCTIONPOINT 163)
  (CINIT OPENSOCKETDATA OBJECTPOINT 164)

					; POST volatile input fields. 
  (CINIT COPYPOSTFIELDS OBJECTPOINT 165)

					; set transfer mode (;type=<a|i>) when doing FTP via an HTTP proxy 
  (CINIT PROXY_TRANSFER_MODE LONG 166)

					; Callback function for seeking in the input stream 
  (CINIT SEEKFUNCTION FUNCTIONPOINT 167)
  (CINIT SEEKDATA OBJECTPOINT 168)

					; CRL file 
  (CINIT CRLFILE STRINGPOINT 169)

					; Issuer certificate 
  (CINIT ISSUERCERT STRINGPOINT 170)

					; (IPv6) Address scope 
  (CINIT ADDRESS_SCOPE LONG 171)

  ;; /* Collect certificate chain info and allow it to get retrievable with
  ;;    CURLINFO_CERTINFO after the transfer is complete. */
  (CINIT CERTINFO LONG 172)

					; "name" and "pwd" to use when fetching. 
  (CINIT USERNAME STRINGPOINT 173)
  (CINIT PASSWORD STRINGPOINT 174)

					; "name" and "pwd" to use with Proxy when fetching. 
  (CINIT PROXYUSERNAME STRINGPOINT 175)
  (CINIT PROXYPASSWORD STRINGPOINT 176)

  ;; /* Comma separated list of hostnames defining no-proxy zones. These should
  ;;    match both hostnames directly and hostnames within a domain. For
  ;;    example local.com will match local.com and www.local.com but NOT
  ;;    notlocal.com or www.notlocal.com. For compatibility with other
  ;;    implementations of this .local.com will be considered to be the same as
  ;;    local.com. A single * is the only valid wildcard and effectively
  ;;    disables the use of proxy. */
  (CINIT NOPROXY STRINGPOINT 177)

					; block size for TFTP transfers 
  (CINIT TFTP_BLKSIZE LONG 178)

					; Socks Service 
  (CINIT SOCKS5_GSSAPI_SERVICE STRINGPOINT 179) ; DEPRECATED do not use! 

					; Socks Service 
  (CINIT SOCKS5_GSSAPI_NEC LONG 180)

  ;; /* set the bitmask for the protocols that are allowed to be used for the
  ;;    transfer which thus helps the app which takes URLs from users or other
  ;;    external inputs and want to restrict what protocol(s) to deal
  ;;    with. Defaults to CURLPROTO_ALL. */
  (CINIT PROTOCOLS LONG 181)

  ;; /* set the bitmask for the protocols that libcurl is allowed to follow to,
  ;;    as a subset of the CURLOPT_PROTOCOLS ones. That means the protocol needs
  ;;    to be set in both bitmasks to be allowed to get redirected to. Defaults
  ;;    to all protocols except FILE and SCP. */
  (CINIT REDIR_PROTOCOLS LONG 182)

					; set the SSH knownhost file name to use 
  (CINIT SSH_KNOWNHOSTS STRINGPOINT 183)

  ;; /* set the SSH host key callback must point to a curl_sshkeycallback
  ;;    function */
  (CINIT SSH_KEYFUNCTION FUNCTIONPOINT 184)

					; set the SSH host key callback custom pointer 
  (CINIT SSH_KEYDATA OBJECTPOINT 185)

					; set the SMTP mail originator 
  (CINIT MAIL_FROM STRINGPOINT 186)

					; set the list of SMTP mail receiver(s) 
  (CINIT MAIL_RCPT OBJECTPOINT 187)

					; FTP: send PRET before PASV 
  (CINIT FTP_USE_PRET LONG 188)

					; RTSP request method (OPTIONS SETUP PLAY etc...) 
  (CINIT RTSP_REQUEST LONG 189)

					; The RTSP session identifier 
  (CINIT RTSP_SESSION_ID STRINGPOINT 190)

					; The RTSP stream URI 
  (CINIT RTSP_STREAM_URI STRINGPOINT 191)

					; The Transport: header to use in RTSP requests 
  (CINIT RTSP_TRANSPORT STRINGPOINT 192)

					; Manually initialize the client RTSP CSeq for this handle 
  (CINIT RTSP_CLIENT_CSEQ LONG 193)

					; Manually initialize the server RTSP CSeq for this handle 
  (CINIT RTSP_SERVER_CSEQ LONG 194)

					; The stream to pass to INTERLEAVEFUNCTION. 
  (CINIT INTERLEAVEDATA OBJECTPOINT 195)

					; Let the application define a custom write method for RTP data 
  (CINIT INTERLEAVEFUNCTION FUNCTIONPOINT 196)

					; Turn on wildcard matching 
  (CINIT WILDCARDMATCH LONG 197)

  ;; /* Directory matching callback called before downloading of an
  ;;    individual file (chunk) started */
  (CINIT CHUNK_BGN_FUNCTION FUNCTIONPOINT 198)

  ;; /* Directory matching callback called after the file (chunk)
  ;;    was downloaded or skipped */
  (CINIT CHUNK_END_FUNCTION FUNCTIONPOINT 199)

					; Change match (fnmatch-like) callback for wildcard matching 
  (CINIT FNMATCH_FUNCTION FUNCTIONPOINT 200)

					; Let the application define custom chunk data pointer 
  (CINIT CHUNK_DATA OBJECTPOINT 201)

					; FNMATCH_FUNCTION user pointer 
  (CINIT FNMATCH_DATA OBJECTPOINT 202)

					; send linked-list of name:port:address sets 
  (CINIT RESOLVE OBJECTPOINT 203)

					; Set a username for authenticated TLS 
  (CINIT TLSAUTH_USERNAME STRINGPOINT 204)

					; Set a password for authenticated TLS 
  (CINIT TLSAUTH_PASSWORD STRINGPOINT 205)

					; Set authentication type for authenticated TLS 
  (CINIT TLSAUTH_TYPE STRINGPOINT 206)

  ;; /* Set to 1 to enable the "TE:" header in HTTP requests to ask for
  ;;    compressed transfer-encoded responses. Set to 0 to disable the use of TE:
  ;;    in outgoing requests. The current default is 0 but it might change in a
  ;;    future libcurl release.

  ;;    libcurl will ask for the compressed methods it knows of and if that
  ;;    isn't any it will not ask for transfer-encoding at all even if this
  ;;    option is set to 1.

  ;; */
  (CINIT TRANSFER_ENCODING LONG 207)

  ;; /* Callback function for closing socket (instead of close(2)). The callback
  ;;    should have type curl_closesocket_callback */
  (CINIT CLOSESOCKETFUNCTION FUNCTIONPOINT 208)
  (CINIT CLOSESOCKETDATA OBJECTPOINT 209)

					; allow GSSAPI credential delegation 
  (CINIT GSSAPI_DELEGATION LONG 210)

					; Set the name servers to use for DNS resolution 
  (CINIT DNS_SERVERS STRINGPOINT 211)

  ;; /* Time-out accept operations (currently for FTP only) after this amount
  ;;    of miliseconds. */
  (CINIT ACCEPTTIMEOUT_MS LONG 212)

					; Set TCP keepalive 
  (CINIT TCP_KEEPALIVE LONG 213)

					; non-universal keepalive knobs (Linux AIX HP-UX more) 
  (CINIT TCP_KEEPIDLE LONG 214)
  (CINIT TCP_KEEPINTVL LONG 215)

					; Enable/disable specific SSL features with a bitmask see CURLSSLOPT_* 
  (CINIT SSL_OPTIONS LONG 216)

					; Set the SMTP auth originator 
  (CINIT MAIL_AUTH STRINGPOINT 217)

					; Enable/disable SASL initial response 
  (CINIT SASL_IR LONG 218)

  ;; /* Function that will be called instead of the internal progress display
  ;;  * function. This function should be defined as the curl_xferinfo_callback
  ;;  * prototype defines. (Deprecates CURLOPT_PROGRESSFUNCTION) */
  (CINIT XFERINFOFUNCTION FUNCTIONPOINT 219)

					; The XOAUTH2 bearer token 
  (CINIT XOAUTH2_BEARER STRINGPOINT 220)

  ;; /* Set the interface string to use as outgoing network
  ;;  * interface for DNS requests.
  ;;  * Only supported by the c-ares DNS backend */
  (CINIT DNS_INTERFACE STRINGPOINT 221)

  ;; /* Set the local IPv4 address to use for outgoing DNS requests.
  ;;  * Only supported by the c-ares DNS backend */
  (CINIT DNS_LOCAL_IP4 STRINGPOINT 222)

  ;; /* Set the local IPv4 address to use for outgoing DNS requests.
  ;;  * Only supported by the c-ares DNS backend */
  (CINIT DNS_LOCAL_IP6 STRINGPOINT 223)

					; Set authentication options directly 
  (CINIT LOGIN_OPTIONS STRINGPOINT 224)

					; Enable/disable TLS NPN extension (http2 over ssl might fail without) 
  (CINIT SSL_ENABLE_NPN LONG 225)

					; Enable/disable TLS ALPN extension (http2 over ssl might fail without) 
  (CINIT SSL_ENABLE_ALPN LONG 226)

  ;; /* Time to wait for a response to a HTTP request containing an
  ;;  * Expect: 100-continue header before sending the data anyway. */
  (CINIT EXPECT_100_TIMEOUT_MS LONG 227)

  ;; /* This points to a linked list of headers used for proxy requests only,
  ;;    struct curl_slist kind */
  (CINIT PROXYHEADER OBJECTPOINT 228)

					; Pass in a bitmask of "header options" 
  (CINIT HEADEROPT LONG 229)

  ;; /* The public key in DER form used to validate the peer public key
  ;;    this option is used only if SSL_VERIFYPEER is true */
  (CINIT PINNEDPUBLICKEY STRINGPOINT 230)

					; Path to Unix domain socket 
  (CINIT UNIX_SOCKET_PATH STRINGPOINT 231)

					; Set if we should verify the certificate status. 
  (CINIT SSL_VERIFYSTATUS LONG 232)

					; Set if we should enable TLS false start. 
  (CINIT SSL_FALSESTART LONG 233)

					; Do not squash dot-dot sequences 
  (CINIT PATH_AS_IS LONG 234)

					; Proxy Service Name 
  (CINIT PROXY_SERVICE_NAME STRINGPOINT 235)

					; Service Name 
  (CINIT SERVICE_NAME STRINGPOINT 236)

					; Wait/don't wait for pipe/mutex to clarify 
  (CINIT PIPEWAIT LONG 237)

					; Set the protocol used when curl is given a URL without a protocol 
  (CINIT DEFAULT_PROTOCOL STRINGPOINT 238)

					; Set stream weight 1 - 256 (default is 16) 
  (CINIT STREAM_WEIGHT LONG 239)

					; Set stream dependency on another CURL handle 
  (CINIT STREAM_DEPENDS OBJECTPOINT 240)

					; Set E-xclusive stream dependency on another CURL handle 
  (CINIT STREAM_DEPENDS_E OBJECTPOINT 241)

					; Do not send any tftp option requests to the server 
  (CINIT TFTP_NO_OPTIONS LONG 242)

  ;; /* Linked-list of host:port:connect-to-host:connect-to-port,
  ;;    overrides the URL's host:port (only for the network layer) */
  (CINIT CONNECT_TO OBJECTPOINT 243)

					; Set TCP Fast Open 
  (CINIT TCP_FASTOPEN LONG 244)

  (define CURL_GLOBAL_SSL 1)
  (define CURL_GLOBAL_WIN32 2)
  (define CURL_GLOBAL_ALL (logior CURL_GLOBAL_SSL CURL_GLOBAL_WIN32))
  (define CURL_GLOBAL_NOTHING 0)
  (define CURL_GLOBAL_DEFAULT CURL_GLOBAL_ALL)
  (define CURL_GLOBAL_ACK_EINTR 4)

  (define CURLFTP_CREATE_DIR_NONE 0)
  (define CURLFTP_CREATE_DIR 1)
  (define CURLFTP_CREATE_DIR_RETRY 2)

  (define curl-easy-init (foreign-procedure "curl_easy_init" () (* CURL)))
  (define curl-easy-cleanup (foreign-procedure "curl_easy_cleanup" ((* CURL)) void ))

  (define-ftype curl_slist
    (struct
     [data (* char)]
     [next (* curl_slist)]))

  (define-ftype curl_off_t integer-64)

  (define curl-slist-append (foreign-procedure "curl_slist_append" ((* curl_slist) utf-8) (* curl_slist)))
  (define curl-slist-free-all (foreign-procedure "curl_slist_free_all" ((* curl_slist)) void))
  (define curl-easy-setopt/long (foreign-procedure "curl_easy_setopt" ((* CURL) CURLoption long) CURLcode-t) )
  (define curl-easy-setopt/string (foreign-procedure "curl_easy_setopt" ((* CURL) CURLoption utf-8) CURLcode-t))
  (define curl-easy-setopt/object (foreign-procedure "curl_easy_setopt" ((* CURL) CURLoption void*) CURLcode-t))
  (define curl-easy-setopt/scheme-object (foreign-procedure "curl_easy_setopt" ((* CURL) CURLoption scheme-object) CURLcode-t))
  (define curl-easy-setopt/offset (foreign-procedure "curl_easy_setopt" ((* CURL) CURLoption curl_off_t) CURLcode-t))
  (define curl-easy-setopt/function (foreign-procedure "curl_easy_setopt" ((* CURL) CURLoption void*) CURLcode-t))


  (define curl-global-init (foreign-procedure "curl_global_init" (long) CURLcode-t))

  (define (curl-easy-perform curl)
    (define f (foreign-procedure "curl_easy_perform" ((* CURL)) CURLcode-t))
    (define r (f curl))
    (unless (= r (CURLcode 'CURLE_OK))
      (error 'curl-easy-perform "failed" (CURLcode-ref r))))

  (define-ftype curl-read-callback (function (void* size_t size_t scheme-object) size_t))
  (define-ftype curl-write-callback (function (u8* size_t size_t scheme-object) size_t))

  
  ) ;library curl