## NAME

         curl_easy_setopt - Set curl easy-session options

## SYNOPSIS

         #include <curl/curl.h>

         CURLcode  curl_easy_setopt(CURL  *handle, CURLoption option,
         parameter);

## DESCRIPTION

         curl_easy_setopt() is used to tell libcurl  how  to  behave.
         Most  operations  in  libcurl  have  default actions, and by
         using the appropriate options to curl_easy_setopt,  you  can
         change  them.   All options are set with the option followed
         by a parameter. That parameter can be  a  long,  a  function
         pointer or an object pointer, all depending on what the spe
         cific option expects. Read  this  manual  carefully  as  bad
         input  values  may  cause  libcurl to behave badly!  You can
         only set one option in each function call. A typical  appli
         cation  uses  many  curl_easy_setopt()  calls  in  the setup
         phase.

         NOTE: strings passed to libcurl as 'char *' arguments,  will
         not  be  copied by the library. Instead you should keep them
         available until libcurl no longer needs them. Failing to  do
         so will cause very odd behavior or even crashes.

         NOTE2: options set with this function call are valid for the
         forthcoming data  transfers  that  are  performed  when  you
         invoke  curl_easy_perform.   The  options are not in any way
         reset between transfers, so if you want subsequent transfers
         with  different  options,  you  must change them between the
         transfers.

         The handle is the return code from  a  curl_easy_init(3)  or
         curl_easy_duphandle(3) call.

