| .\" ************************************************************************** |
| .\" * _ _ ____ _ |
| .\" * Project ___| | | | _ \| | |
| .\" * / __| | | | |_) | | |
| .\" * | (__| |_| | _ <| |___ |
| .\" * \___|\___/|_| \_\_____| |
| .\" * |
| .\" * Copyright (C) 1998 - 2004, Daniel Stenberg, <daniel@haxx.se>, et al. |
| .\" * |
| .\" * This software is licensed as described in the file COPYING, which |
| .\" * you should have received as part of this distribution. The terms |
| .\" * are also available at http://curl.haxx.se/docs/copyright.html. |
| .\" * |
| .\" * You may opt to use, copy, modify, merge, publish, distribute and/or sell |
| .\" * copies of the Software, and permit persons to whom the Software is |
| .\" * furnished to do so, under the terms of the COPYING file. |
| .\" * |
| .\" * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY |
| .\" * KIND, either express or implied. |
| .\" * |
| .\" * $Id$ |
| .\" ************************************************************************** |
| .\" |
| .TH curl_easy_setopt 3 "12 Mar 2004" "libcurl 7.11.1" "libcurl Manual" |
| .SH NAME |
| curl_easy_setopt - set options for a curl easy handle |
| .SH SYNOPSIS |
| #include <curl/curl.h> |
| |
| CURLcode curl_easy_setopt(CURL *handle, CURLoption option, parameter); |
| .SH DESCRIPTION |
| curl_easy_setopt() is used to tell libcurl how to behave. By using the |
| appropriate options to \fIcurl_easy_setopt\fP, you can change libcurl's |
| behavior. All options are set with the \fIoption\fP followed by a |
| \fIparameter\fP. That parameter can be a \fBlong\fP, a \fBfunction pointer\fP, |
| an \fBobject pointer\fP or a \fBcurl_off_t\fP, depending on what the specific |
| 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 application uses many curl_easy_setopt() calls in the setup phase. |
| |
| Options set with this function call are valid for all forthcoming transfers |
| performed using this \fIhandle\fP. 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. You can optionally reset all |
| options back to internal default with \fIcurl_easy_reset(3)\fP. |
| |
| \fBNOTE:\fP 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. libcurl will need them until you call \fIcurl_easy_cleanup(3)\fP or |
| you set the same option again to use a different pointer. |
| |
| The \fIhandle\fP is the return code from a \fIcurl_easy_init(3)\fP or |
| \fIcurl_easy_duphandle(3)\fP call. |
| .SH BEHAVIOR OPTIONS |
| .IP CURLOPT_VERBOSE |
| Set the parameter to non-zero to get the library to display a lot of verbose |
| information about its operations. Very useful for libcurl and/or protocol |
| debugging and understanding. The verbose information will be sent to stderr, |
| or the stream set with \fICURLOPT_STDERR\fP. |
| |
| You hardly ever want this set in production use, you will almost always want |
| this when you debug/report problems. Another neat option for debugging is the |
| \fICURLOPT_DEBUGFUNCTION\fP. |
| .IP 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). |
| .IP CURLOPT_NOPROGRESS |
| A non-zero parameter tells the library to shut off the built-in progress meter |
| completely. |
| |
| \fBNOTE:\fP future versions of libcurl is likely to not have any built-in |
| progress meter at all. |
| .IP CURLOPT_NOSIGNAL |
| Pass a long. If it is non-zero, libcurl will not use any functions that |
| install signal handlers or any functions that cause signals to be sent to the |
| process. This option is mainly here to allow multi-threaded unix applications |
| to still set/use all timeout options etc, without risking getting signals. |
| (Added in 7.10) |
| |
| Consider building libcurl with ares support to enable asynchronous DNS |
| lookups. It enables nice timeouts for name resolves without signals. |
| .PP |
| .SH CALLBACK OPTIONS |
| .IP CURLOPT_WRITEFUNCTION |
| Function pointer that should match the following prototype: \fBsize_t |
| function( void *ptr, size_t size, size_t nmemb, void *stream);\fP This |
| function gets called by libcurl as soon as there is data received that needs |
| to be saved. The size of the data pointed to by \fIptr\fP is \fIsize\fP |
| multiplied with \fInmemb\fP, it will not be zero terminated. 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 \fICURLE_WRITE_ERROR\fP. |
| |
| This function may be called with zero bytes data if the transfered file is |
| empty. |
| |
| Set the \fIstream\fP argument with the \fICURLOPT_WRITEDATA\fP option. |
| |
| \fBNOTE:\fP 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 |
| thousands. The maximum amount of data that can be passed to the write callback |
| is defined in the curl.h header file: CURL_MAX_WRITE_SIZE. |
| .IP CURLOPT_WRITEDATA |
| Data pointer to pass to the file write function. Note that if you specify the |
| \fICURLOPT_WRITEFUNCTION\fP, 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. |
| |
| \fBNOTE:\fP If you're using libcurl as a win32 DLL, you MUST use the |
| \fICURLOPT_WRITEFUNCTION\fP if you set this option or you will experience |
| crashes. |
| |
| This option is also known with the older name \fICURLOPT_FILE\fP, the name |
| \fICURLOPT_WRITEDATA\fP was introduced in 7.9.7. |
| .IP CURLOPT_READFUNCTION |
| Function pointer that should match the following prototype: \fBsize_t |
| function( void *ptr, size_t size, size_t nmemb, void *stream);\fP 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 \fIptr\fP may be |
| filled with at most \fIsize\fP multiplied with \fInmemb\fP 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. |
| |
| If you stop the current transfer by returning 0 "pre-maturely" (i.e before the |
| server expected it, like when you've told you will upload N bytes and you |
| upload less than N bytes), you may experience that the server "hangs" waiting |
| for the rest of the data that won't come. |
| |
| In libcurl 7.12.1 and later, the read callback may return |
| \fICURL_READFUNC_ABORT\fP to stop the current operation at once, with a |
| \fICURLE_ABORTED_BY_CALLBACK\fP error code from the transfer. |
| .IP CURLOPT_READDATA |
| Data pointer to pass to the file read function. Note that if you specify the |
| \fICURLOPT_READFUNCTION\fP, this is the pointer you'll get as input. If you |
| don't specify a read callback, this must be a valid FILE *. |
| |
| \fBNOTE:\fP If you're using libcurl as a win32 DLL, you MUST use a |
| \fICURLOPT_READFUNCTION\fP if you set this option. |
| |
| This option is also known with the older name \fICURLOPT_INFILE\fP, the name |
| \fICURLOPT_READDATA\fP was introduced in 7.9.7. |
| .IP CURLOPT_PROGRESSFUNCTION |
| Function pointer that should match the \fIcurl_progress_callback\fP prototype |
| found in \fI<curl/curl.h>\fP. This function gets called by libcurl instead of |
| its internal equivalent with a frequent interval during data transfer. |
| Unknown/unused argument 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 |
| \fICURLE_ABORTED_BY_CALLBACK\fP. |
| |
| Also note that \fICURLOPT_NOPROGRESS\fP must be set to FALSE to make this |
| function actually get called. |
| .IP CURLOPT_PROGRESSDATA |
| Pass a pointer that will be untouched by libcurl and passed as the first |
| argument in the progress callback set with \fICURLOPT_PROGRESSFUNCTION\fP. |
| .IP CURLOPT_HEADERFUNCTION |
| Function pointer that should match the following prototype: \fIsize_t |
| function( void *ptr, size_t size, size_t nmemb, void *stream);\fP. This |
| function gets called by libcurl as soon as there is received header data that |
| needs to be written down. The headers 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 \fIptr\fP is \fIsize\fP |
| multiplied with \fInmemb\fP. The pointer named \fIstream\fP will be the one |
| you passed to libcurl with the \fICURLOPT_WRITEHEADER\fP 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 \fICURLE_WRITE_ERROR\fP return |
| code). |
| .IP 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 \fICURLOPT_HEADERFUNCTION\fP option above on how to |
| set a custom get-all-headers callback. |
| .IP CURLOPT_DEBUGFUNCTION |
| Function pointer that should match the following prototype: \fIint |
| curl_debug_callback (CURL *, curl_infotype, char *, size_t, void *);\fP |
| \fICURLOPT_DEBUGFUNCTION\fP replaces the standard debug function used when |
| \fICURLOPT_VERBOSE \fP is in effect. This callback receives debug information, |
| as specified with the \fBcurl_infotype\fP argument. This function must return |
| 0. The data pointed to by the char * passed to this function WILL NOT be zero |
| terminated, but will be exactly of the size as told by the size_t argument. |
| |
| Available curl_infotype values: |
| .RS |
| .IP CURLINFO_TEXT |
| The data is informational text. |
| .IP CURLINFO_HEADER_IN |
| The data is header (or header-like) data received from the peer. |
| .IP CURLINFO_HEADER_OUT |
| The data is header (or header-like) data sent to the peer. |
| .IP CURLINFO_DATA_IN |
| The data is protocol data received from the peer. |
| .IP CURLINFO_DATA_OUT |
| The data is protocol data sent to the peer. |
| .RE |
| .IP CURLOPT_DEBUGDATA |
| Pass a pointer to whatever you want passed in to your |
| \fICURLOPT_DEBUGFUNCTION\fP in the last void * argument. This pointer is not |
| used by libcurl, it is only passed to the callback. |
| .IP CURLOPT_SSL_CTX_FUNCTION |
| Function pointer that should match the following prototype: \fBCURLcode |
| sslctxfun(CURL *curl, void *sslctx, void *parm);\fP This function gets called |
| by libcurl just before the initialization of an SSL connection after having |
| processed all other SSL related options to give a last chance to an |
| application to modify the behaviour of openssl's ssl initialization. The |
| \fIsslctx\fP parameter is actually a pointer to an openssl \fISSL_CTX\fP. If |
| an error is returned no attempt to establish a connection is made and the |
| perform operation will return the error code from this callback function. Set |
| the \fIparm\fP argument with the \fICURLOPT_SSL_CTX_DATA\fP option. This |
| option was introduced in 7.11.0. |
| |
| \fBNOTE:\fP To use this properly, a non-trivial amount of knowledge of the |
| openssl libraries is necessary. Using this function allows for example to use |
| openssl callbacks to add additional validation code for certificates, and even |
| to change the actual URI of an HTTPS request (example used in the lib509 test |
| case). See also the example section for a replacement of the key, certificate |
| and trust file settings. |
| .IP CURLOPT_SSL_CTX_DATA |
| Data pointer to pass to the ssl context callback set by the option |
| \fICURLOPT_SSL_CTX_FUNCTION\fP, this is the pointer you'll get as third |
| parameter, otherwise \fBNULL\fP. (Added in 7.11.0) |
| .SH ERROR OPTIONS |
| .IP 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. |
| |
| Use \fICURLOPT_VERBOSE\fP and \fICURLOPT_DEBUGFUNCTION\fP to better |
| debug/trace why errors happen. |
| |
| \fBNote:\fP if the library does not return an error, the buffer may not have |
| been touched. Do not rely on the contents in those cases. |
| .IP CURLOPT_STDERR |
| Pass a FILE * as parameter. Tell libcurl to use this stream instead of stderr |
| when showing the progress meter and displaying \fICURLOPT_VERBOSE\fP data. |
| .IP 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. |
| .SH NETWORK OPTIONS |
| .IP 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. |
| |
| If the given URL lacks the protocol part ("http://" or "ftp://" etc), it will |
| attempt to guess which protocol to use based on the given host name. If the |
| given protocol of the set URL is not supported, libcurl will return on error |
| (\fICURLE_UNSUPPORTED_PROTOCOL\fP) when you call \fIcurl_easy_perform(3)\fP or |
| \fIcurl_multi_perform(3)\fP. Use \fIcurl_version_info(3)\fP for detailed info |
| on which protocols that are supported. |
| |
| \fBNOTE:\fP \fICURLOPT_URL\fP is the only option that must be set before |
| \fIcurl_easy_perform(3)\fP is called. |
| .IP 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 [protocol]:// since any such prefix will be ignored. The |
| proxy's port number may optionally be specified with the separate option |
| \fICURLOPT_PROXYPORT\fP. |
| |
| \fBNOTE:\fP when you tell the library to use an HTTP proxy, libcurl will |
| transparently convert operations to HTTP even if you specify an FTP URL |
| etc. This may have an impact on what other features of the library you can |
| use, such as \fICURLOPT_QUOTE\fP and similar FTP specifics that don't work |
| unless you tunnel through the HTTP proxy. Such tunneling is activated with |
| \fICURLOPT_HTTPPROXYTUNNEL\fP. |
| |
| \fBNOTE2:\fP libcurl respects the environment variables \fBhttp_proxy\fP, |
| \fBftp_proxy\fP, \fBall_proxy\fP etc, if any of those is set. |
| .IP CURLOPT_PROXYPORT |
| Pass a long with this option to set the proxy port to connect to unless it is |
| specified in the proxy string \fICURLOPT_PROXY\fP. |
| .IP CURLOPT_PROXYTYPE |
| Pass a long with this option to set type of the proxy. Available options for |
| this are \fICURLPROXY_HTTP\fP and \fICURLPROXY_SOCKS5\fP, with the HTTP one |
| being default. (Added in 7.10) |
| .IP 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 tunneling option. |
| .IP 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. |
| .IP CURLOPT_DNS_CACHE_TIMEOUT |
| Pass a long, this sets the timeout in seconds. Name resolves will be kept in |
| memory for this number of seconds. Set to zero (0) to completely disable |
| caching, or set to -1 to make the cached entries remain forever. By default, |
| libcurl caches this info for 60 seconds. |
| .IP CURLOPT_DNS_USE_GLOBAL_CACHE |
| Pass a long. If the value is non-zero, it tells curl to use a global DNS cache |
| that will survive between easy handle creations and deletions. This is not |
| thread-safe and this will use a global variable. |
| |
| \fBWARNING:\fP this option is considered obsolete. Stop using it. Switch over |
| to using the share interface instead! See \fICURLOPT_SHARE\fP and |
| \fIcurl_share_init(3)\fP. |
| .IP CURLOPT_BUFFERSIZE |
| Pass a long specifying your preferred size for the receive buffer in libcurl. |
| The main point of this would be that the write callback gets called more often |
| and with smaller chunks. This is just treated as a request, not an order. You |
| cannot be guaranteed to actually get the given size. (Added in 7.10) |
| .IP CURLOPT_PORT |
| Pass a long specifying what remote port number to connect to, instead of the |
| one specified in the URL or the default port for the used protocol. |
| .IP CURLOPT_TCP_NODELAY |
| Pass a long specifying whether the TCP_NODELAY option should be set or |
| cleared (1 = set, 0 = clear). The option is cleared by default. This |
| will have no effect after the connection has been established. |
| |
| Setting this option will disable TCP's Nagle algorithm. The purpose of |
| this algorithm is to try to minimize the number of small packets on |
| the network (where "small packets" means TCP segments less than the |
| Maximum Segment Size (MSS) for the network). |
| |
| Maximizing the amount of data sent per TCP segment is good because it |
| amortizes the overhead of the send. However, in some cases (most |
| notably telnet or rlogin) small segments may need to be sent |
| without delay. This is less efficient than sending larger amounts of |
| data at a time, and can contribute to congestion on the network if |
| overdone. |
| .SH NAMES and PASSWORDS OPTIONS (Authentication) |
| .IP CURLOPT_NETRC |
| This parameter controls the preference of libcurl between using user names and |
| passwords from your \fI~/.netrc\fP file, relative to user names and passwords |
| in the URL supplied with \fICURLOPT_URL\fP. |
| |
| \fBNote:\fP libcurl uses a user name (and supplied or prompted password) |
| supplied with \fICURLOPT_USERPWD\fP in preference to any of the options |
| controlled by this parameter. |
| |
| Pass a long, set to one of the values described below. |
| .RS |
| .IP CURL_NETRC_OPTIONAL |
| The use of your \fI~/.netrc\fP file is optional, |
| and information in the URL is to be preferred. The file will be scanned |
| with the host and user name (to find the password only) or with the host only, |
| to find the first user name and password after that \fImachine\fP, |
| which ever information is not specified in the URL. |
| |
| Undefined values of the option will have this effect. |
| .IP CURL_NETRC_IGNORED |
| The library will ignore the file and use only the information in the URL. |
| |
| This is the default. |
| .IP CURL_NETRC_REQUIRED |
| This value tells the library that use of the file is required, |
| to ignore the information in the URL, |
| and to search the file with the host only. |
| .RE |
| Only machine name, user name and password are taken into account |
| (init macros and similar things aren't supported). |
| |
| \fBNote:\fP 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. |
| .IP CURLOPT_NETRC_FILE |
| Pass a char * as parameter, pointing to a zero terminated string containing |
| the full path name to the file you want libcurl to use as .netrc file. If this |
| option is omitted, and \fICURLOPT_NETRC\fP is set, libcurl will attempt to |
| find the a .netrc file in the current user's home directory. (Added in 7.10.9) |
| .IP CURLOPT_USERPWD |
| Pass a char * as parameter, which should be [user name]:[password] to use for |
| the connection. Use \fICURLOPT_HTTPAUTH\fP to decide authentication method. |
| |
| When using HTTP and \fICURLOPT_FOLLOWLOCATION\fP, libcurl might perform |
| several requests to possibly different hosts. libcurl will only send this user |
| and password information to hosts using the initial host name (unless |
| \fICURLOPT_UNRESTRICTED_AUTH\fP is set), so if libcurl follows locations to |
| other hosts it will not send the user and password to those. This is enforced |
| to prevent accidental information leakage. |
| .IP CURLOPT_PROXYUSERPWD |
| Pass a char * as parameter, which should be [user name]:[password] to use for |
| the connection to the HTTP proxy. Use \fICURLOPT_PROXYAUTH\fP to decide |
| authentication method. |
| .IP CURLOPT_HTTPAUTH |
| Pass a long as parameter, which is set to a bitmask, to tell libcurl what |
| authentication method(s) you want it to use. The available bits are listed |
| below. If more than one bit is set, libcurl will first query the site to see |
| what authentication methods it supports and then pick the best one you allow |
| it to use. Note that for some methods, this will induce an extra network |
| round-trip. Set the actual name and password with the \fICURLOPT_USERPWD\fP |
| option. (Added in 7.10.6) |
| .RS |
| .IP CURLAUTH_BASIC |
| HTTP Basic authentication. This is the default choice, and the only method |
| that is in wide-spread use and supported virtually everywhere. This is sending |
| the user name and password over the network in plain text, easily captured by |
| others. |
| .IP CURLAUTH_DIGEST |
| HTTP Digest authentication. Digest authentication is defined in RFC2617 and |
| is a more secure way to do authentication over public networks than the |
| regular old-fashioned Basic method. |
| .IP CURLAUTH_GSSNEGOTIATE |
| HTTP GSS-Negotiate authentication. The GSS-Negotiate (also known as plain |
| "Negotiate") method was designed by Microsoft and is used in their web |
| applications. It is primarily meant as a support for Kerberos5 authentication |
| but may be also used along with another authentication methods. For more |
| information see IETF draft draft-brezak-spnego-http-04.txt. |
| |
| \fBNOTE\fP that you need to build libcurl with a suitable GSS-API library for |
| this to work. |
| .IP CURLAUTH_NTLM |
| HTTP NTLM authentication. A proprietary protocol invented and used by |
| Microsoft. It uses a challenge-response and hash concept similar to Digest, to |
| prevent the password from being eavesdropped. |
| |
| \fBNOTE\fP that you need to build libcurl with SSL support for this option to |
| work. |
| .IP CURLAUTH_ANY |
| This is a convenience macro that sets all bits and thus makes libcurl pick any |
| it finds suitable. libcurl will automatically select the one it finds most |
| secure. |
| .IP CURLAUTH_ANYSAFE |
| This is a convenience macro that sets all bits except Basic and thus makes |
| libcurl pick any it finds suitable. libcurl will automatically select the one it |
| finds most secure. |
| .RE |
| .IP CURLOPT_PROXYAUTH |
| Pass a long as parameter, which is set to a bitmask, to tell libcurl what |
| authentication method(s) you want it to use for your proxy authentication. If |
| more than one bit is set, libcurl will first query the site to see what |
| authentication methods it supports and then pick the best one you allow it to |
| use. Note that for some methods, this will induce an extra network |
| round-trip. Set the actual name and password with the |
| \fICURLOPT_PROXYUSERPWD\fP option. The bitmask can be constructed by or'ing |
| together the bits listed above for the \fICURLOPT_HTTPAUTH\fP option. As of |
| this writing, only Basic and NTLM work. (Added in 7.10.7) |
| .SH HTTP OPTIONS |
| .IP CURLOPT_AUTOREFERER |
| Pass a non-zero parameter to enable this. When enabled, libcurl will |
| automatically set the Referer: field in requests where it follows a Location: |
| redirect. |
| .IP CURLOPT_ENCODING |
| Sets the contents of the Accept-Encoding: header sent in an HTTP |
| request, and enables decoding of a response when a Content-Encoding: |
| header is received. Three encodings are supported: \fIidentity\fP, |
| which does nothing, \fIdeflate\fP which requests the server to |
| compress its response using the zlib algorithm, and \fIgzip\fP which |
| requests the gzip algorithm. If a zero-length string is set, then an |
| Accept-Encoding: header containing all supported encodings is sent. |
| |
| This is a request, not an order; the server may or may not do it. This |
| option must be set (to any non-NULL value) or else any unsolicited |
| encoding done by the server is ignored. See the special file |
| lib/README.encoding for details. |
| .IP CURLOPT_FOLLOWLOCATION |
| A non-zero parameter tells the library to follow any Location: header that the |
| server sends as part of an HTTP header. |
| |
| \fBNOTE:\fP 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. \fICURLOPT_MAXREDIRS\fP can be used to limit the number |
| of redirects libcurl will follow. |
| .IP CURLOPT_UNRESTRICTED_AUTH |
| A non-zero parameter tells the library it can continue to send authentication |
| (user+password) when following locations, even when hostname changed. Note |
| that this is meaningful only when setting \fICURLOPT_FOLLOWLOCATION\fP. |
| .IP 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 |
| (\fICURLE_TOO_MANY_REDIRECTS\fP). This option only makes sense if the |
| \fICURLOPT_FOLLOWLOCATION\fP is used at the same time. |
| .IP CURLOPT_PUT |
| A non-zero parameter tells the library to use HTTP PUT to transfer data. The |
| data should be set with \fICURLOPT_READDATA\fP and \fICURLOPT_INFILESIZE\fP. |
| |
| This option is deprecated and starting with version 7.12.1 you should instead |
| use \fICURLOPT_UPLOAD\fP. |
| .IP CURLOPT_POST |
| A non-zero parameter tells the library to do a regular HTTP post. This will |
| also make the library use the a "Content-Type: |
| application/x-www-form-urlencoded" header. (This is by far the most commonly |
| used POST method). |
| |
| Use the \fICURLOPT_POSTFIELDS\fP option to specify what data to post and |
| \fICURLOPT_POSTFIELDSIZE\fP to set the data size. |
| |
| Optionally, you can provide data to POST using the \fICURLOPT_READFUNCTION\fP |
| and \fICURLOPT_READDATA\fP options but then you must make sure to not set |
| \fICURLOPT_POSTFIELDS\fP to anything but NULL. When providing data with a |
| callback, you must transmit it using chunked transfer-encoding or you must set |
| the size of the data with the \fICURLOPT_POSTFIELDSIZE\fP option. |
| |
| You can override the default POST Content-Type: header by setting your own |
| with \fICURLOPT_HTTPHEADER\fP. |
| |
| Using POST with HTTP 1.1 implies the use of a "Expect: 100-continue" header. |
| You can disable this header with \fICURLOPT_HTTPHEADER\fP as usual. |
| |
| If you use POST to a HTTP 1.1 server, you can send data without knowing the |
| size before starting the POST if you use chunked encoding. You enable this by |
| adding a header like "Transfer-Encoding: chunked" with |
| \fICURLOPT_HTTPHEADER\fP. With HTTP 1.0 or without chunked transfer, you must |
| specify the size in the request. |
| |
| NOTE: if you have issued a POST request and want to make a HEAD or GET |
| instead, you must explictly pick the new request type using |
| \fICURLOPT_NOBODY\fP or \fICURLOPT_HTTPGET\fP or similar. |
| .IP CURLOPT_POSTFIELDS |
| Pass a char * as parameter, which should be the full data to post in an HTTP |
| POST operation. You must make sure that the data is formatted the way you want |
| the server to receive it. libcurl will not convert or encode it for you. Most |
| web servers will assume this data to be url-encoded. Take note. |
| |
| This POST is a normal application/x-www-form-urlencoded kind (and libcurl will |
| set that Content-Type by default when this option is used), which is the most |
| commonly used one by HTML forms. See also the \fICURLOPT_POST\fP. Using |
| \fICURLOPT_POSTFIELDS\fP implies \fICURLOPT_POST\fP. |
| |
| Using POST with HTTP 1.1 implies the use of a "Expect: 100-continue" header. |
| You can disable this header with \fICURLOPT_HTTPHEADER\fP as usual. |
| |
| \fBNote:\fP to make multipart/formdata posts (aka rfc1867-posts), check out |
| the \fICURLOPT_HTTPPOST\fP option. |
| .IP CURLOPT_POSTFIELDSIZE |
| If you want to post data to the server without letting 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 -1, the library will use strlen() to get the size. |
| .IP CURLOPT_POSTFIELDSIZE_LARGE |
| Pass a curl_off_t as parameter. Use this to set the size of the |
| \fICURLOPT_POSTFIELDS\fP data to prevent libcurl from doing strlen() on the |
| data to figure out the size. This is the large file version of the |
| \fICURLOPT_POSTFIELDSIZE\fP option. (Added in 7.11.1) |
| .IP 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 |
| elegant way to do this, is to use \fIcurl_formadd(3)\fP as documented. The |
| data in this list must remain intact until you close this curl handle again |
| with \fIcurl_easy_cleanup(3)\fP. |
| |
| Using POST with HTTP 1.1 implies the use of a "Expect: 100-continue" header. |
| You can disable this header with \fICURLOPT_HTTPHEADER\fP as usual. |
| .IP CURLOPT_REFERER |
| Pass a pointer to a zero terminated string as parameter. 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 \fICURLOPT_HTTPHEADER\fP. |
| .IP CURLOPT_USERAGENT |
| Pass a pointer to a zero terminated string as parameter. 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 \fICURLOPT_HTTPHEADER\fP. |
| .IP 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 \fBstruct |
| curl_slist\fP structs properly filled in. Use \fIcurl_slist_append(3)\fP to |
| create the list and \fIcurl_slist_free_all(3)\fP 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 disabled. Thus, using this option you can add |
| new headers, replace internal headers and remove internal headers. The |
| headers included in the linked list must not be CRLF-terminated, because |
| curl adds CRLF after each header item. Failure to comply with this will |
| result in strange bugs because the server will most likely ignore part |
| of the headers you specified. |
| |
| The first line in a request (usually containing a GET or POST) is not a header |
| and cannot be replaced using this option. Only the lines following the |
| request-line are headers. |
| |
| Pass a NULL to this to reset back to no custom headers. |
| |
| \fBNOTE:\fP The most commonly replaced headers have "shortcuts" in the options |
| \fICURLOPT_COOKIE\fP, \fICURLOPT_USERAGENT\fP and \fICURLOPT_REFERER\fP. |
| .IP CURLOPT_HTTP200ALIASES |
| Pass a pointer to a linked list of aliases to be treated as valid HTTP 200 |
| responses. Some servers respond with a custom header response line. For |
| example, IceCast servers respond with "ICY 200 OK". By including this string |
| in your list of aliases, the response will be treated as a valid HTTP header |
| line such as "HTTP/1.0 200 OK". (Added in 7.10.3) |
| |
| The linked list should be a fully valid list of struct curl_slist structs, and |
| be properly filled in. Use \fIcurl_slist_append(3)\fP to create the list and |
| \fIcurl_slist_free_all(3)\fP to clean up an entire list. |
| |
| \fBNOTE:\fP The alias itself is not parsed for any version strings. So if your |
| alias is "MYHTTP/9.9", Libcurl will not treat the server as responding with |
| HTTP version 9.9. Instead Libcurl will use the value set by option |
| \fICURLOPT_HTTP_VERSION\fP. |
| .IP CURLOPT_COOKIE |
| Pass a pointer to a zero terminated string as parameter. 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 and CONTENTS is what the cookie |
| should contain. |
| |
| If you need to set multiple cookies, you need to set them all using a single |
| option and thus you need to concatenate them all in one single string. Set |
| multiple cookies in one string like this: "name1=content1; name2=content2;" |
| etc. |
| |
| Using this option multiple times will only make the latest string override the |
| previously ones. |
| .IP CURLOPT_COOKIEFILE |
| Pass a pointer to a zero terminated string as parameter. It should contain the |
| name of your file holding cookie data to read. The cookie data may be in |
| Netscape / Mozilla cookie data format or just regular HTTP-style headers |
| dumped to a file. |
| |
| Given an empty or non-existing file, this option will enable cookies for this |
| curl handle, making it understand and parse received cookies and then use |
| matching cookies in future request. |
| .IP CURLOPT_COOKIEJAR |
| Pass a file name as char *, zero terminated. This will make libcurl write all |
| internally known cookies to the specified file when \fIcurl_easy_cleanup(3)\fP |
| is called. If no cookies are known, no file will be created. Specify "-" to |
| instead have the cookies written to stdout. Using this option also enables |
| cookies for this session, so if you for example follow a location it will make |
| matching cookies get sent accordingly. |
| |
| \fBNOTE:\fP If the cookie jar file can't be created or written to (when the |
| \fIcurl_easy_cleanup(3)\fP is called), libcurl will not and cannot report an |
| error for this. Using \fICURLOPT_VERBOSE\fP or \fICURLOPT_DEBUGFUNCTION\fP |
| will get a warning to display, but that is the only visible feedback you get |
| about this possibly lethal situation. |
| .IP CURLOPT_COOKIESESSION |
| Pass a long set to non-zero to mark this as a new cookie "session". It will |
| force libcurl to ignore all cookies it is about to load that are "session |
| cookies" from the previous session. By default, libcurl always stores and |
| loads all cookies, independent if they are session cookies are not. Session |
| cookies are cookies without expiry date and they are meant to be alive and |
| existing for this "session" only. |
| .IP CURLOPT_HTTPGET |
| Pass a long. If the long is non-zero, this forces the HTTP request to get back |
| to GET. usable if a POST, HEAD, PUT or a custom request have been used |
| previously using the same curl handle. |
| .IP 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. |
| .RS |
| .IP CURL_HTTP_VERSION_NONE |
| We don't care about what version the library uses. libcurl will use whatever |
| it thinks fit. |
| .IP CURL_HTTP_VERSION_1_0 |
| Enforce HTTP 1.0 requests. |
| .IP CURL_HTTP_VERSION_1_1 |
| Enforce HTTP 1.1 requests. |
| .RE |
| .SH FTP OPTIONS |
| .IP CURLOPT_FTPPORT |
| Pass a pointer to a zero terminated string as parameter. 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 systems default IP |
| address. Default FTP operations are passive, and thus won't use PORT. |
| |
| You disable PORT again and go back to using the passive version by setting |
| this option to NULL. |
| .IP CURLOPT_QUOTE |
| Pass a pointer to a linked list of FTP commands to pass to the server prior to |
| your ftp request. This will be done before any other FTP commands are issued |
| (even before the CWD command). The linked list should be a fully valid list of |
| 'struct curl_slist' structs properly filled in. Use \fIcurl_slist_append(3)\fP |
| to append strings (commands) to the list, and clear the entire list afterwards |
| with \fIcurl_slist_free_all(3)\fP. Disable this operation again by setting a |
| NULL to this option. |
| .IP 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 |
| \fICURLOPT_QUOTE\fP. Disable this operation again by setting a NULL to this |
| option. |
| .IP CURLOPT_PREQUOTE |
| Pass a pointer to a linked list of FTP commands to pass to the server after |
| the transfer type is set. The linked list should be a fully valid list of |
| struct curl_slist structs properly filled in as described for |
| \fICURLOPT_QUOTE\fP. Disable this operation again by setting a NULL to this |
| option. |
| .IP 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. |
| |
| This causes an FTP NLST command to be sent. Beware that some FTP servers list |
| only files in their response to NLST; they might not include subdirectories |
| and symbolic links. |
| .IP 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 an ftp site. |
| .IP CURLOPT_FTP_USE_EPRT |
| Pass a long. If the value is non-zero, it tells curl to use the EPRT (and |
| LPRT) command when doing active FTP downloads (which is enabled by |
| \fICURLOPT_FTPPORT\fP). Using EPRT means that it will first attempt to use |
| EPRT and then LPRT before using PORT, but if you pass FALSE (zero) to this |
| option, it will not try using EPRT or LPRT, only plain PORT. (Added in 7.10.5) |
| .IP 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 downloads (which it 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. |
| .IP CURLOPT_FTP_CREATE_MISSING_DIRS |
| Pass a long. If the value is non-zero, curl will attempt to create any remote |
| directory that it fails to CWD into. CWD is the command that changes working |
| directory. (Added in 7.10.7) |
| .IP CURLOPT_FTP_RESPONSE_TIMEOUT |
| Pass a long. Causes curl to set a timeout period (in seconds) on the amount |
| of time that the server is allowed to take in order to generate a response |
| message for a command before the session is considered hung. Note that while |
| curl is waiting for a response, this value overrides \fICURLOPT_TIMEOUT\fP. It |
| is recommended that if used in conjunction with \fICURLOPT_TIMEOUT\fP, you set |
| \fICURLOPT_FTP_RESPONSE_TIMEOUT\fP to a value smaller than |
| \fICURLOPT_TIMEOUT\fP. (Added in 7.10.8) |
| .IP CURLOPT_FTP_SSL |
| Pass a long using one of the values from below, to make libcurl use your |
| desired level of SSL for the ftp transfer. (Added in 7.11.0) |
| .RS |
| .IP CURLFTPSSL_NONE |
| Don't attempt to use SSL. |
| .IP CURLFTPSSL_TRY |
| Try using SSL, proceed as normal otherwise. |
| .IP CURLFTPSSL_CONTROL |
| Require SSL for the control connection or fail with \fICURLE_FTP_SSL_FAILED\fP. |
| .IP CURLFTPSSL_ALL |
| Require SSL for all communication or fail with \fICURLE_FTP_SSL_FAILED\fP. |
| .RE |
| .IP CURLOPT_FTPSSLAUTH |
| Pass a long using one of the values from below, to alter how libcurl issues |
| \&"AUTH TLS" or "AUTH SSL" when FTP over SSL is activated (see |
| \fICURLOPT_FTP_SSL\fP). |
| .RS |
| .IP CURLFTPAUTH_DEFAULT |
| Allow libcurl to decide |
| .IP CURLFTPAUTH_SSL |
| Try "AUTH SSL" first, and only if that fails try "AUTH TLS" |
| .IP CURLFTPAUTH_TLS |
| Try "AUTH TLS" first, and only if that fails try "AUTH SSL" |
| .RE |
| .SH PROTOCOL OPTIONS |
| .IP 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. |
| .IP CURLOPT_CRLF |
| Convert Unix newlines to CRLF newlines on transfers. |
| .IP 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 commas as in |
| \fI"X-Y,N-M"\fP. Using this kind of multiple intervals will cause the HTTP |
| server to send the response document in pieces (using standard MIME separation |
| techniques). Pass a NULL to this option to disable the use of ranges. |
| .IP CURLOPT_RESUME_FROM |
| Pass a long as parameter. It contains the offset in number of bytes that you |
| want the transfer to start from. Set this option to 0 to make the transfer |
| start from the beginning (effectively disabling resume). |
| .IP CURLOPT_RESUME_FROM_LARGE |
| Pass a curl_off_t as parameter. It contains the offset in number of bytes that |
| you want the transfer to start from. (Added in 7.11.0) |
| .IP CURLOPT_CUSTOMREQUEST |
| Pass a pointer to a zero terminated string as parameter. It will be user |
| instead of GET or HEAD when doing an HTTP request, or instead of LIST or NLST |
| when doing an ftp directory listing. This is useful for doing DELETE or other |
| more or less obscure HTTP requests. Don't do this at will, make sure your |
| server supports the command first. |
| |
| Restore to the internal default by setting this to NULL. |
| |
| \fBNOTE:\fP Many people have wrongly used this option to replace the entire |
| request with their own, including multiple headers and POST contents. While |
| that might work in many cases, it will cause libcurl to send invalid requests |
| and it could possibly confuse the remote server badly. Use \fICURLOPT_POST\fP |
| and \fICURLOPT_POSTFIELDS\fP to set POST data. Use \fICURLOPT_HTTPHEADER\fP to |
| replace or extend the set of headers sent by libcurl. Use |
| \fICURLOPT_HTTP_VERSION\fP to change HTTP version. |
| .IP 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 |
| \fIcurl_easy_getinfo(3)\fP function with the \fICURLINFO_FILETIME\fP argument |
| can be used after a transfer to extract the received time (if any). |
| .IP 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. On HTTP(S) servers, this will make libcurl do a HEAD request. |
| |
| To change back to GET, you should use \fICURLOPT_HTTPGET\fP. To change back to |
| POST, you should use \fICURLOPT_POST\fP. Setting \fICURLOPT_NOBODY\fP to zero |
| has no effect. |
| .IP 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. This value should be passed |
| as a long. See also \fICURLOPT_INFILESIZE_LARGE\fP. |
| .IP CURLOPT_INFILESIZE_LARGE |
| When uploading a file to a remote site, this option should be used to tell |
| libcurl what the expected size of the infile is. This value should be passed |
| as a curl_off_t. (Added in 7.11.0) |
| .IP CURLOPT_UPLOAD |
| A non-zero parameter tells the library to prepare for an upload. The |
| \fICURLOPT_READDATA\fP and \fICURLOPT_INFILESIZEE\fP or |
| \fICURLOPT_INFILESIZE_LARGE\fP are also interesting for uploads. If the |
| protocol is HTTP, uploading means using the PUT request unless you tell |
| libcurl otherwise. |
| |
| Using PUT with HTTP 1.1 implies the use of a "Expect: 100-continue" header. |
| You can disable this header with \fICURLOPT_HTTPHEADER\fP as usual. |
| |
| If you use PUT to a HTTP 1.1 server, you can upload data without knowing the |
| size before starting the transfer if you use chunked encoding. You enable this |
| by adding a header like "Transfer-Encoding: chunked" with |
| \fICURLOPT_HTTPHEADER\fP. With HTTP 1.0 or without chunked transfer, you must |
| specify the size. |
| .IP CURLOPT_MAXFILESIZE |
| Pass a long as parameter. This allows you to specify the maximum size (in |
| bytes) of a file to download. If the file requested is larger than this value, |
| the transfer will not start and CURLE_FILESIZE_EXCEEDED will be returned. |
| |
| \fBNOTE:\fP The file size is not always known prior to download, and for such |
| files this option has no effect even if the file transfer ends up being larger |
| than this given limit. This concerns both FTP and HTTP transfers. |
| .IP CURLOPT_MAXFILESIZE_LARGE |
| Pass a curl_off_t as parameter. This allows you to specify the maximum size |
| (in bytes) of a file to download. If the file requested is larger than this |
| value, the transfer will not start and \fICURLE_FILESIZE_EXCEEDED\fP will be |
| returned. (Added in 7.11.0) |
| |
| \fBNOTE:\fP The file size is not always known prior to download, and for such |
| files this option has no effect even if the file transfer ends up being larger |
| than this given limit. This concerns both FTP and HTTP transfers. |
| .IP CURLOPT_TIMECONDITION |
| Pass a long as parameter. This defines how the \fICURLOPT_TIMEVALUE\fP time |
| value is treated. You can set this parameter to \fICURL_TIMECOND_IFMODSINCE\fP |
| or \fICURL_TIMECOND_IFUNMODSINCE\fP. This feature applies to HTTP and FTP. |
| |
| \fBNOTE:\fP The last modification time of a file is not always known and in such |
| instances this feature will have no effect even if the given time condition |
| would have not been met. |
| .IP CURLOPT_TIMEVALUE |
| Pass a long as parameter. This should be the time in seconds since 1 jan 1970, |
| and the time will be used in a condition as specified with |
| \fICURLOPT_TIMECONDITION\fP. |
| .SH CONNECTION OPTIONS |
| .IP CURLOPT_TIMEOUT |
| Pass a long as parameter containing the maximum time in seconds that you allow |
| the libcurl transfer operation 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. |
| |
| \fBNOTE:\fP this is not recommended to use in unix multi-threaded programs, as |
| it uses signals unless \fICURLOPT_NOSIGNAL\fP (see above) is set. |
| .IP 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 \fICURLOPT_LOW_SPEED_TIME\fP seconds |
| for the library to consider it too slow and abort. |
| .IP CURLOPT_LOW_SPEED_TIME |
| Pass a long as parameter. It contains the time in seconds that the transfer |
| should be below the \fICURLOPT_LOW_SPEED_LIMIT\fP for the library to consider |
| it too slow and abort. |
| .IP CURLOPT_MAXCONNECTS |
| Pass a long. The set number will be the persistent connection cache size. The |
| set amount will be the maximum amount of simultaneously open connections that |
| libcurl may cache. 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. This concerns connection using any of the protocols that support |
| persistent connections. |
| |
| When reaching the maximum limit, curl uses the \fICURLOPT_CLOSEPOLICY\fP to |
| figure out which of the existing connections to close to prevent the number of |
| open connections to increase. |
| |
| \fBNOTE:\fP if you already have performed transfers with this curl handle, |
| setting a smaller MAXCONNECTS than before may cause open connections to get |
| closed unnecessarily. |
| .IP 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 \fICURLCLOSEPOLICY_LEAST_RECENTLY_USED\fP to make libcurl close |
| the connection that was least recently used, that connection is also least |
| likely to be capable of re-use. Use \fICURLCLOSEPOLICY_OLDEST\fP to make |
| libcurl close the oldest connection, the one that was created first among the |
| ones in the connection cache. The other close policies are not support |
| yet. |
| .IP CURLOPT_FRESH_CONNECT |
| Pass a long. Set to non-zero to make the next transfer 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). |
| .IP CURLOPT_FORBID_REUSE |
| Pass a long. Set to non-zero to make the next transfer explicitly close the |
| connection when done. Normally, 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). |
| .IP 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 \fICURLOPT_TIMEOUT\fP option. |
| |
| \fBNOTE:\fP this is not recommended to use in unix multi-threaded programs, as |
| it uses signals unless \fICURLOPT_NOSIGNAL\fP (see above) is set. |
| .IP CURLOPT_IPRESOLVE |
| Allows an application to select what kind of IP addresses to use when |
| resolving host names. This is only interesting when using host names that |
| resolve addresses using more than one version of IP. The allowed values are: |
| .RS |
| .IP CURL_IPRESOLVE_WHATEVER |
| Default, resolves addresses to all IP versions that your system allows. |
| .IP CURL_IPRESOLVE_V4 |
| Resolve to ipv4 addresses. |
| .IP CURL_IPRESOLVE_V6 |
| Resolve to ipv6 addresses. |
| .RE |
| .SH SSL and SECURITY OPTIONS |
| .IP CURLOPT_SSLCERT |
| Pass a pointer to a zero terminated string as parameter. The string should be |
| the file name of your certificate. The default format is "PEM" and can be |
| changed with \fICURLOPT_SSLCERTTYPE\fP. |
| .IP CURLOPT_SSLCERTTYPE |
| Pass a pointer to a zero terminated string as parameter. The string should be |
| the format of your certificate. Supported formats are "PEM" and "DER". (Added |
| in 7.9.3) |
| .IP CURLOPT_SSLCERTPASSWD |
| Pass a pointer to a zero terminated string as parameter. It will be used as |
| the password required to use the \fICURLOPT_SSLCERT\fP certificate. |
| |
| This option is replaced by \fICURLOPT_SSLKEYPASSWD\fP and should only be used |
| for backward compatibility. You never needed a pass phrase to load a |
| certificate but you need one to load your private key. |
| .IP CURLOPT_SSLKEY |
| Pass a pointer to a zero terminated string as parameter. The string should be |
| the file name of your private key. The default format is "PEM" and can be |
| changed with \fICURLOPT_SSLKEYTYPE\fP. |
| .IP CURLOPT_SSLKEYTYPE |
| Pass a pointer to a zero terminated string as parameter. The string should be |
| the format of your private key. Supported formats are "PEM", "DER" and "ENG". |
| |
| \fBNOTE:\fP The format "ENG" enables you to load the private key from a crypto |
| engine. In this case \fICURLOPT_SSLKEY\fP is used as an identifier passed to |
| the engine. You have to set the crypto engine with \fICURLOPT_SSLENGINE\fP. |
| \&"DER" format key file currently does not work because of a bug in OpenSSL. |
| .IP CURLOPT_SSLKEYPASSWD |
| Pass a pointer to a zero terminated string as parameter. It will be used as |
| the password required to use the \fICURLOPT_SSLKEY\fP private key. |
| .IP CURLOPT_SSLENGINE |
| Pass a pointer to a zero terminated string as parameter. It will be used as |
| the identifier for the crypto engine you want to use for your private |
| key. |
| |
| \fBNOTE:\fP If the crypto device cannot be loaded, |
| \fICURLE_SSL_ENGINE_NOTFOUND\fP is returned. |
| .IP CURLOPT_SSLENGINE_DEFAULT |
| Sets the actual crypto engine as the default for (asymmetric) crypto |
| operations. |
| |
| \fBNOTE:\fP If the crypto device cannot be set, |
| \fICURLE_SSL_ENGINE_SETFAILED\fP is returned. |
| .IP 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. |
| .IP CURLOPT_SSL_VERIFYPEER |
| Pass a long that is set to a zero value to stop curl from verifying the peer's |
| certificate (7.10 starting setting this option to non-zero by default). |
| Alternate certificates to verify against can be specified with the |
| \fICURLOPT_CAINFO\fP option or a certificate directory can be specified with |
| the \fICURLOPT_CAPATH\fP option. As of 7.10, curl installs a default bundle. |
| \fICURLOPT_SSL_VERIFYHOST\fP may also need to be set to 1 or 0 if |
| \fICURLOPT_SSL_VERIFYPEER\fP is disabled (it defaults to 2). |
| .IP CURLOPT_CAINFO |
| Pass a char * to a zero terminated string naming a file holding one or more |
| certificates to verify the peer with. This only makes sense when used in |
| combination with the \fICURLOPT_SSL_VERIFYPEER\fP option. |
| .IP CURLOPT_CAPATH |
| Pass a char * to a zero terminated string naming a directory holding multiple |
| CA certificates to verify the peer with. The certificate directory must be |
| prepared using the openssl c_rehash utility. This only makes sense when used |
| in combination with the \fICURLOPT_SSL_VERIFYPEER\fP option. The |
| \fICURLOPT_CAPATH\fP function apparently does not work in Windows due to some |
| limitation in openssl. (Added in 7.9.8) |
| .IP 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 the SSL connection will become. |
| .IP 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. |
| .IP 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. This is by default set to 2. (default changed in 7.10) |
| .IP 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 syntactically correct, |
| it consists of one or more cipher strings separated by colons. Commas or spaces |
| are also acceptable separators 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: |
| \fIhttp://www.openssl.org/docs/apps/ciphers.html\fP |
| .IP 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 |
| \&'private'. 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. |
| .SH OTHER OPTIONS |
| .IP CURLOPT_PRIVATE |
| Pass a char * as parameter, pointing to data that should be associated with |
| this curl handle. The pointer can subsequently be retrieved using |
| \fIcurl_easy_getinfo(3)\fP with the CURLINFO_PRIVATE option. libcurl itself |
| does nothing with this data. (Added in 7.10.3) |
| .IP CURLOPT_SHARE |
| Pass a share handle as a parameter. The share handle must have been created by |
| a previous call to \fIcurl_share_init(3)\fP. Setting this option, will make |
| this curl handle use the data from the shared handle instead of keeping the |
| data to itself. This enables several curl handles to share data. If the curl |
| handles are used simultaneously, you \fBMUST\fP use the locking methods in the |
| share handle. See \fIcurl_share_setopt(3)\fP for details. |
| .SH TELNET OPTIONS |
| .IP CURLOPT_TELNETOPTIONS |
| Provide a pointer to a curl_slist with variables to pass to the telnet |
| negotiations. The variables should be in the format <option=value>. libcurl |
| supports the options 'TTYPE', 'XDISPLOC' and 'NEW_ENV'. See the TELNET |
| standard for details. |
| .SH RETURN VALUE |
| CURLE_OK (zero) means that the option was set properly, non-zero means an |
| error occurred as \fI<curl/curl.h>\fP defines. See the \fIlibcurl-errors(3)\fP |
| man page for the full list with descriptions. |
| |
| If you try to set an option that libcurl doesn't know about, perhaps because |
| the library is too old to support it or the option was removed in a recent |
| version, this function will return \fICURLE_FAILED_INIT\fP. |
| .SH "SEE ALSO" |
| .BR curl_easy_init "(3), " curl_easy_cleanup "(3), " curl_easy_reset "(3), " |