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".

     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.

     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".

             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.

     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.

             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.

             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
             connection.  The  list must be syntactly correct, it
             consists 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.







Man(1) output converted with man2html