## OPTIONS

         The options are listed in a sort of random order, but you'll
         figure it out!

         CURLOPT_FILE
                 Data pointer to pass to  the  file  write  function.
                 Note  that if you specify the CURLOPT_WRITEFUNCTION,
                 this is the pointer you'll  get  as  input.  If  you
                 don't  use  a  callback, you must pass a 'FILE *' as
                 libcurl will pass  this  to  fwrite()  when  writing
                 data.

                 NOTE:  If  you're  using libcurl as a win32 DLL, you
                 MUST use the CURLOPT_WRITEFUNCTION if you  set  this
                 option or you will experience crashes.

         CURLOPT_WRITEFUNCTION
                 Function  pointer  that  should  match the following
                 prototype: size_t function( void *ptr, size_t  size,
                 size_t  nmemb,  void  *stream);  This  function gets
                 called by libcurl as soon as there is data available
                 to  pass  available that needs to be saved. The size
                 of the data pointed to by  ptr  is  size  multiplied
                 with  nmemb.   Return  the  number of bytes actually
                 taken care of.  If  that  amount  differs  from  the
                 amount  passed  to  your  function,  it'll signal an
                 error to the library and it will abort the  transfer
                 and return CURLE_WRITE_ERROR.

                 Set   the  stream  argument  with  the  CURLOPT_FILE
                 option.

                 NOTE: you will be passed as much data as possible in
                 all  invokes,  but  you  cannot  possibly  make  any
                 assumptions. It may be one byte,  it  may  be  thou
                 sands.

         CURLOPT_INFILE
                 Data pointer to pass to the file read function. Note
                 that if you specify the  CURLOPT_READFUNCTION,  this
                 is  the  pointer  you'll  get as input. If you don't
                 specify a read callback, this must be a  valid  FILE
                 *.

                 NOTE:  If  you're  using libcurl as a win32 DLL, you
                 MUST use a  CURLOPT_READFUNCTION  if  you  set  this
                 option.

         CURLOPT_READFUNCTION
                 Function  pointer  that  should  match the following
                 prototype: size_t function( void *ptr, size_t  size,
                 size_t  nmemb,  void  *stream);  This  function gets
                 called by libcurl as soon as it needs to  read  data
                 in  order  to  send  it  to  the peer. The data area
                 pointed at by the pointer ptr may be filled with  at
                 most  size  multiplied  with  nmemb number of bytes.
                 Your function must return the actual number of bytes
                 that  you  stored  in  that memory area. Returning 0
                 will signal end-of-file to the library and cause  it
                 to stop the current transfer.

         CURLOPT_INFILESIZE
                 When  uploading a file to a remote site, this option
                 should be used to tell  libcurl  what  the  expected
                 size of the infile is.

         CURLOPT_URL
                 The actual URL to deal with. The parameter should be
                 a char * to a zero  terminated  string.  The  string
                 must  remain  present until curl no longer needs it,
                 as it doesn't copy the string.

                 NOTE: this option is (the only one) required  to  be
                 set before curl_easy_perform(3) is called.

         CURLOPT_PROXY
                 Set  HTTP  proxy  to  use. The parameter should be a
                 char * to a zero terminated string holding the  host
                 name or dotted IP address. To specify port number in
                 this string, append :[port] to the end of  the  host
                 name.  The proxy string may be prefixed with [proto
                 col]:// since any such prefix will be  ignored.  The
                 proxy's port number may optionally be specified with
                 the separate option CURLOPT_PROXYPORT.

                 NOTE: when you tell the library to use a HTTP proxy,
                 libcurl  will  transparently  convert  operations to
                 HTTP even if you specify a FTP  URL  etc.  This  may
                 have an impact on what other features of the library
                 you can use, such as CURLOPT_QUOTE and  similar  FTP
                 specifics  that don't work unless you tunnel through
                 the HTTP proxy. Such  tunneling  is  activated  with
                 CURLOPT_HTTPPROXYTUNNEL.

                 NOTE2:  libcurl  respects  the environment variables
                 http_proxy, ftp_proxy,  all_proxy  etc,  if  any  of
                 those is set.

         CURLOPT_PROXYPORT
                 Pass  a  long with this option to set the proxy port
                 to connect to unless it is specified  in  the  proxy
                 string CURLOPT_PROXY.

         CURLOPT_HTTPPROXYTUNNEL
                 Set  the parameter to non-zero to get the library to
                 tunnel all operations through a  given  HTTP  proxy.
                 Note  that there is a big difference between using a
                 proxy and to tunnel through it. If  you  don't  know
                 what  this  means, you probably don't want this tun
                 neling option. (Added in libcurl 7.3)

         CURLOPT_VERBOSE
                 Set the parameter to non-zero to get the library  to
                 display a lot of verbose information about its oper
                 ations. Very  useful  for  libcurl  and/or  protocol
                 debugging and understanding.

                 You hardly ever want this set in production use, you
                 will almost always want this when  you  debug/report
                 problems.

         CURLOPT_HEADER
                 A  non-zero  parameter  tells the library to include
                 the header in the body output. This is only relevant
                 for  protocols  that actually have headers preceding
                 the data (like HTTP).

         CURLOPT_NOPROGRESS
                 A non-zero parameter tells the library  to  shut  of
                 the built-in progress meter completely.

                 NOTE:  future  versions  of libcurl is likely to not
                 have any built-in progress meter at all.

         CURLOPT_NOBODY
                 A  non-zero  parameter  tells  the  library  to  not
                 include  the  body-part  in the output. This is only
                 relevant for protocols that have separate header and
                 body parts.

         CURLOPT_FAILONERROR
                 A  non-zero  parameter  tells  the  library  to fail
                 silently if the HTTP code returned is  equal  to  or
                 larger  than  300.  The  default  action would be to
                 return the page normally, ignoring that code.

         CURLOPT_UPLOAD
                 A non-zero parameter tells the  library  to  prepare
                 for   an   upload.   The   CURLOPT_INFILE  and  CUR
                 LOPT_INFILESIZE are also interesting for uploads.

         CURLOPT_POST
                 A non-zero parameter tells the library to do a regu
                 lar  HTTP  post. This is a normal application/x-www-
                 form-urlencoded kind, which  is  the  most  commonly
                 used  one  by HTML forms. See the CURLOPT_POSTFIELDS
                 option for how to specify the data to post and  CUR
                 LOPT_POSTFIELDSIZE  in  how  to  set  the data size.
                 Starting with libcurl 7.8, this option is  obsolete.
                 Using  the CURLOPT_POSTFIELDS option will imply this
                 option.

         CURLOPT_FTPLISTONLY
                 A non-zero parameter tells the library to just  list
                 the  names  of  an ftp directory, instead of doing a
                 full  directory  listing  that  would  include  file
                 sizes, dates etc.

         CURLOPT_FTPAPPEND
                 A  non-zero parameter tells the library to append to
                 the remote file instead of  overwrite  it.  This  is
                 only useful when uploading to a ftp site.

         CURLOPT_NETRC
                 A  non-zero parameter tells the library to scan your
                 ~/.netrc file to find user name and password for the
                 remote  site  you  are about to access. Only machine
                 name, user name and password is taken  into  account
                 (init macros and similar things aren't supported).

                 Note:  libcurl does not verify that the file has the
                 correct properties set (as  the  standard  Unix  ftp
                 client does). It should only be readable by user.

         CURLOPT_FOLLOWLOCATION
                 A non-zero parameter tells the library to follow any
                 Location: header that the server sends as part of  a
                 HTTP header.

                 NOTE:  this  means that the library will re-send the
                 same request on the  new  location  and  follow  new
                 Location:  headers  all  the  way until no more such
                 headers are returned. CURLOPT_MAXREDIRS can be  used
                 to  limit  the number of redirects libcurl will fol
                 low.

         CURLOPT_TRANSFERTEXT
                 A non-zero parameter tells the library to use  ASCII
                 mode  for  ftp  transfers,  instead  of  the default
                 binary transfer. For LDAP transfers it gets the data
                 in  plain text instead of HTML and for win32 systems
                 it does not set the  stdout  to  binary  mode.  This
                 option  can  be  usable  when transferring text data
                 between systems  with  different  views  on  certain
                 characters, such as newlines or similar.

         CURLOPT_PUT
                 A  non-zero  parameter tells the library to use HTTP
                 PUT to transfer data. The data should  be  set  with
                 CURLOPT_INFILE and CURLOPT_INFILESIZE.

         CURLOPT_USERPWD
                 Pass  a  char  * as parameter, which should be [user
                 name]:[password] to use for the connection.  If  the
                 password  is  left out, you will be prompted for it.
                 CURLOPT_PASSWDFUNCTION can be used to set  your  own
                 prompt function.

         CURLOPT_PROXYUSERPWD
                 Pass  a  char  * as parameter, which should be [user
                 name]:[password] to use for the  connection  to  the
                 HTTP proxy. If the password is left out, you will be
                 prompted for it. CURLOPT_PASSWDFUNCTION can be  used
                 to set your own prompt function.

         CURLOPT_RANGE
                 Pass a char * as parameter, which should contain the
                 specified range you want. It should be in the format
                 "X-Y",  where X or Y may be left out. HTTP transfers
                 also support several intervals, separated with  com
                 mas  as  in  "X-Y,N-M".  Using this kind of multiple
                 intervals will cause the HTTP  server  to  send  the
                 response  document  in  pieces  (using standard MIME
                 separation techniques).

         CURLOPT_ERRORBUFFER
                 Pass a char * to a buffer that the libcurl may store
                 human  readable  error messages in. This may be more
                 helpful than just the return code from the  library.
                 The buffer must be at least CURL_ERROR_SIZE big.

                 Note:  if  the library does not return an error, the
                 buffer may not have been touched. Do not rely on the
                 contents in those cases.

         CURLOPT_TIMEOUT
                 Pass a long as parameter containing the maximum time
                 in seconds that you allow the libcurl transfer oper
                 ation  to  take.  Normally,  name lookups can take a
                 considerable time and limiting  operations  to  less
                 than  a  few  minutes risk aborting perfectly normal
                 operations. This option will cause curl to  use  the
                 SIGALRM to enable time-outing system calls.

                 NOTE: this does not work in Unix multi-threaded pro
                 grams, as it uses signals.

         CURLOPT_POSTFIELDS
                 Pass a char * as parameter, which should be the full
                 data  to  post  in  a HTTP post operation. This is a
                 normal application/x-www-form-urlencoded kind, which
                 is  the  most  commonly  used one by HTML forms. See
                 also  the  CURLOPT_POST.  Since  7.8,   using   CUR
                 LOPT_POSTFIELDS implies CURLOPT_POST.

                 Note:   to   make   multipart/formdata   posts  (aka
                 rfc1867-posts),  check  out   the   CURLOPT_HTTPPOST
                 option.

         CURLOPT_POSTFIELDSIZE
                 If  you want to post data to the server without let
                 ting libcurl do a strlen() to measure the data size,
                 this  option  must be used. When this option is used
                 you can post fully binary data, which  otherwise  is
                 likely  to  fail.  If  this size is set to zero, the
                 library will use strlen() to get the size. (Added in
                 libcurl 7.2)

         CURLOPT_REFERER
                 Pass a pointer to a zero terminated string as param
                 eter. It will be used to set the Referer: header  in
                 the http request sent to the remote server. This can
                 be used to fool servers or scripts. You can also set
                 any custom header with CURLOPT_HTTPHEADER.

         CURLOPT_USERAGENT
                 Pass a pointer to a zero terminated string as param
                 eter. It will be used to set the User-Agent:  header
                 in  the http request sent to the remote server. This
                 can be used to fool servers or scripts. You can also
                 set any custom header with CURLOPT_HTTPHEADER.

         CURLOPT_FTPPORT
                 Pass a pointer to a zero terminated string as param
                 eter. It will be used to get the IP address  to  use
                 for  the  ftp PORT instruction. The PORT instruction
                 tells the remote server to connect to our  specified
                 IP  address. The string may be a plain IP address, a
                 host name, an network interface name (under Unix) or
                 just  a  '-' letter to let the library use your sys
                 tems default IP address. Default FTP operations  are
                 passive, and thus won't use PORT.

         CURLOPT_LOW_SPEED_LIMIT
                 Pass  a  long as parameter. It contains the transfer
                 speed in bytes per second that the  transfer  should
                 be  below  during CURLOPT_LOW_SPEED_TIME seconds for
                 the library to consider it too slow and abort.

         CURLOPT_LOW_SPEED_TIME
                 Pass a long as parameter. It contains  the  time  in
                 seconds  that  the transfer should be below the CUR
                 LOPT_LOW_SPEED_LIMIT for the library to consider  it
                 too slow and abort.

         CURLOPT_RESUME_FROM
                 Pass  a long as parameter. It contains the offset in
                 number of bytes that you want the transfer to  start
                 from.

         CURLOPT_COOKIE
                 Pass a pointer to a zero terminated string as param
                 eter. It will be used to set a cookie  in  the  http
                 request.   The   format  of  the  string  should  be
                 [NAME]=[CONTENTS]; Where NAME is the cookie name.

         CURLOPT_HTTPHEADER
                 Pass a pointer to a linked list of HTTP  headers  to
                 pass  to the server in your HTTP request. The linked
                 list  should  be  a  fully  valid  list  of   struct
                 curl_slist   structs   properly   filled   in.   Use
                 curl_slist_append(3)  to   create   the   list   and
                 curl_slist_free_all(3)  to  clean up an entire list.
                 If you add a header that is otherwise generated  and
                 used  by  libcurl internally, your added one will be
                 used instead. If you add a header with  no  contents
                 as  in  'Accept:'  (no data on the right side of the
                 colon), the internally used  header  will  get  dis
                 abled. Thus, using this option you can add new head
                 ers, replace internal headers  and  remove  internal
                 headers.

                 NOTE:The most commonly replaced headers have "short
                 cuts" in the options CURLOPT_COOKIE,  CURLOPT_USERA
                 GENT and CURLOPT_REFERER.

         CURLOPT_HTTPPOST
                 Tells  libcurl  you  want  a multipart/formdata HTTP
                 POST to be made and you instruct what data  to  pass
                 on  to  the server.  Pass a pointer to a linked list
                 of HTTP post structs as parameter.  The linked  list
                 should  be  a  fully valid list of 'struct HttpPost'
                 structs properly filled in. The best and  most  ele
                 gant  way  to  do this, is to use curl_formadd(3) as
                 documented. The data  in  this  list  must  remained
                 intact  until  you close this curl handle again with
                 curl_easy_cleanup(3).

         CURLOPT_SSLCERT
                 Pass a pointer to a zero terminated string as param
                 eter.  The  string  should  be the file name of your
                 certificate. The default format is "PEM" and can  be
                 changed with CURLOPT_SSLCERTTYPE.

         CURLOPT_SSLCERTTYPE
                 Pass a pointer to a zero terminated string as param
                 eter. The string should be the format of  your  cer
                 tificate.  Supported  formats  are  "PEM" and "DER".
                 (Added in 7.9.3)

         CURLOPT_SSLCERTPASSWD
                 Pass a pointer to a zero terminated string as param
                 eter.  It  will  be used as the password required to
                 use the CURLOPT_SSLCERT certificate. If the password
                 is  not  supplied, you will be prompted for it. CUR
                 LOPT_PASSWDFUNCTION can be  used  to  set  your  own
                 prompt function.

                 NOTE:This option is replaced by CURLOPT_SSLKEYPASSWD
                 and only cept for backward compatibility. You  never
                 needed  a  pass phrase to load a certificate but you
                 need one to load your private key.

         CURLOPT_SSLKEY
                 Pass a pointer to a zero terminated string as param
                 eter.  The  string  should  be the file name of your
                 private key. The default format is "PEM" and can  be
                 changed with CURLOPT_SSLKEYTYPE. (Added in 7.9.3)

         CURLOPT_SSLKEYTYPE
                 Pass a pointer to a zero terminated string as param
                 eter. The string should be the format of  your  pri
                 vate  key.  Supported  formats  are "PEM", "DER" and
                 "ENG".  (Added in 7.9.3)

                 NOTE:The format "ENG" enables you to load  the  pri
                 vate  key  from  a  crypto engine. in this case CUR
                 LOPT_SSLKEY is used as an identifier passed  to  the
                 engine.  You have to set the crypto engine with CUR
                 LOPT_SSL_ENGINE.

         CURLOPT_SSLKEYASSWD
                 Pass a pointer to a zero terminated string as param
                 eter.  It  will  be used as the password required to
                 use the CURLOPT_SSLKEY private key. If the  password
                 is  not  supplied, you will be prompted for it. CUR
                 LOPT_PASSWDFUNCTION can be  used  to  set  your  own
                 prompt function.  (Added in 7.9.3)

         CURLOPT_SSL_ENGINE
                 Pass a pointer to a zero terminated string as param
                 eter. It will be used  as  the  identifier  for  the
                 crypto  engine you want to use for your private key.
                 (Added in 7.9.3)

                 NOTE:If  the  crypto  device   cannot   be   loaded,
                 CURLE_SSL_ENGINE_NOTFOUND is returned.

         CURLOPT_SSL_ENGINEDEFAULT
                 Sets  the  actual  crypto  engine as the default for
                 (asymetric) crypto operations. (Added in 7.9.3)

                 NOTE:If   the   crypto   device   cannot   be   set,
                 CURLE_SSL_ENGINE_SETFAILED is returned.

         CURLOPT_CRLF
                 Convert  Unix  newlines  to  CRLF  newlines  on  FTP
                 uploads.

         CURLOPT_QUOTE
                 Pass a pointer to a linked list of FTP  commands  to
                 pass  to  the  server prior to your ftp request. The
                 linked list should be a fully valid list of  'struct
                 curl_slist'   structs   properly   filled   in.  Use
                 curl_slist_append(3) to append strings (commands) to
                 the  list, and clear the entire list afterwards with
                 curl_slist_free_all(3). Disable this operation again
                 by setting a NULL to this option.

         CURLOPT_POSTQUOTE
                 Pass  a  pointer to a linked list of FTP commands to
                 pass to the server after your ftp transfer  request.
                 The  linked  list  should  be  a fully valid list of
                 struct curl_slist  structs  properly  filled  in  as
                 described  for CURLOPT_QUOTE. Disable this operation
                 again by setting a NULL to this option.

         CURLOPT_WRITEHEADER
                 Pass a pointer to be used to write the  header  part
                 of  the  received data to. If you don't use your own
                 callback to take care of the writing, this must be a
                 valid  FILE  *.  See also the CURLOPT_HEADERFUNCTION
                 option below on how to set a custom  get-all-headers
                 callback.

         CURLOPT_HEADERFUNCTION
                 Function  pointer  that  should  match the following
                 prototype: size_t function( void *ptr, size_t  size,
                 size_t  nmemb,  void  *stream);.  This function gets
                 called by libcurl  as  soon  as  there  is  received
                 header data that needs to be written down. The head
                 ers are guaranteed to be written one-by-one and only
                 complete  lines  are written. Parsing headers should
                 be easy enough using this.  The  size  of  the  data
                 pointed  to  by  ptr  is size multiplied with nmemb.
                 The pointer named stream will be the one you  passed
                 to  libcurl  with  the  CURLOPT_WRITEHEADER  option.
                 Return the  number  of  bytes  actually  written  or
                 return  -1  to  signal error to the library (it will
                 cause   it   to   abort   the   transfer   with    a
                 CURLE_WRITE_ERROR  return  code).  (Added in libcurl
                 7.7.2)

         CURLOPT_COOKIEFILE
                 Pass a pointer to a zero terminated string as param
                 eter.  It should contain the name of your file hold
                 ing cookie data. The cookie data may be in  Netscape
                 /  Mozilla  cookie data format or just regular HTTP-
                 style headers dumped to a file.

         CURLOPT_SSLVERSION
                 Pass a long as parameter. Set what version of SSL to
                 attempt  to use, 2 or 3. By default, the SSL library
                 will try to  solve  this  by  itself  although  some
                 servers  make  this  difficult  why you at times may
                 have to use this option.

         CURLOPT_TIMECONDITION
                 Pass a long as parameter. This defines how the  CUR
                 LOPT_TIMEVALUE  time  value  is treated. You can set
                 this  parameter  to  TIMECOND_IFMODSINCE  or   TIME
                 COND_IFUNMODSINCE.  This  is  a  HTTP-only  feature.
                 (TBD)

         CURLOPT_TIMEVALUE
                 Pass a long as parameter. This should be the time in
                 seconds  since 1 jan 1970, and the time will be used
                 as specified in  CURLOPT_TIMECONDITION  or  if  that
                 isn't   used,  it  will  be  TIMECOND_IFMODSINCE  by
                 default.

         CURLOPT_CUSTOMREQUEST
                 Pass a pointer to a zero terminated string as param
                 eter.  It  will  be user instead of GET or HEAD when
                 doing the HTTP request. This  is  useful  for  doing
                 DELETE  or other more or less obscure HTTP requests.
                 Don't do this at will, make sure  your  server  sup
                 ports the command first.

         CURLOPT_STDERR
                 Pass  a  FILE  * as parameter. This is the stream to
                 use instead  of  stderr  internally  when  reporting
                 errors.

         CURLOPT_INTERFACE
                 Pass  a  char * as parameter. This set the interface
                 name to use as outgoing network interface. The  name
                 can  be  an  interface name, an IP address or a host
                 name. (Added in libcurl 7.3)

         CURLOPT_KRB4LEVEL
                 Pass a char * as parameter. Set  the  krb4  security
                 level,  this also enables krb4 awareness.  This is a
                 string, 'clear',  'safe',  'confidential'  or  'pri
                 vate'.   If  the string is set but doesn't match one
                 of these, 'private' will be used. Set the string  to
                 NULL to disable kerberos4. The kerberos support only
                 works for FTP. (Added in libcurl 7.3)

         CURLOPT_PROGRESSFUNCTION
                 Function   pointer    that    should    match    the
                 curl_progress_callback     prototype     found    in
                 <curl/curl.h>. This function gets called by  libcurl
                 instead  of  its internal equivalent with a frequent
                 interval during data transfer.  Unknown/unused argu
                 ment  values  will  be set to zero (like if you only
                 download data,  the  upload  size  will  remain  0).
                 Returning  a  non-zero value from this callback will
                 cause libcurl  to  abort  the  transfer  and  return
                 CURLE_ABORTED_BY_CALLBACK.

         CURLOPT_PROGRESSDATA
                 Pass a pointer that will be untouched by libcurl and
                 passed as the first argument in the  progress  call
                 back set with CURLOPT_PROGRESSFUNCTION.

         CURLOPT_SSL_VERIFYPEER
                 Pass  a long that is set to a non-zero value to make
                 curl verify the peer's certificate. The  certificate
                 to  verify  against  must be specified with the CUR
                 LOPT_CAINFO option. (Added in 7.4.2)

         CURLOPT_CAINFO
                 Pass a char * to a zero terminated file naming hold
                 ing  the  certificate  to verify the peer with. This
                 only makes sense when used in combination  with  the
                 CURLOPT_SSL_VERIFYPEER option. (Added in 7.4.2)

         CURLOPT_PASSWDFUNCTION
                 Pass  a  pointer  to a curl_passwd_callback function
                 that will be called instead of the internal  one  if
                 libcurl requests a password. The function must match
                 this prototype: int  my_getpass(void  *client,  char
                 *prompt,  char*  buffer,  int  buflen );.  If set to
                 NULL, it equals to making the function always  fail.
                 If  the  function  returns a non-zero value, it will
                 abort the operation and  an  error  (CURLE_BAD_PASS
                 WORD_ENTERED) will be returned.  client is a generic
                 pointer, see CURLOPT_PASSWDDATA.  prompt is a  zero-
                 terminated  string  that  is  text that prefixes the
                 input request.  buffer is a pointer  to  data  where
                 the  entered password should be stored and buflen is
                 the maximum number of bytes that may be  written  in
                 the buffer.  (Added in 7.4.2)

         CURLOPT_PASSWDDATA
                 Pass  a void * to whatever data you want. The passed
                 pointer will be  the  first  argument  sent  to  the
                 specifed  CURLOPT_PASSWDFUNCTION function. (Added in
                 7.4.2)

         CURLOPT_FILETIME
                 Pass a long. If it is a non-zero value, libcurl will
                 attempt  to  get the modification date of the remote
                 document in this operation. This requires  that  the
                 remote  server  sends  the time or replies to a time
                 querying command. The curl_easy_getinfo(3)  function
                 with  the  CURLINFO_FILETIME  argument  can  be used
                 after a transfer to extract the  received  time  (if
                 any). (Added in 7.5)

         CURLOPT_MAXREDIRS
                 Pass  a long. The set number will be the redirection
                 limit. If that many redirections have been followed,
                 the    next    redirect    will   cause   an   error
                 (CURLE_TOO_MANY_REDIRECTS). This option  only  makes
                 sense  if  the CURLOPT_FOLLOWLOCATION is used at the
                 same time. (Added in 7.5)

         CURLOPT_MAXCONNECTS
                 Pass a long. The set number will be  the  persistant
                 connection  cache  size.  The set amount will be the
                 maximum  amount  of  simultaneous  connections  that
                 libcurl may cache between file transfers. Default is
                 5, and there isn't much point in changing this value
                 unless  you are perfectly aware of how this work and
                 changes libcurl's behaviour.

                 NOTE: if you already have performed  transfers  with
                 this curl handle, setting a smaller MAXCONNECTS than
                 before may cause  open  connections  to  get  closed
                 unnecessarily. (Added in 7.7)

         CURLOPT_CLOSEPOLICY
                 Pass  a  long.  This option sets what policy libcurl
                 should use when the connection cache is  filled  and
                 one of the open connections has to be closed to make
                 room for a new connection. This must be one  of  the
                 CURLCLOSEPOLICY_*    defines.    Use   CURLCLOSEPOL
                 ICY_LEAST_RECENTLY_USED to make  libcurl  close  the
                 connection  that  was least recently used, that con
                 nection is also least likely to be  capable  of  re-
                 use.  Use  CURLCLOSEPOLICY_OLDEST  to  make  libcurl
                 close the oldest connection, the one that  was  cre
                 ated  first  among the ones in the connection cache.
                 The other close policies are not support yet. (Added
                 in 7.7)

         CURLOPT_FRESH_CONNECT
                 Pass a long. Set to non-zero to make the next trans
                 fer use a new (fresh) connection by  force.  If  the
                 connection cache is full before this connection, one
                 of  the  existing  connections  will  be  closed  as
                 according  to  the  selected or default policy. This
                 option should be used with caution and only  if  you
                 understand  what  it  does.  Set  this  to 0 to have
                 libcurl  attempt  re-using  an  existing  connection
                 (default behavior).  (Added in 7.7)

         CURLOPT_FORBID_REUSE
                 Pass a long. Set to non-zero to make the next trans
                 fer explicitly close the connection when done.  Nor
                 mally,  libcurl keep all connections alive when done
                 with one transfer in case there comes  a  succeeding
                 one  that  can  re-use  them.  This option should be
                 used with caution and only if you understand what it
                 does.  Set  to 0 to have libcurl keep the connection
                 open for possibly later re-use  (default  behavior).
                 (Added in 7.7)

         CURLOPT_RANDOM_FILE
                 Pass  a  char  * to a zero terminated file name. The
                 file will be used to read from to  seed  the  random
                 engine  for  SSL. The more random the specified file
                 is, the more secure will the SSL connection  become.

         CURLOPT_EGDSOCKET
                 Pass  a  char  * to the zero terminated path name to
                 the Entropy Gathering Daemon socket. It will be used
                 to seed the random engine for SSL.

         CURLOPT_CONNECTTIMEOUT
                 Pass  a  long. It should contain the maximum time in
                 seconds that you allow the connection to the  server
                 to  take.   This  only  limits the connection phase,
                 once it has connected, this option  is  of  no  more
                 use.  Set  to zero to disable connection timeout (it
                 will then only  timeout  on  the  system's  internal
                 timeouts). See also the CURLOPT_TIMEOUT option.

                 NOTE: this does not work in unix multi-threaded pro
                 grams, as it uses signals.

         CURLOPT_HTTPGET
                 Pass a long. If the long is  non-zero,  this  forces
                 the  HTTP  request  to  get back to GET. Only really
                 usable if POST, PUT or a custom  request  have  been
                 used  previously  using the same curl handle. (Added
                 in 7.8.1)

         CURLOPT_SSL_VERIFYHOST
                 Pass a long. Set if we should verify the Common name
                 from  the peer certificate in the SSL handshake, set
                 1 to check existence, 2 to ensure  that  it  matches
                 the provided hostname. (Added in 7.8.1)

         CURLOPT_COOKIEJAR
                 Pass  a  file  name as char *, zero terminated. This
                 will make libcurl dump all internally known  cookies
                 to  the  specified file when curl_easy_cleanup(3) is
                 called. If no cookies are known,  no  file  will  be
                 created.  Specify  "-"  to  instead have the cookies
                 written to stdout.

         CURLOPT_SSL_CIPHER_LIST
                 Pass a char *, pointing to a zero terminated  string
                 holding  the list of ciphers to use for the SSL con
                 nection. The list must be syntactly correct, it con
                 sists  of  one  or  more cipher strings separated by
                 colons. Commas or spaces are also acceptable separa
                 tors  but colons are normally used, , - and + can be
                 used as operators. Valid examples  of  cipher  lists
                 include    'RC4-SHA',    ´SHA1+DES´,   'TLSv1'   and
                 'DEFAULT'. The default list is normally set when you
                 compile OpenSSL.

                 You'll  find more details about cipher lists on this
                 URL: http://www.openssl.org/docs/apps/ciphers.html

         CURLOPT_HTTP_VERSION
                 Pass a long, set to  one  of  the  values  described
                 below.  They  force libcurl to use the specific HTTP
                 versions. This is not sensible to do unless you have
                 a good reason.

                 CURL_HTTP_VERSION_NONE
                      We  don't  care  about what version the library
                      uses. libcurl will use whatever it thinks  fit.

                 CURL_HTTP_VERSION_1_0
                      Enforce HTTP 1.0 requests.

                 CURL_HTTP_VERSION_1_1
                      Enforce HTTP 1.1 requests.

         CURLOPT_FTP_USE_EPSV
                 Pass a long. If the value is non-zero, it tells curl
                 to use the EPSV command when doing passive FTP down
                 loads  (which is always does by default). Using EPSV
                 means that it will first attempt to use EPSV  before
                 using  PASV,  but  if  you pass FALSE (zero) to this
                 option, it will not try using EPSV, only plain PASV.

## RETURN VALUE

         CURLE_OK (zero) means that the option was set properly, non-
         zero means an error occurred as <curl/curl.h> defines.

## SEE ALSO

         curl_easy_init(3), curl_easy_cleanup(3),

## BUGS

         If you find any bugs, or just have questions,  subscribe  to
         one of the mailing lists and post. We won't bite.