of:
.RS
.IP interface
-i.e "eth0" to specify which interface's IP address you want to use (Unix only)
+e.g. "eth0" to specify which interface's IP address you want to use (Unix only)
.IP "IP address"
-i.e "192.168.10.1" to specify the exact IP address
+e.g. "192.168.10.1" to specify the exact IP address
.IP "host name"
-i.e "my.host.domain" to specify the machine
+e.g. "my.host.domain" to specify the machine
.IP "-"
make curl pick the same IP address that is already used for the control
connection
If this option is used several times, the last one will be used.
On Linux it can be used to specify a VRF, but the binary needs to either
-have CAP_NET_RAW or to be ran as root. More information about Linux VRF:
+have CAP_NET_RAW or to be run as root. More information about Linux VRF:
https://www.kernel.org/doc/Documentation/networking/vrf.txt
.IP "ALL_PROXY [protocol://]<host>[:port]"
Sets the proxy server to use if no protocol-specific proxy is set.
.IP "NO_PROXY <comma-separated list of hosts>"
-list of host names that shouldn't go through any proxy. If set to a asterisk
+list of host names that shouldn't go through any proxy. If set to an asterisk
\&'*' only, it matches all hosts.
This environment variable disables use of the proxy even when specified with
The supported proxy protocol prefixes are as follows:
.IP "http://"
-Makes it use it as a HTTP proxy. The default if no scheme prefix is used.
+Makes it use it as an HTTP proxy. The default if no scheme prefix is used.
.IP "https://"
-Makes it treated as a \fBHTTPS\fP proxy.
+Makes it treated as an \fBHTTPS\fP proxy.
.IP "socks4://"
Makes it the equivalent of --socks4
.IP "socks4a://"
Long: proxy-cert-type
Arg: <type>
Added: 7.52.0
-Help: Client certificate type for HTTS proxy
+Help: Client certificate type for HTTPS proxy
---
Same as --cert-type but used in HTTPS proxy context.
Long: proxytunnel
Short: p
-Help: Operate through a HTTP proxy tunnel (using CONNECT)
+Help: Operate through an HTTP proxy tunnel (using CONNECT)
See-also: proxy
---
When an HTTP proxy is used --proxy, this option will cause non-HTTP protocols
Arg: <range>
Protocols: HTTP FTP SFTP FILE
---
-Retrieve a byte range (i.e a partial document) from a HTTP/1.1, FTP or SFTP
+Retrieve a byte range (i.e. a partial document) from an HTTP/1.1, FTP or SFTP
server or a local FILE. Ranges can be specified in a number of ways.
.RS
.TP 10
.\" *
.\" **************************************************************************
.\"
-.TH curl_easy_cleanup 3 "22 aug 2007" "libcurl 7.17.0" "libcurl Manual"
+.TH curl_easy_cleanup 3 "22 Aug 2007" "libcurl 7.17.0" "libcurl Manual"
.SH NAME
curl_easy_cleanup - End a libcurl easy handle
.SH SYNOPSIS
.IP CURLOPT_POSTREDIR
How to act on redirects after POST. See \fICURLOPT_POSTREDIR(3)\fP
.IP CURLOPT_PUT
-Issue a HTTP PUT request. See \fICURLOPT_PUT(3)\fP
+Issue an HTTP PUT request. See \fICURLOPT_PUT(3)\fP
.IP CURLOPT_POST
-Issue a HTTP POST request. See \fICURLOPT_POST(3)\fP
+Issue an HTTP POST request. See \fICURLOPT_POST(3)\fP
.IP CURLOPT_POSTFIELDS
Send a POST with this data. See \fICURLOPT_POSTFIELDS(3)\fP
.IP CURLOPT_POSTFIELDSIZE
.IP CURLOPT_COOKIELIST
Add or control cookies. See \fICURLOPT_COOKIELIST(3)\fP
.IP CURLOPT_HTTPGET
-Do a HTTP GET request. See \fICURLOPT_HTTPGET(3)\fP
+Do an HTTP GET request. See \fICURLOPT_HTTPGET(3)\fP
.IP CURLOPT_REQUEST_TARGET
Set the request target. \fICURLOPT_REQUEST_TARGET(3)\fP
.IP CURLOPT_HTTP_VERSION
The implication here is that if this bit is not set, the initialization of the
SSL layer needs to be done by the application or at least outside of
-libcurl. The exact procedure how to do SSL initializtion depends on the TLS
+libcurl. The exact procedure how to do SSL initialization depends on the TLS
backend libcurl uses.
Doing TLS based transfers without having the TLS layer initialized may lead to
.SH RETURN VALUE
If this function returns CURLSSLSET_OK, the backend was successfully selected.
-If the chosen backend is unknown (or support for the chosed backend has not
+If the chosen backend is unknown (or support for the chosen backend has not
been compiled into libcurl), the function returns \fICURLSSLSET_UNKNOWN_BACKEND\fP.
If the backend had been configured previously, or if \fIcurl_global_init(3)\fP
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
+If you stop the current transfer by returning 0 "pre-maturely" (i.e. before the
server expected it, like when you've said 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.
.ad
.SH DESCRIPTION
\fIcurl_mime_filedata(3)\fP sets a mime part's body content from the named
-file's contents. This is an alernative to \fIcurl_mime_data(3)\fP for setting
+file's contents. This is an alternative to \fIcurl_mime_data(3)\fP for setting
data to a mime part.
\fIpart\fP is the part's to assign contents to.
.br
- If set as a custom header, use this value.
.br
-- application/form-data for a HTTP form post.
+- application/form-data for an HTTP form post.
.br
- If a remote file name is set, the mime type is taken from the file name
extension, or application/octet-stream by default.
User name to use when invoking the ntlm-wb tool, if NTLMUSER and LOGNAME
weren't set.
.SH "Debug Variables"
-There's a set of variables only recognized and used if libcurl was buillt
+There's a set of variables only recognized and used if libcurl was built
"debug enabled", which should never be true for a library used in production.
.IP "CURL_GETHOSTNAME"
Debug-only variable.
NTLM authentication. Or even better: use authenticated protocols that protect
the entire connection and everything sent over it.
.SH "Un-authenticated Connections"
-Protocols that don't have any form of cryptographic authentication can not
+Protocols that don't have any form of cryptographic authentication cannot
with any certainty know that they communicate with the right remote server.
If your application is using a fixed scheme or fixed host name, it is not safe
.SH "Upload Data to a Remote Site"
libcurl tries to keep a protocol independent approach to most transfers, thus
-uploading to a remote FTP site is very similar to uploading data to a HTTP
+uploading to a remote FTP site is very similar to uploading data to an HTTP
server with a PUT request.
Of course, first you either create an easy handle or you re-use one existing
To post multiple files for a single form field, you must supply each file in
a separate part, all with the same field name. Although function
-\fIcurl_mime_subparts(3)\fP implements nested muti-parts, this way of
+\fIcurl_mime_subparts(3)\fP implements nested multi-parts, this way of
multiple files posting is deprecated by RFC 7578, chapter 4.3.
To set the data source from an already opened FILE pointer, use:
If you're using a SOCKS proxy, you may find that libcurl doesn't quite support
all operations through it.
-For HTTP proxies: the fact that the proxy is a HTTP proxy puts certain
+For HTTP proxies: the fact that the proxy is an HTTP proxy puts certain
restrictions on what can actually happen. A requested URL that might not be a
HTTP URL will be still be passed to the HTTP proxy to deliver back to
libcurl. This happens transparently, and an application may not need to
know. I say "may", because at times it is very important to understand that
-all operations over a HTTP proxy use the HTTP protocol. For example, you
+all operations over an HTTP proxy use the HTTP protocol. For example, you
can't invoke your own custom FTP commands or even proper FTP directory
listings.
\fICURLOPT_PROXYPORT(3)\fP.
Tell libcurl what kind of proxy it is with \fICURLOPT_PROXYTYPE(3)\fP (if not,
-it will default to assume a HTTP proxy):
+it will default to assume an HTTP proxy):
curl_easy_setopt(easyhandle, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS4);
SSL is for secure point-to-point connections. This involves strong encryption
and similar things, which effectively makes it impossible for a proxy to
operate as a "man in between" which the proxy's task is, as previously
-discussed. Instead, the only way to have SSL work over a HTTP proxy is to ask
+discussed. Instead, the only way to have SSL work over an HTTP proxy is to ask
the proxy to tunnel trough everything without being able to check or fiddle
with the traffic.
-Opening an SSL connection over a HTTP proxy is therefore a matter of asking the
+Opening an SSL connection over an HTTP proxy is therefore a matter of asking the
proxy for a straight connection to the target host on a specified port. This
is made with the HTTP request CONNECT. ("please mr proxy, connect me to that
remote host").
As tunneling opens a direct connection from your application to the remote
machine, it suddenly also re-introduces the ability to do non-HTTP
-operations over a HTTP proxy. You can in fact use things such as FTP
+operations over an HTTP proxy. You can in fact use things such as FTP
upload or FTP custom commands this way.
Again, this is often prevented by the administrators of proxies and is
Not all protocols are HTTP-like, and thus the above may not help you when
you want to make, for example, your FTP transfers to behave differently.
-Sending custom commands to a FTP server means that you need to send the
+Sending custom commands to an FTP server means that you need to send the
commands exactly as the FTP server expects them (RFC959 is a good guide
here), and you can only use commands that work on the control-connection
alone. All kinds of commands that require data interchange and thus need
content transfer will be performed.
.IP "FTP Custom CUSTOMREQUEST"
-If you do want to list the contents of a FTP directory using your own defined
+If you do want to list the contents of an FTP directory using your own defined
FTP command, \fICURLOPT_CUSTOMREQUEST(3)\fP will do just that. "NLST" is the
default one for listing directories but you're free to pass in your idea of a
good alternative.
.SH DESCRIPTION
Pass a char * argument specifying what encoding you'd like.
-Sets the contents of the Accept-Encoding: header sent in a HTTP request, and
+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, meaning non-compressed,
\fIdeflate\fP which requests the server to compress its response using the
the request URL is the default behavior.
If an HTTP proxy is used for a request having a special "connect to" host or
-port, and the "connect to" host or port differs from the requests's host and
+port, and the "connect to" host or port differs from the request's host and
port, the HTTP proxy is automatically switched to tunnel mode for this
specific request. This is necessary because it is not possible to connect to a
specific host or port in normal (non-tunnel) mode.
This option can be used to specify the request:
.IP HTTP
Instead of GET or HEAD when performing HTTP based requests. This is
-particularly useful, for example, for performing a HTTP DELETE request.
+particularly useful, for example, for performing an HTTP DELETE request.
For example:
.SH DESCRIPTION
Pass a long to tell libcurl the number of \fImilliseconds\fP to wait for a
server response with the HTTP status 100 (Continue), 417 (Expectation Failed)
-or similar after sending a HTTP request containing an Expect: 100-continue
+or similar after sending an HTTP request containing an Expect: 100-continue
header. If this times out before a response is received, the request body is
sent anyway.
.SH DEFAULT
curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1L);
ret = curl_easy_perform(curl);
if(ret == CURLE_HTTP_RETURNED_ERROR) {
- /* a HTTP response error problem */
+ /* an HTTP response error problem */
}
}
.fi
CURLcode curl_easy_setopt(CURL *handle, CURLOPT_FOLLOWLOCATION, long enable);
.SH DESCRIPTION
A long parameter set to 1 tells the library to follow any Location: header
-that the server sends as part of a HTTP header in a 3xx response. The
+that the server sends as part of an HTTP header in a 3xx response. The
Location: header can specify a relative or an absolute URL to follow.
libcurl will issue another request for the new URL and follow new Location:
HTTP status lines, for example, to delimit response boundaries.
When a server sends a chunked encoded transfer, it may contain a trailer. That
-trailer is identical to a HTTP header and if such a trailer is received it is
+trailer is identical to an HTTP header and if such a trailer is received it is
passed to the application using this callback as well. There are several ways
to detect it being a trailer and not an ordinary header: 1) it comes after the
response-body. 2) it comes after the final header line (CR LF) 3) a Trailer:
headers only to the proxy and then \fICURLOPT_HTTPHEADER(3)\fP headers only to
the server.
.SH DEFAULT
-CURLHEADER_SEPARATE (changed in 7.42.1, ased CURLHEADER_UNIFIED before then)
+CURLHEADER_SEPARATE (changed in 7.42.1, used CURLHEADER_UNIFIED before then)
.SH PROTOCOLS
HTTP
.SH EXAMPLE
.SH AVAILABILITY
Option Added in 7.10.6.
-CURLAUTH_DIGEST_IE was added added in 7.19.3
+CURLAUTH_DIGEST_IE was added in 7.19.3
CURLAUTH_ONLY was added in 7.21.3
.\"
.TH CURLOPT_HTTPGET 3 "17 Jun 2014" "libcurl 7.37.0" "curl_easy_setopt options"
.SH NAME
-CURLOPT_HTTPGET \- ask for a HTTP GET request
+CURLOPT_HTTPGET \- ask for an HTTP GET request
.SH SYNOPSIS
#include <curl/curl.h>
through the HTTP proxy (set with \fICURLOPT_PROXY(3)\fP). There is a big
difference between using a proxy and to tunnel through it.
-Tunneling means that a HTTP CONNECT request is sent to the proxy, asking it
+Tunneling means that an HTTP CONNECT request is sent to the proxy, asking it
to connect to a remote host on a specific port number and then the traffic is
just passed through the proxy. Proxies tend to white-list specific port numbers
it allows CONNECT requests to and often only port 80 and 443 are allowed.
HTTP proxies can generally only speak HTTP (for obvious reasons), which makes
libcurl convert non-HTTP requests to HTTP when using an HTTP proxy without
this tunnel option set. For example, asking for an FTP URL and specifying an
-HTTP proxy will make libcurl send an FTP URL in a HTTP GET request to the
+HTTP proxy will make libcurl send an FTP URL in an HTTP GET request to the
proxy. By instead tunneling through the proxy, you avoid that conversion (that
rarely works through the proxy anyway).
.SH DEFAULT
curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2TLS);
ret = curl_easy_perform(curl);
if(ret == CURLE_HTTP_RETURNED_ERROR) {
- /* a HTTP response error problem */
+ /* an HTTP response error problem */
}
}
.fi
This callback function gets called by libcurl when something special
I/O-related needs to be done that the library can't do by itself. For now,
rewinding the read data stream is the only action it can request. The
-rewinding of the read data stream may be necessary when doing a HTTP PUT or
+rewinding of the read data stream may be necessary when doing an HTTP PUT or
POST with a multi-pass authentication method.
The callback MUST return \fICURLIOE_UNKNOWNCMD\fP if the input \fIcmd\fP is
}
.fi
.SH AVAILABILITY
-Aded in 7.42.0
+Added in 7.42.0
.SH RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
.SH "SEE ALSO"
.\"
.TH CURLOPT_POST 3 "17 Jun 2014" "libcurl 7.37.0" "curl_easy_setopt options"
.SH NAME
-CURLOPT_POST \- request a HTTP POST
+CURLOPT_POST \- request an HTTP POST
.SH SYNOPSIS
#include <curl/curl.h>
Using POST with HTTP 1.1 implies the use of a "Expect: 100-continue" header.
You can disable this header with \fICURLOPT_HTTPHEADER(3)\fP as usual.
-If you use POST to a HTTP 1.1 server, you can send data without knowing the
+If you use POST to an 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(3)\fP. With HTTP 1.0 or without chunked transfer, you
CURLcode curl_easy_setopt(CURL *handle, CURLOPT_POSTFIELDS, char *postdata);
.SH DESCRIPTION
-Pass a char * as parameter, pointing to the full data to send in a HTTP POST
+Pass a char * as parameter, pointing to the full data to send 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 in any
way. For example, the web server may assume that this data is url-encoded.
.\"
.TH CURLOPT_POSTREDIR 3 "19 Jun 2014" "libcurl 7.37.0" "curl_easy_setopt options"
.SH NAME
-CURLOPT_POSTREDIR \- how to act on a HTTP POST redirect
+CURLOPT_POSTREDIR \- how to act on an HTTP POST redirect
.SH SYNOPSIS
.nf
#include <curl/curl.h>
Without a scheme prefix, \fICURLOPT_PROXYTYPE(3)\fP can be used to specify
which kind of proxy the string identifies.
-When you tell the library to use a HTTP proxy, libcurl will transparently
+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(3)\fP and similar FTP specifics that don't work unless you
CURLcode curl_easy_setopt(CURL *handle, CURLOPT_PROXY_CAINFO, char *path);
.SH DESCRIPTION
-This option is for connecting to a HTTPS proxy, not a HTTPS server.
+This option is for connecting to an HTTPS proxy, not an HTTPS server.
Pass a char * to a zero terminated string naming a file holding one or more
certificates to verify the HTTPS proxy with.
CURL *curl = curl_easy_init();
if(curl) {
curl_easy_setopt(curl, CURLOPT_URL, "https://example.com/");
- /* using a HTTPS proxy */
+ /* using an HTTPS proxy */
curl_easy_setopt(curl, CURLOPT_PROXY, "https://localhost:443");
curl_easy_setopt(curl, CURLOPT_PROXY_CAINFO, "/etc/certs/cabundle.pem");
ret = curl_easy_perform(curl);
CURL *curl = curl_easy_init();
if(curl) {
curl_easy_setopt(curl, CURLOPT_URL, "https://example.com/");
- /* using a HTTPS proxy */
+ /* using an HTTPS proxy */
curl_easy_setopt(curl, CURLOPT_PROXY, "https://localhost:443");
curl_easy_setopt(curl, CURLOPT_PROXY_CAPATH, "/etc/cert-dir");
ret = curl_easy_perform(curl);
CURLcode curl_easy_setopt(CURL *handle, CURLOPT_PROXY_CRLFILE, char *file);
.SH DESCRIPTION
-This option is for connecting to a HTTPS proxy, not a HTTPS server.
+This option is for connecting to an HTTPS proxy, not an HTTPS server.
Pass a char * to a zero terminated string naming a \fIfile\fP with the
concatenation of CRL (in PEM format) to use in the certificate validation that
CURLcode curl_easy_setopt(CURL *handle, CURLOPT_PROXY_KEYPASSWD, char *pwd);
.SH DESCRIPTION
-This option is for connecting to a HTTPS proxy, not a HTTPS server.
+This option is for connecting to an HTTPS proxy, not an HTTPS server.
Pass a pointer to a zero terminated string as parameter. It will be used as
the password required to use the \fICURLOPT_PROXY_SSLKEY(3)\fP private key.
CURLcode curl_easy_setopt(CURL *handle, CURLOPT_PROXY_SSLCERT, char *cert);
.SH DESCRIPTION
-This option is for connecting to a HTTPS proxy, not a HTTPS server.
+This option is for connecting to an HTTPS proxy, not an HTTPS server.
Pass a pointer to a zero terminated string as parameter. The string should be
the file name of your client certificate used to connect to the HTTPS proxy.
CURLcode curl_easy_setopt(CURL *handle, CURLOPT_PROXY_SSLCERTTYPE, char *type);
.SH DESCRIPTION
Pass a pointer to a zero terminated string as parameter. The string should be
-the format of your client certificate used when connecting to a HTTPS proxy.
+the format of your client certificate used when connecting to an HTTPS proxy.
Supported formats are "PEM" and "DER", except with Secure Transport. OpenSSL
(versions 0.9.3 and later) and Secure Transport (on iOS 5 or later, or OS X
CURLcode curl_easy_setopt(CURL *handle, CURLOPT_PROXY_SSLKEYTYPE, char *type);
.SH DESCRIPTION
-This option is for connecting to a HTTPS proxy, not a HTTPS server.
+This option is for connecting to an HTTPS proxy, not an HTTPS server.
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".
.SH DEFAULT
2
.SH PROTOCOLS
-All protocols when used over a HTTPS proxy.
+All protocols when used over an HTTPS proxy.
.SH EXAMPLE
.nf
CURL *curl = curl_easy_init();
CURLcode curl_easy_setopt(CURL *handle, CURLOPT_PROXY_TRANSFER_MODE, long enabled);
.SH DESCRIPTION
Pass a long. If the value is set to 1 (one), it tells libcurl to set the
-transfer mode (binary or ASCII) for FTP transfers done via a HTTP proxy, by
+transfer mode (binary or ASCII) for FTP transfers done via an HTTP proxy, by
appending ;type=a or ;type=i to the URL. Without this setting, or it being set
to 0 (zero, the default), \fICURLOPT_TRANSFERTEXT(3)\fP has no effect when
doing FTP via a proxy. Beware that not all proxies support this feature.
.\"
.TH CURLOPT_PUT 3 "17 Jun 2014" "libcurl 7.37.0" "curl_easy_setopt options"
.SH NAME
-CURLOPT_PUT \- make a HTTP PUT request
+CURLOPT_PUT \- make an HTTP PUT request
.SH SYNOPSIS
#include <curl/curl.h>
list of 'struct curl_slist' structs properly filled in with text strings. 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. When speaking to a FTP
+operation again by setting a NULL to this option. When speaking to an FTP
server, prefix the command with an asterisk (*) to make libcurl continue even
if the command fails as by default libcurl will stop at first failure.
CURLcode curl_easy_setopt(CURL *handle, CURLOPT_RTSP_CLIENT_CSEQ, long cseq);
.SH DESCRIPTION
-Pass a long to set the the CSEQ number to issue for the next RTSP
+Pass a long to set the CSEQ number to issue for the next RTSP
request. Useful if the application is resuming a previously broken
connection. The CSEQ will increment from this new number henceforth.
.SH DEFAULT
When sent by a client, this method changes the description of the session. For
example, if a client is using the server to record a meeting, the client can
use Announce to inform the server of all the meta-information about the
-session. ANNOUNCE acts like a HTTP PUT or POST just like
+session. ANNOUNCE acts like an HTTP PUT or POST just like
\fICURL_RTSPREQ_SET_PARAMETER\fP
.IP CURL_RTSPREQ_SETUP
Setup is used to initialize the transport layer for the session. The
.IP CURL_RTSPREQ_GET_PARAMETER
Retrieve a parameter from the server. By default, libcurl will automatically
include a \fIContent-Type: text/parameters\fP header on all non-empty requests
-unless a custom one is set. GET_PARAMETER acts just like a HTTP PUT or POST
+unless a custom one is set. GET_PARAMETER acts just like an HTTP PUT or POST
(see \fICURL_RTSPREQ_SET_PARAMETER\fP).
Applications wishing to send a heartbeat message (e.g. in the presence of a
server-specified timeout) should send use an empty GET_PARAMETER request.
.IP CURL_RTSPREQ_SET_PARAMETER
Set a parameter on the server. By default, libcurl will automatically include
a \fIContent-Type: text/parameters\fP header unless a custom one is set. The
-interaction with SET_PARAMETER is much like a HTTP PUT or POST. An application
+interaction with SET_PARAMETER is much like an HTTP PUT or POST. An application
may either use \fICURLOPT_UPLOAD(3)\fP with \fICURLOPT_READDATA(3)\fP like a
-HTTP PUT, or it may use \fICURLOPT_POSTFIELDS(3)\fP like a HTTP POST. No
+HTTP PUT, or it may use \fICURLOPT_POSTFIELDS(3)\fP like an HTTP POST. No
chunked transfers are allowed, so the application must set the
\fICURLOPT_INFILESIZE(3)\fP in the former and \fICURLOPT_POSTFIELDSIZE(3)\fP
in the latter. Also, there is no use of multi-part POSTs within RTSP.
(instead of reading all uploaded bytes with the normal read
function/callback). It is also called to rewind a stream when data has already
been sent to the server and needs to be sent again. This may happen when doing
-a HTTP PUT or POST with a multi-pass authentication method, or when an
+an HTTP PUT or POST with a multi-pass authentication method, or when an
existing HTTP connection is reused too late and the server closes the
connection. The function shall work like fseek(3) or lseek(3) and it gets
SEEK_SET, SEEK_CUR or SEEK_END as argument for \fIorigin\fP, although libcurl
To use this properly, a non-trivial amount of knowledge of your SSL library is
necessary. For example, you can use this function to call library-specific
callbacks to add additional validation code for certificates, and even to
-change the actual URI of a HTTPS request.
+change the actual URI of an HTTPS request.
.SH DEFAULT
NULL
.SH PROTOCOLS
.\"
.TH CURLOPT_STREAM_DEPENDS_E 3 "13 Sep 2015" "libcurl 7.46.0" "curl_easy_setopt options"
.SH NAME
-CURLOPT_STREAM_DEPENDS_E \- set stream this transfer depends on execlusively
+CURLOPT_STREAM_DEPENDS_E \- set stream this transfer depends on exclusively
.SH SYNOPSIS
#include <curl/curl.h>
connections, which thus implies that you use \fICURLMOPT_PIPELINING(3)\fP.
This option can be set during transfer and will then cause the updated weight
-info get sent to the server the next time a HTTP/2 frame is sent to the
+info get sent to the server the next time an HTTP/2 frame is sent to the
server.
See section 5.3 of RFC 7540 for protocol details:
POP3 and SMTP should in particular work (including their SSL/TLS variants).
.SH EXAMPLE
Given that you have an nginx server running, listening on /tmp/nginx.sock, you
-can request a HTTP resource with:
+can request an HTTP resource with:
.nf
curl_easy_setopt(curl_handle, CURLOPT_UNIX_SOCKET_PATH, "/tmp/nginx.sock");
Using PUT with HTTP 1.1 implies the use of a "Expect: 100-continue" header.
You can disable this header with \fICURLOPT_HTTPHEADER(3)\fP as usual.
-If you use PUT to a HTTP 1.1 server, you can upload data without knowing the
+If you use PUT to an 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(3)\fP. With HTTP 1.0 or without chunked transfer, you
given below this list is not conclusive:
.IP HTTP
-The path part of a HTTP request specifies the file to retrieve and from what
+The path part of an HTTP request specifies the file to retrieve and from what
directory. If the directory is not specified then the web server's root
directory is used. If the file is omitted then the default document will be
retrieved for either the directory specified or the root directory. The exact
projects / curl / commitdiff