}
#endif
-static CURLcode setopt_long(struct Curl_easy *data, CURLoption option,
- long arg)
+static CURLcode setopt_bool(struct Curl_easy *data, CURLoption option,
+ long arg, bool *set)
{
bool enabled = !!arg;
- unsigned long uarg = (unsigned long)arg;
+ struct UserDefined *s = &data->set;
switch(option) {
- case CURLOPT_DNS_CACHE_TIMEOUT:
- if(arg < -1)
- return CURLE_BAD_FUNCTION_ARGUMENT;
- else if(arg > INT_MAX)
- arg = INT_MAX;
-
- data->set.dns_cache_timeout = (int)arg;
- break;
- case CURLOPT_CA_CACHE_TIMEOUT:
- if(Curl_ssl_supports(data, SSLSUPP_CA_CACHE)) {
- if(arg < -1)
- return CURLE_BAD_FUNCTION_ARGUMENT;
- else if(arg > INT_MAX)
- arg = INT_MAX;
-
- data->set.general_ssl.ca_cache_timeout = (int)arg;
- }
- else
- return CURLE_NOT_BUILT_IN;
- break;
- case CURLOPT_MAXCONNECTS:
- /*
- * Set the absolute number of maximum simultaneous alive connection that
- * libcurl is allowed to have.
- */
- if(uarg > UINT_MAX)
- return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.maxconnects = (unsigned int)uarg;
- break;
case CURLOPT_FORBID_REUSE:
/*
* When this transfer is done, it must not be left to be reused by a
* subsequent transfer but shall be closed immediately.
*/
- data->set.reuse_forbid = enabled;
+ s->reuse_forbid = enabled;
break;
case CURLOPT_FRESH_CONNECT:
/*
* This transfer shall not use a previously cached connection but
* should be made with a fresh new connect!
*/
- data->set.reuse_fresh = enabled;
+ s->reuse_fresh = enabled;
break;
case CURLOPT_VERBOSE:
/*
* Verbose means infof() calls that give a lot of information about
* the connection and transfer procedures as well as internal choices.
*/
- data->set.verbose = enabled;
+ s->verbose = enabled;
break;
case CURLOPT_HEADER:
/*
* Set to include the header in the general data output stream.
*/
- data->set.include_header = enabled;
+ s->include_header = enabled;
break;
case CURLOPT_NOPROGRESS:
/*
/*
* Do not include the body part in the output data stream.
*/
- data->set.opt_no_body = enabled;
+ s->opt_no_body = enabled;
#ifndef CURL_DISABLE_HTTP
- if(data->set.opt_no_body)
+ if(s->opt_no_body)
/* in HTTP lingo, no body means using the HEAD request... */
- data->set.method = HTTPREQ_HEAD;
- else if(data->set.method == HTTPREQ_HEAD)
- data->set.method = HTTPREQ_GET;
+ s->method = HTTPREQ_HEAD;
+ else if(s->method == HTTPREQ_HEAD)
+ s->method = HTTPREQ_GET;
#endif
break;
case CURLOPT_FAILONERROR:
* Do not output the >=400 error code HTML-page, but instead only
* return error.
*/
- data->set.http_fail_on_error = enabled;
+ s->http_fail_on_error = enabled;
break;
case CURLOPT_KEEP_SENDING_ON_ERROR:
- data->set.http_keep_sending_on_error = enabled;
+ s->http_keep_sending_on_error = enabled;
break;
case CURLOPT_UPLOAD:
case CURLOPT_PUT:
* We want to sent data to the remote host. If this is HTTP, that equals
* using the PUT request.
*/
- if(arg) {
+ if(enabled) {
/* If this is HTTP, PUT is what's needed to "upload" */
- data->set.method = HTTPREQ_PUT;
- data->set.opt_no_body = FALSE; /* this is implied */
+ s->method = HTTPREQ_PUT;
+ s->opt_no_body = FALSE; /* this is implied */
}
else
/* In HTTP, the opposite of upload is GET (unless NOBODY is true as
then this can be changed to HEAD later on) */
- data->set.method = HTTPREQ_GET;
+ s->method = HTTPREQ_GET;
break;
case CURLOPT_FILETIME:
/*
* Try to get the file time of the remote document. The time will
* later (possibly) become available using curl_easy_getinfo().
*/
- data->set.get_filetime = enabled;
+ s->get_filetime = enabled;
break;
- case CURLOPT_SERVER_RESPONSE_TIMEOUT:
+#ifndef CURL_DISABLE_HTTP
+ case CURLOPT_HTTP09_ALLOWED:
+ s->http09_allowed = enabled;
+ break;
+#if !defined(CURL_DISABLE_COOKIES)
+ case CURLOPT_COOKIESESSION:
/*
- * Option that specifies how quickly a server response must be obtained
- * before it is considered failure. For pingpong protocols.
+ * Set this option to TRUE to start a new "cookie session". It will
+ * prevent the forthcoming read-cookies-from-file actions to accept
+ * cookies that are marked as being session cookies, as they belong to a
+ * previous session.
+ */
+ s->cookiesession = enabled;
+ break;
+#endif
+ case CURLOPT_AUTOREFERER:
+ /*
+ * Switch on automatic referer that gets set if curl follows locations.
*/
- return setopt_set_timeout_sec(&data->set.server_response_timeout, arg);
+ s->http_auto_referer = enabled;
+ break;
- case CURLOPT_SERVER_RESPONSE_TIMEOUT_MS:
+ case CURLOPT_TRANSFER_ENCODING:
+ s->http_transfer_encoding = enabled;
+ break;
+ case CURLOPT_UNRESTRICTED_AUTH:
/*
- * Option that specifies how quickly a server response must be obtained
- * before it is considered failure. For pingpong protocols.
+ * Send authentication (user+password) when following locations, even when
+ * hostname changed.
+ */
+ s->allow_auth_to_other_hosts = enabled;
+ break;
+
+ case CURLOPT_HTTP_TRANSFER_DECODING:
+ /*
+ * disable libcurl transfer encoding is used
+ */
+ s->http_te_skip = !enabled; /* reversed */
+ break;
+
+ case CURLOPT_HTTP_CONTENT_DECODING:
+ /*
+ * raw data passed to the application when content encoding is used
+ */
+ s->http_ce_skip = !enabled; /* reversed */
+ break;
+
+ case CURLOPT_HTTPGET:
+ /*
+ * Set to force us do HTTP GET
+ */
+ if(enabled) {
+ s->method = HTTPREQ_GET;
+ s->opt_no_body = FALSE; /* this is implied */
+ }
+ break;
+ case CURLOPT_POST:
+ /* Does this option serve a purpose anymore? Yes it does, when
+ CURLOPT_POSTFIELDS is not used and the POST data is read off the
+ callback! */
+ if(enabled) {
+ s->method = HTTPREQ_POST;
+ s->opt_no_body = FALSE; /* this is implied */
+ }
+ else
+ s->method = HTTPREQ_GET;
+ break;
+#endif /* ! CURL_DISABLE_HTTP */
+#ifndef CURL_DISABLE_PROXY
+ case CURLOPT_HTTPPROXYTUNNEL:
+ /*
+ * Tunnel operations through the proxy instead of normal proxy use
+ */
+ s->tunnel_thru_httpproxy = enabled;
+ break;
+ case CURLOPT_HAPROXYPROTOCOL:
+ /*
+ * Set to send the HAProxy Proxy Protocol header
+ */
+ s->haproxyprotocol = enabled;
+ break;
+ case CURLOPT_PROXY_SSL_VERIFYPEER:
+ /*
+ * Enable peer SSL verifying for proxy.
+ */
+ s->proxy_ssl.primary.verifypeer = enabled;
+
+ /* Update the current connection proxy_ssl_config. */
+ Curl_ssl_conn_config_update(data, TRUE);
+ break;
+ case CURLOPT_PROXY_SSL_VERIFYHOST:
+ /*
+ * Enable verification of the hostname in the peer certificate for proxy
+ */
+ s->proxy_ssl.primary.verifyhost = enabled;
+
+ /* Update the current connection proxy_ssl_config. */
+ Curl_ssl_conn_config_update(data, TRUE);
+ break;
+ case CURLOPT_PROXY_TRANSFER_MODE:
+ /*
+ * set transfer mode (;type=<a|i>) when doing FTP via an HTTP proxy
+ */
+ s->proxy_transfer_mode = enabled;
+ break;
+#endif /* ! CURL_DISABLE_PROXY */
+#if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
+ case CURLOPT_SOCKS5_GSSAPI_NEC:
+ /*
+ * Set flag for NEC SOCK5 support
+ */
+ s->socks5_gssapi_nec = enabled;
+ break;
+#endif
+#ifdef CURL_LIST_ONLY_PROTOCOL
+ case CURLOPT_DIRLISTONLY:
+ /*
+ * An option that changes the command to one that asks for a list only, no
+ * file info details. Used for FTP, POP3 and SFTP.
+ */
+ s->list_only = enabled;
+ break;
+#endif
+ case CURLOPT_APPEND:
+ /*
+ * We want to upload and append to an existing file. Used for FTP and
+ * SFTP.
+ */
+ s->remote_append = enabled;
+ break;
+#ifndef CURL_DISABLE_FTP
+ case CURLOPT_FTP_USE_EPRT:
+ s->ftp_use_eprt = enabled;
+ break;
+
+ case CURLOPT_FTP_USE_EPSV:
+ s->ftp_use_epsv = enabled;
+ break;
+
+ case CURLOPT_FTP_USE_PRET:
+ s->ftp_use_pret = enabled;
+ break;
+ case CURLOPT_FTP_SKIP_PASV_IP:
+ /*
+ * Enable or disable FTP_SKIP_PASV_IP, which will disable/enable the
+ * bypass of the IP address in PASV responses.
*/
- return setopt_set_timeout_ms(&data->set.server_response_timeout, arg);
+ s->ftp_skip_ip = enabled;
+ break;
+ case CURLOPT_WILDCARDMATCH:
+ s->wildcard_enabled = enabled;
+ break;
+#endif
+ case CURLOPT_CRLF:
+ /*
+ * Kludgy option to enable CRLF conversions. Subject for removal.
+ */
+ s->crlf = enabled;
+ break;
#ifndef CURL_DISABLE_TFTP
case CURLOPT_TFTP_NO_OPTIONS:
* Option that prevents libcurl from sending TFTP option requests to the
* server.
*/
- data->set.tftp_no_options = enabled;
+ s->tftp_no_options = enabled;
+ break;
+#endif /* ! CURL_DISABLE_TFTP */
+ case CURLOPT_TRANSFERTEXT:
+ /*
+ * This option was previously named 'FTPASCII'. Renamed to work with
+ * more protocols than merely FTP.
+ *
+ * Transfer using ASCII (instead of BINARY).
+ */
+ s->prefer_ascii = enabled;
+ break;
+ case CURLOPT_SSL_VERIFYPEER:
+ /*
+ * Enable peer SSL verifying.
+ */
+ s->ssl.primary.verifypeer = enabled;
+
+ /* Update the current connection ssl_config. */
+ Curl_ssl_conn_config_update(data, FALSE);
+ break;
+#ifndef CURL_DISABLE_DOH
+ case CURLOPT_DOH_SSL_VERIFYPEER:
+ /*
+ * Enable peer SSL verifying for DoH.
+ */
+ s->doh_verifypeer = enabled;
+ break;
+ case CURLOPT_DOH_SSL_VERIFYHOST:
+ /*
+ * Enable verification of the hostname in the peer certificate for DoH
+ */
+ s->doh_verifyhost = enabled;
+ break;
+ case CURLOPT_DOH_SSL_VERIFYSTATUS:
+ /*
+ * Enable certificate status verifying for DoH.
+ */
+ if(!Curl_ssl_cert_status_request())
+ return CURLE_NOT_BUILT_IN;
+
+ s->doh_verifystatus = enabled;
+ break;
+#endif /* ! CURL_DISABLE_DOH */
+ case CURLOPT_SSL_VERIFYHOST:
+ /*
+ * Enable verification of the hostname in the peer certificate
+ */
+
+ /* Obviously people are not reading documentation and too many thought
+ this argument took a boolean when it was not and misused it.
+ Treat 1 and 2 the same */
+ s->ssl.primary.verifyhost = enabled;
+
+ /* Update the current connection ssl_config. */
+ Curl_ssl_conn_config_update(data, FALSE);
+ break;
+ case CURLOPT_SSL_VERIFYSTATUS:
+ /*
+ * Enable certificate status verifying.
+ */
+ if(!Curl_ssl_cert_status_request())
+ return CURLE_NOT_BUILT_IN;
+
+ s->ssl.primary.verifystatus = enabled;
+
+ /* Update the current connection ssl_config. */
+ Curl_ssl_conn_config_update(data, FALSE);
+ break;
+ case CURLOPT_CERTINFO:
+#ifdef USE_SSL
+ if(Curl_ssl_supports(data, SSLSUPP_CERTINFO))
+ s->ssl.certinfo = enabled;
+ else
+#endif
+ return CURLE_NOT_BUILT_IN;
+ break;
+ case CURLOPT_NOSIGNAL:
+ /*
+ * The application asks not to set any signal() or alarm() handlers,
+ * even when using a timeout.
+ */
+ s->no_signal = enabled;
+ break;
+ case CURLOPT_TCP_NODELAY:
+ /*
+ * Enable or disable TCP_NODELAY, which will disable/enable the Nagle
+ * algorithm
+ */
+ s->tcp_nodelay = enabled;
+ break;
+
+ case CURLOPT_IGNORE_CONTENT_LENGTH:
+ s->ignorecl = enabled;
+ break;
+ case CURLOPT_SSL_SESSIONID_CACHE:
+ s->ssl.primary.cache_session = enabled;
+#ifndef CURL_DISABLE_PROXY
+ s->proxy_ssl.primary.cache_session =
+ s->ssl.primary.cache_session;
+#endif
+ break;
+#ifdef USE_SSH
+ case CURLOPT_SSH_COMPRESSION:
+ s->ssh_compression = enabled;
+ break;
+#endif /* ! USE_SSH */
+#ifndef CURL_DISABLE_SMTP
+ case CURLOPT_MAIL_RCPT_ALLOWFAILS:
+ /* allow RCPT TO command to fail for some recipients */
+ s->mail_rcpt_allowfails = enabled;
+ break;
+#endif /* !CURL_DISABLE_SMTP */
+ case CURLOPT_SASL_IR:
+ /* Enable/disable SASL initial response */
+ s->sasl_ir = enabled;
+ break;
+ case CURLOPT_TCP_KEEPALIVE:
+ s->tcp_keepalive = enabled;
+ break;
+ case CURLOPT_TCP_FASTOPEN:
+#if defined(CONNECT_DATA_IDEMPOTENT) || defined(MSG_FASTOPEN) || \
+ defined(TCP_FASTOPEN_CONNECT)
+ s->tcp_fastopen = enabled;
+#else
+ return CURLE_NOT_BUILT_IN;
+#endif
+ break;
+ case CURLOPT_SSL_ENABLE_ALPN:
+ s->ssl_enable_alpn = enabled;
+ break;
+ case CURLOPT_PATH_AS_IS:
+ s->path_as_is = enabled;
+ break;
+ case CURLOPT_PIPEWAIT:
+ s->pipewait = enabled;
+ break;
+ case CURLOPT_SUPPRESS_CONNECT_HEADERS:
+ s->suppress_connect_headers = enabled;
+ break;
+#ifndef CURL_DISABLE_SHUFFLE_DNS
+ case CURLOPT_DNS_SHUFFLE_ADDRESSES:
+ s->dns_shuffle_addresses = enabled;
+ break;
+#endif
+ case CURLOPT_DISALLOW_USERNAME_IN_URL:
+ s->disallow_username_in_url = enabled;
+ break;
+ case CURLOPT_QUICK_EXIT:
+ s->quick_exit = enabled;
+ break;
+ default:
+ return CURLE_OK;
+ }
+ if((arg > 1) || (arg < 0))
+ /* reserve other values for future use */
+ infof(data, "boolean setopt(%d) got unsupported argument %ld,"
+ " treated as %d", option, arg, enabled);
+
+ *set = TRUE;
+ return CURLE_OK;
+}
+
+static CURLcode setopt_long(struct Curl_easy *data, CURLoption option,
+ long arg)
+{
+ unsigned long uarg = (unsigned long)arg;
+ bool set = FALSE;
+ CURLcode result = setopt_bool(data, option, arg, &set);
+ struct UserDefined *s = &data->set;
+ if(set || result)
+ return result;
+
+ switch(option) {
+ case CURLOPT_DNS_CACHE_TIMEOUT:
+ if(arg < -1)
+ return CURLE_BAD_FUNCTION_ARGUMENT;
+ else if(arg > INT_MAX)
+ arg = INT_MAX;
+
+ s->dns_cache_timeout = (int)arg;
+ break;
+ case CURLOPT_CA_CACHE_TIMEOUT:
+ if(Curl_ssl_supports(data, SSLSUPP_CA_CACHE)) {
+ if(arg < -1)
+ return CURLE_BAD_FUNCTION_ARGUMENT;
+ else if(arg > INT_MAX)
+ arg = INT_MAX;
+
+ s->general_ssl.ca_cache_timeout = (int)arg;
+ }
+ else
+ return CURLE_NOT_BUILT_IN;
+ break;
+ case CURLOPT_MAXCONNECTS:
+ /*
+ * Set the absolute number of maximum simultaneous alive connection that
+ * libcurl is allowed to have.
+ */
+ if(uarg > UINT_MAX)
+ return CURLE_BAD_FUNCTION_ARGUMENT;
+ s->maxconnects = (unsigned int)uarg;
break;
+ case CURLOPT_SERVER_RESPONSE_TIMEOUT:
+ /*
+ * Option that specifies how quickly a server response must be obtained
+ * before it is considered failure. For pingpong protocols.
+ */
+ return setopt_set_timeout_sec(&s->server_response_timeout, arg);
+
+ case CURLOPT_SERVER_RESPONSE_TIMEOUT_MS:
+ /*
+ * Option that specifies how quickly a server response must be obtained
+ * before it is considered failure. For pingpong protocols.
+ */
+ return setopt_set_timeout_ms(&s->server_response_timeout, arg);
+
+#ifndef CURL_DISABLE_TFTP
case CURLOPT_TFTP_BLKSIZE:
/*
* TFTP option that specifies the block size to use for data transmission.
arg = 512;
else if(arg > TFTP_BLKSIZE_MAX)
arg = TFTP_BLKSIZE_MAX;
- data->set.tftp_blksize = arg;
+ s->tftp_blksize = arg;
break;
#endif
#ifndef CURL_DISABLE_NETRC
*/
if((arg < CURL_NETRC_IGNORED) || (arg >= CURL_NETRC_LAST))
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.use_netrc = (unsigned char)arg;
+ s->use_netrc = (unsigned char)arg;
break;
#endif
- case CURLOPT_TRANSFERTEXT:
- /*
- * This option was previously named 'FTPASCII'. Renamed to work with
- * more protocols than merely FTP.
- *
- * Transfer using ASCII (instead of BINARY).
- */
- data->set.prefer_ascii = enabled;
- break;
case CURLOPT_TIMECONDITION:
/*
* Set HTTP time condition. This must be one of the defines in the
*/
if((arg < CURL_TIMECOND_NONE) || (arg >= CURL_TIMECOND_LAST))
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.timecondition = (unsigned char)arg;
+ s->timecondition = (unsigned char)arg;
break;
case CURLOPT_TIMEVALUE:
/*
* This is the value to compare with the remote document with the
* method set with CURLOPT_TIMECONDITION
*/
- data->set.timevalue = (time_t)arg;
+ s->timevalue = (time_t)arg;
break;
case CURLOPT_SSLVERSION:
#ifndef CURL_DISABLE_PROXY
if(arg < -1)
return CURLE_BAD_FUNCTION_ARGUMENT;
- if(data->set.postfieldsize < arg &&
- data->set.postfields == data->set.str[STRING_COPYPOSTFIELDS]) {
+ if(s->postfieldsize < arg &&
+ s->postfields == s->str[STRING_COPYPOSTFIELDS]) {
/* Previous CURLOPT_COPYPOSTFIELDS is no longer valid. */
- Curl_safefree(data->set.str[STRING_COPYPOSTFIELDS]);
- data->set.postfields = NULL;
+ Curl_safefree(s->str[STRING_COPYPOSTFIELDS]);
+ s->postfields = NULL;
}
- data->set.postfieldsize = arg;
+ s->postfieldsize = arg;
break;
#ifndef CURL_DISABLE_HTTP
-#ifndef CURL_DISABLE_COOKIES
- case CURLOPT_COOKIESESSION:
- /*
- * Set this option to TRUE to start a new "cookie session". It will
- * prevent the forthcoming read-cookies-from-file actions to accept
- * cookies that are marked as being session cookies, as they belong to a
- * previous session.
- */
- data->set.cookiesession = enabled;
- break;
-#endif
- case CURLOPT_AUTOREFERER:
- /*
- * Switch on automatic referer that gets set if curl follows locations.
- */
- data->set.http_auto_referer = enabled;
- break;
-
- case CURLOPT_TRANSFER_ENCODING:
- data->set.http_transfer_encoding = enabled;
- break;
-
case CURLOPT_FOLLOWLOCATION:
/*
* Follow Location: header hints on an HTTP-server.
*/
if(uarg > 3)
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.http_follow_mode = (unsigned char)uarg;
- break;
-
- case CURLOPT_UNRESTRICTED_AUTH:
- /*
- * Send authentication (user+password) when following locations, even when
- * hostname changed.
- */
- data->set.allow_auth_to_other_hosts = enabled;
+ s->http_follow_mode = (unsigned char)uarg;
break;
case CURLOPT_MAXREDIRS:
*/
if(arg < -1)
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.maxredirs = arg;
+ s->maxredirs = arg;
break;
case CURLOPT_POSTREDIR:
/* no return error on too high numbers since the bitmask could be
extended in a future */
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.keep_post = arg & CURL_REDIR_POST_ALL;
+ s->keep_post = arg & CURL_REDIR_POST_ALL;
break;
- case CURLOPT_POST:
- /* Does this option serve a purpose anymore? Yes it does, when
- CURLOPT_POSTFIELDS is not used and the POST data is read off the
- callback! */
- if(arg) {
- data->set.method = HTTPREQ_POST;
- data->set.opt_no_body = FALSE; /* this is implied */
- }
- else
- data->set.method = HTTPREQ_GET;
- break;
case CURLOPT_HEADEROPT:
/*
* Set header option.
*/
- data->set.sep_headers = !!(arg & CURLHEADER_SEPARATE);
+ s->sep_headers = !!(arg & CURLHEADER_SEPARATE);
break;
case CURLOPT_HTTPAUTH:
return httpauth(data, FALSE, uarg);
- case CURLOPT_HTTPGET:
- /*
- * Set to force us do HTTP GET
- */
- if(enabled) {
- data->set.method = HTTPREQ_GET;
- data->set.opt_no_body = FALSE; /* this is implied */
- }
- break;
-
case CURLOPT_HTTP_VERSION:
return setopt_HTTP_VERSION(data, arg);
*/
if(arg < 0)
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.expect_100_timeout = arg;
+ s->expect_100_timeout = arg;
break;
- case CURLOPT_HTTP09_ALLOWED:
- data->set.http09_allowed = enabled;
- break;
#endif /* ! CURL_DISABLE_HTTP */
#ifndef CURL_DISABLE_MIME
case CURLOPT_MIME_OPTIONS:
- data->set.mime_formescape = !!(arg & CURLMIMEOPT_FORMESCAPE);
+ s->mime_formescape = !!(arg & CURLMIMEOPT_FORMESCAPE);
break;
#endif
#ifndef CURL_DISABLE_PROXY
- case CURLOPT_HTTPPROXYTUNNEL:
- /*
- * Tunnel operations through the proxy instead of normal proxy use
- */
- data->set.tunnel_thru_httpproxy = enabled;
- break;
-
case CURLOPT_PROXYPORT:
/*
* Explicitly set HTTP proxy port number.
*/
if((arg < 0) || (arg > 65535))
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.proxyport = (unsigned short)arg;
+ s->proxyport = (unsigned short)arg;
break;
case CURLOPT_PROXYAUTH:
*/
if((arg < CURLPROXY_HTTP) || (arg > CURLPROXY_SOCKS5_HOSTNAME))
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.proxytype = (unsigned char)arg;
+ s->proxytype = (unsigned char)arg;
break;
- case CURLOPT_PROXY_TRANSFER_MODE:
- /*
- * set transfer mode (;type=<a|i>) when doing FTP via an HTTP proxy
- */
- if(uarg > 1)
- /* reserve other values for future use */
- return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.proxy_transfer_mode = (bool)uarg;
- break;
case CURLOPT_SOCKS5_AUTH:
if(uarg & ~(CURLAUTH_BASIC | CURLAUTH_GSSAPI))
return CURLE_NOT_BUILT_IN;
- data->set.socks5auth = (unsigned char)uarg;
- break;
- case CURLOPT_HAPROXYPROTOCOL:
- /*
- * Set to send the HAProxy Proxy Protocol header
- */
- data->set.haproxyprotocol = enabled;
- break;
- case CURLOPT_PROXY_SSL_VERIFYPEER:
- /*
- * Enable peer SSL verifying for proxy.
- */
- data->set.proxy_ssl.primary.verifypeer = enabled;
-
- /* Update the current connection proxy_ssl_config. */
- Curl_ssl_conn_config_update(data, TRUE);
- break;
- case CURLOPT_PROXY_SSL_VERIFYHOST:
- /*
- * Enable verification of the hostname in the peer certificate for proxy
- */
- data->set.proxy_ssl.primary.verifyhost = enabled;
-
- /* Update the current connection proxy_ssl_config. */
- Curl_ssl_conn_config_update(data, TRUE);
+ s->socks5auth = (unsigned char)uarg;
break;
#endif /* ! CURL_DISABLE_PROXY */
-#if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
- case CURLOPT_SOCKS5_GSSAPI_NEC:
- /*
- * Set flag for NEC SOCK5 support
- */
- data->set.socks5_gssapi_nec = enabled;
- break;
-#endif
-#ifdef CURL_LIST_ONLY_PROTOCOL
- case CURLOPT_DIRLISTONLY:
- /*
- * An option that changes the command to one that asks for a list only, no
- * file info details. Used for FTP, POP3 and SFTP.
- */
- data->set.list_only = enabled;
- break;
-#endif
- case CURLOPT_APPEND:
- /*
- * We want to upload and append to an existing file. Used for FTP and
- * SFTP.
- */
- data->set.remote_append = enabled;
- break;
-
#ifndef CURL_DISABLE_FTP
case CURLOPT_FTP_FILEMETHOD:
/*
*/
if((arg < CURLFTPMETHOD_DEFAULT) || (arg >= CURLFTPMETHOD_LAST))
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.ftp_filemethod = (unsigned char)arg;
- break;
- case CURLOPT_FTP_USE_EPRT:
- data->set.ftp_use_eprt = enabled;
- break;
-
- case CURLOPT_FTP_USE_EPSV:
- data->set.ftp_use_epsv = enabled;
+ s->ftp_filemethod = (unsigned char)arg;
break;
-
- case CURLOPT_FTP_USE_PRET:
- data->set.ftp_use_pret = enabled;
- break;
-
case CURLOPT_FTP_SSL_CCC:
if((arg < CURLFTPSSL_CCC_NONE) || (arg >= CURLFTPSSL_CCC_LAST))
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.ftp_ccc = (unsigned char)arg;
- break;
-
- case CURLOPT_FTP_SKIP_PASV_IP:
- /*
- * Enable or disable FTP_SKIP_PASV_IP, which will disable/enable the
- * bypass of the IP address in PASV responses.
- */
- data->set.ftp_skip_ip = enabled;
+ s->ftp_ccc = (unsigned char)arg;
break;
case CURLOPT_FTPSSLAUTH:
*/
if((arg < CURLFTPAUTH_DEFAULT) || (arg >= CURLFTPAUTH_LAST))
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.ftpsslauth = (unsigned char)arg;
+ s->ftpsslauth = (unsigned char)arg;
break;
case CURLOPT_ACCEPTTIMEOUT_MS:
/*
* The maximum time for curl to wait for FTP server connect
*/
- return setopt_set_timeout_ms(&data->set.accepttimeout, arg);
-
- case CURLOPT_WILDCARDMATCH:
- data->set.wildcard_enabled = enabled;
- break;
+ return setopt_set_timeout_ms(&s->accepttimeout, arg);
#endif /* ! CURL_DISABLE_FTP */
#if !defined(CURL_DISABLE_FTP) || defined(USE_SSH)
case CURLOPT_FTP_CREATE_MISSING_DIRS:
/* reserve other values for future use */
if((arg < CURLFTP_CREATE_DIR_NONE) || (arg > CURLFTP_CREATE_DIR_RETRY))
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.ftp_create_missing_dirs = (unsigned char)arg;
+ s->ftp_create_missing_dirs = (unsigned char)arg;
break;
#endif /* ! CURL_DISABLE_FTP || USE_SSH */
case CURLOPT_INFILESIZE:
*/
if(arg < -1)
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.filesize = arg;
+ s->filesize = arg;
break;
case CURLOPT_LOW_SPEED_LIMIT:
/*
*/
if(arg < 0)
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.low_speed_limit = arg;
+ s->low_speed_limit = arg;
break;
case CURLOPT_LOW_SPEED_TIME:
/*
*/
if(arg < 0)
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.low_speed_time = arg;
+ s->low_speed_time = arg;
break;
case CURLOPT_PORT:
/*
*/
if((arg < 0) || (arg > 65535))
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.use_port = (unsigned short)arg;
+ s->use_port = (unsigned short)arg;
break;
case CURLOPT_TIMEOUT:
/*
* The maximum time you allow curl to use for a single transfer
* operation.
*/
- return setopt_set_timeout_sec(&data->set.timeout, arg);
+ return setopt_set_timeout_sec(&s->timeout, arg);
case CURLOPT_TIMEOUT_MS:
- return setopt_set_timeout_ms(&data->set.timeout, arg);
+ return setopt_set_timeout_ms(&s->timeout, arg);
case CURLOPT_CONNECTTIMEOUT:
/*
* The maximum time you allow curl to use to connect.
*/
- return setopt_set_timeout_sec(&data->set.connecttimeout, arg);
+ return setopt_set_timeout_sec(&s->connecttimeout, arg);
case CURLOPT_CONNECTTIMEOUT_MS:
- return setopt_set_timeout_ms(&data->set.connecttimeout, arg);
+ return setopt_set_timeout_ms(&s->connecttimeout, arg);
case CURLOPT_RESUME_FROM:
/*
*/
if(arg < -1)
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.set_resume_from = arg;
- break;
-
- case CURLOPT_CRLF:
- /*
- * Kludgy option to enable CRLF conversions. Subject for removal.
- */
- data->set.crlf = enabled;
+ s->set_resume_from = arg;
break;
#ifndef CURL_DISABLE_BINDLOCAL
*/
if((arg < 0) || (arg > 65535))
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.localport = curlx_sltous(arg);
+ s->localport = curlx_sltous(arg);
break;
case CURLOPT_LOCALPORTRANGE:
/*
*/
if((arg < 0) || (arg > 65535))
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.localportrange = curlx_sltous(arg);
+ s->localportrange = curlx_sltous(arg);
break;
#endif
/*
* GSS-API credential delegation bitmask
*/
- data->set.gssapi_delegation = (unsigned char)uarg&
+ s->gssapi_delegation = (unsigned char)uarg&
(CURLGSSAPI_DELEGATION_POLICY_FLAG|CURLGSSAPI_DELEGATION_FLAG);
break;
#endif
- case CURLOPT_SSL_VERIFYPEER:
- /*
- * Enable peer SSL verifying.
- */
- data->set.ssl.primary.verifypeer = enabled;
-
- /* Update the current connection ssl_config. */
- Curl_ssl_conn_config_update(data, FALSE);
- break;
-#ifndef CURL_DISABLE_DOH
- case CURLOPT_DOH_SSL_VERIFYPEER:
- /*
- * Enable peer SSL verifying for DoH.
- */
- data->set.doh_verifypeer = enabled;
- break;
- case CURLOPT_DOH_SSL_VERIFYHOST:
- /*
- * Enable verification of the hostname in the peer certificate for DoH
- */
- data->set.doh_verifyhost = enabled;
- break;
- case CURLOPT_DOH_SSL_VERIFYSTATUS:
- /*
- * Enable certificate status verifying for DoH.
- */
- if(!Curl_ssl_cert_status_request())
- return CURLE_NOT_BUILT_IN;
-
- data->set.doh_verifystatus = enabled;
- break;
-#endif /* ! CURL_DISABLE_DOH */
- case CURLOPT_SSL_VERIFYHOST:
- /*
- * Enable verification of the hostname in the peer certificate
- */
-
- /* Obviously people are not reading documentation and too many thought
- this argument took a boolean when it was not and misused it.
- Treat 1 and 2 the same */
- data->set.ssl.primary.verifyhost = enabled;
-
- /* Update the current connection ssl_config. */
- Curl_ssl_conn_config_update(data, FALSE);
- break;
- case CURLOPT_SSL_VERIFYSTATUS:
- /*
- * Enable certificate status verifying.
- */
- if(!Curl_ssl_cert_status_request())
- return CURLE_NOT_BUILT_IN;
- data->set.ssl.primary.verifystatus = enabled;
-
- /* Update the current connection ssl_config. */
- Curl_ssl_conn_config_update(data, FALSE);
- break;
case CURLOPT_SSL_FALSESTART:
/*
* No TLS backends support false start anymore.
*/
return CURLE_NOT_BUILT_IN;
- case CURLOPT_CERTINFO:
-#ifdef USE_SSL
- if(Curl_ssl_supports(data, SSLSUPP_CERTINFO))
- data->set.ssl.certinfo = enabled;
- else
-#endif
- return CURLE_NOT_BUILT_IN;
- break;
case CURLOPT_BUFFERSIZE:
/*
* The application kindly asks for a differently sized receive buffer.
else if(arg < READBUFFER_MIN)
arg = READBUFFER_MIN;
- data->set.buffer_size = (unsigned int)arg;
+ s->buffer_size = (unsigned int)arg;
break;
case CURLOPT_UPLOAD_BUFFERSIZE:
else if(arg < UPLOADBUFFER_MIN)
arg = UPLOADBUFFER_MIN;
- data->set.upload_buffer_size = (unsigned int)arg;
+ s->upload_buffer_size = (unsigned int)arg;
break;
- case CURLOPT_NOSIGNAL:
- /*
- * The application asks not to set any signal() or alarm() handlers,
- * even when using a timeout.
- */
- data->set.no_signal = enabled;
- break;
case CURLOPT_MAXFILESIZE:
/*
* Set the maximum size of a file to download.
*/
if(arg < 0)
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.max_filesize = arg;
+ s->max_filesize = arg;
break;
#ifdef USE_SSL
*/
if((arg < CURLUSESSL_NONE) || (arg >= CURLUSESSL_LAST))
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.use_ssl = (unsigned char)arg;
+ s->use_ssl = (unsigned char)arg;
break;
case CURLOPT_SSL_OPTIONS:
- set_ssl_options(&data->set.ssl, &data->set.ssl.primary, arg);
+ set_ssl_options(&s->ssl, &s->ssl.primary, arg);
break;
#ifndef CURL_DISABLE_PROXY
case CURLOPT_PROXY_SSL_OPTIONS:
- set_ssl_options(&data->set.proxy_ssl, &data->set.proxy_ssl.primary, arg);
+ set_ssl_options(&s->proxy_ssl, &s->proxy_ssl.primary, arg);
break;
#endif
case CURLOPT_IPRESOLVE:
if((arg < CURL_IPRESOLVE_WHATEVER) || (arg > CURL_IPRESOLVE_V6))
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.ipver = (unsigned char) arg;
- break;
- case CURLOPT_TCP_NODELAY:
- /*
- * Enable or disable TCP_NODELAY, which will disable/enable the Nagle
- * algorithm
- */
- data->set.tcp_nodelay = enabled;
- break;
-
- case CURLOPT_IGNORE_CONTENT_LENGTH:
- data->set.ignorecl = enabled;
+ s->ipver = (unsigned char) arg;
break;
case CURLOPT_CONNECT_ONLY:
*/
if(arg > 2)
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.connect_only = !!arg;
- data->set.connect_only_ws = (arg == 2);
+ s->connect_only = !!arg;
+ s->connect_only_ws = (arg == 2);
break;
- case CURLOPT_SSL_SESSIONID_CACHE:
- data->set.ssl.primary.cache_session = enabled;
-#ifndef CURL_DISABLE_PROXY
- data->set.proxy_ssl.primary.cache_session =
- data->set.ssl.primary.cache_session;
-#endif
- break;
#ifdef USE_SSH
/* we only include SSH options if explicitly built to support SSH */
case CURLOPT_SSH_AUTH_TYPES:
- data->set.ssh_auth_types = (int)arg;
- break;
- case CURLOPT_SSH_COMPRESSION:
- data->set.ssh_compression = enabled;
+ s->ssh_auth_types = (int)arg;
break;
#endif
- case CURLOPT_HTTP_TRANSFER_DECODING:
- /*
- * disable libcurl transfer encoding is used
- */
- data->set.http_te_skip = !enabled; /* reversed */
- break;
-
- case CURLOPT_HTTP_CONTENT_DECODING:
- /*
- * raw data passed to the application when content encoding is used
- */
- data->set.http_ce_skip = !enabled; /* reversed */
- break;
-
#if !defined(CURL_DISABLE_FTP) || defined(USE_SSH)
case CURLOPT_NEW_FILE_PERMS:
/*
*/
if((arg < 0) || (arg > 0777))
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.new_file_perms = (unsigned int)arg;
+ s->new_file_perms = (unsigned int)arg;
break;
#endif
#ifdef USE_SSH
*/
if((arg < 0) || (arg > 0777))
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.new_directory_perms = (unsigned int)arg;
+ s->new_directory_perms = (unsigned int)arg;
break;
#endif
#ifdef USE_IPV6
if(uarg > UINT_MAX)
return CURLE_BAD_FUNCTION_ARGUMENT;
#endif
- data->set.scope_id = (unsigned int)uarg;
+ s->scope_id = (unsigned int)uarg;
break;
#endif
case CURLOPT_PROTOCOLS:
transfer, which thus helps the app which takes URLs from users or other
external inputs and want to restrict what protocol(s) to deal with.
Defaults to CURLPROTO_ALL. */
- data->set.allowed_protocols = (curl_prot_t)arg;
+ s->allowed_protocols = (curl_prot_t)arg;
break;
case CURLOPT_REDIR_PROTOCOLS:
/* set the bitmask for the protocols that libcurl is allowed to follow to,
as a subset of the CURLOPT_PROTOCOLS ones. That means the protocol
needs to be set in both bitmasks to be allowed to get redirected to. */
- data->set.redir_protocols = (curl_prot_t)arg;
+ s->redir_protocols = (curl_prot_t)arg;
break;
-#ifndef CURL_DISABLE_SMTP
- case CURLOPT_MAIL_RCPT_ALLOWFAILS:
- /* allow RCPT TO command to fail for some recipients */
- data->set.mail_rcpt_allowfails = enabled;
- break;
-#endif /* !CURL_DISABLE_SMTP */
- case CURLOPT_SASL_IR:
- /* Enable/disable SASL initial response */
- data->set.sasl_ir = enabled;
- break;
#ifndef CURL_DISABLE_RTSP
case CURLOPT_RTSP_REQUEST:
return setopt_RTSP_REQUEST(data, arg);
#endif /* ! CURL_DISABLE_RTSP */
- case CURLOPT_TCP_KEEPALIVE:
- data->set.tcp_keepalive = enabled;
- break;
case CURLOPT_TCP_KEEPIDLE:
if(arg < 0)
return CURLE_BAD_FUNCTION_ARGUMENT;
else if(arg > INT_MAX)
arg = INT_MAX;
- data->set.tcp_keepidle = (int)arg;
+ s->tcp_keepidle = (int)arg;
break;
case CURLOPT_TCP_KEEPINTVL:
if(arg < 0)
return CURLE_BAD_FUNCTION_ARGUMENT;
else if(arg > INT_MAX)
arg = INT_MAX;
- data->set.tcp_keepintvl = (int)arg;
+ s->tcp_keepintvl = (int)arg;
break;
case CURLOPT_TCP_KEEPCNT:
if(arg < 0)
return CURLE_BAD_FUNCTION_ARGUMENT;
else if(arg > INT_MAX)
arg = INT_MAX;
- data->set.tcp_keepcnt = (int)arg;
- break;
- case CURLOPT_TCP_FASTOPEN:
-#if defined(CONNECT_DATA_IDEMPOTENT) || defined(MSG_FASTOPEN) || \
- defined(TCP_FASTOPEN_CONNECT)
- data->set.tcp_fastopen = enabled;
-#else
- return CURLE_NOT_BUILT_IN;
-#endif
+ s->tcp_keepcnt = (int)arg;
break;
case CURLOPT_SSL_ENABLE_NPN:
break;
- case CURLOPT_SSL_ENABLE_ALPN:
- data->set.ssl_enable_alpn = enabled;
- break;
- case CURLOPT_PATH_AS_IS:
- data->set.path_as_is = enabled;
- break;
- case CURLOPT_PIPEWAIT:
- data->set.pipewait = enabled;
- break;
case CURLOPT_STREAM_WEIGHT:
#if defined(USE_HTTP2) || defined(USE_HTTP3)
if((arg >= 1) && (arg <= 256))
- data->set.priority.weight = (int)arg;
+ s->priority.weight = (int)arg;
break;
#else
return CURLE_NOT_BUILT_IN;
#endif
- case CURLOPT_SUPPRESS_CONNECT_HEADERS:
- data->set.suppress_connect_headers = enabled;
- break;
case CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS:
- return setopt_set_timeout_ms(&data->set.happy_eyeballs_timeout, arg);
-
-#ifndef CURL_DISABLE_SHUFFLE_DNS
- case CURLOPT_DNS_SHUFFLE_ADDRESSES:
- data->set.dns_shuffle_addresses = enabled;
- break;
-#endif
- case CURLOPT_DISALLOW_USERNAME_IN_URL:
- data->set.disallow_username_in_url = enabled;
- break;
+ return setopt_set_timeout_ms(&s->happy_eyeballs_timeout, arg);
case CURLOPT_UPKEEP_INTERVAL_MS:
if(arg < 0)
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.upkeep_interval_ms = arg;
+ s->upkeep_interval_ms = arg;
break;
case CURLOPT_MAXAGE_CONN:
- return setopt_set_timeout_sec(&data->set.conn_max_idle_ms, arg);
+ return setopt_set_timeout_sec(&s->conn_max_idle_ms, arg);
case CURLOPT_MAXLIFETIME_CONN:
- return setopt_set_timeout_sec(&data->set.conn_max_age_ms, arg);
+ return setopt_set_timeout_sec(&s->conn_max_age_ms, arg);
#ifndef CURL_DISABLE_HSTS
case CURLOPT_HSTS_CTRL:
#endif /* ! CURL_DISABLE_ALTSVC */
#ifndef CURL_DISABLE_WEBSOCKETS
case CURLOPT_WS_OPTIONS:
- data->set.ws_raw_mode = (bool)(arg & CURLWS_RAW_MODE);
- data->set.ws_no_auto_pong = (bool)(arg & CURLWS_NOAUTOPONG);
+ s->ws_raw_mode = (bool)(arg & CURLWS_RAW_MODE);
+ s->ws_no_auto_pong = (bool)(arg & CURLWS_NOAUTOPONG);
break;
#endif
- case CURLOPT_QUICK_EXIT:
- data->set.quick_exit = enabled;
- break;
case CURLOPT_DNS_USE_GLOBAL_CACHE:
/* deprecated */
break;
/*
* flag to set engine as default.
*/
- Curl_safefree(data->set.str[STRING_SSL_ENGINE]);
+ Curl_safefree(s->str[STRING_SSL_ENGINE]);
return Curl_ssl_set_engine_default(data);
case CURLOPT_UPLOAD_FLAGS:
- data->set.upload_flags = (unsigned char)arg;
+ s->upload_flags = (unsigned char)arg;
break;
default:
/* unknown option */
struct curl_slist *slist)
{
CURLcode result = CURLE_OK;
+ struct UserDefined *s = &data->set;
switch(option) {
#ifndef CURL_DISABLE_PROXY
case CURLOPT_PROXYHEADER:
*
* Set this option to NULL to restore the previous behavior.
*/
- data->set.proxyheaders = slist;
+ s->proxyheaders = slist;
break;
#endif
#ifndef CURL_DISABLE_HTTP
/*
* Set a list of aliases for HTTP 200 in response header
*/
- data->set.http200aliases = slist;
+ s->http200aliases = slist;
break;
#endif
#if !defined(CURL_DISABLE_FTP) || defined(USE_SSH)
/*
* List of RAW FTP commands to use after a transfer
*/
- data->set.postquote = slist;
+ s->postquote = slist;
break;
case CURLOPT_PREQUOTE:
/*
* List of RAW FTP commands to use prior to RETR (Wesley Laxton)
*/
- data->set.prequote = slist;
+ s->prequote = slist;
break;
case CURLOPT_QUOTE:
/*
* List of RAW FTP commands to use before a transfer
*/
- data->set.quote = slist;
+ s->quote = slist;
break;
#endif
case CURLOPT_RESOLVE:
* This API can remove any entry from the DNS cache, but only entries
* that are not actually in use right now will be pruned immediately.
*/
- data->set.resolve = slist;
- data->state.resolve = data->set.resolve;
+ s->resolve = slist;
+ data->state.resolve = s->resolve;
break;
#if !defined(CURL_DISABLE_HTTP) || !defined(CURL_DISABLE_MIME)
case CURLOPT_HTTPHEADER:
/*
* Set a list with HTTP headers to use (or replace internals with)
*/
- data->set.headers = slist;
+ s->headers = slist;
break;
#endif
#ifndef CURL_DISABLE_TELNET
/*
* Set a linked list of telnet options
*/
- data->set.telnet_options = slist;
+ s->telnet_options = slist;
break;
#endif
#ifndef CURL_DISABLE_SMTP
case CURLOPT_MAIL_RCPT:
/* Set the list of mail recipients */
- data->set.mail_rcpt = slist;
+ s->mail_rcpt = slist;
break;
#endif
case CURLOPT_CONNECT_TO:
- data->set.connect_to = slist;
+ s->connect_to = slist;
break;
default:
return CURLE_UNKNOWN_OPTION;
va_list param)
{
CURLcode result = CURLE_OK;
+ struct UserDefined *s = &data->set;
switch(option) {
#ifndef CURL_DISABLE_HTTP
#ifndef CURL_DISABLE_FORM_API
/*
* Set to make us do HTTP POST. Legacy API-style.
*/
- data->set.httppost = va_arg(param, struct curl_httppost *);
- data->set.method = HTTPREQ_POST_FORM;
- data->set.opt_no_body = FALSE; /* this is implied */
+ s->httppost = va_arg(param, struct curl_httppost *);
+ s->method = HTTPREQ_POST_FORM;
+ s->opt_no_body = FALSE; /* this is implied */
Curl_mime_cleanpart(data->state.formp);
Curl_safefree(data->state.formp);
data->state.mimepost = NULL;
/*
* Set to make us do MIME POST
*/
- result = Curl_mime_set_subparts(&data->set.mimepost,
+ result = Curl_mime_set_subparts(&s->mimepost,
va_arg(param, curl_mime *),
FALSE);
if(!result) {
- data->set.method = HTTPREQ_POST_MIME;
- data->set.opt_no_body = FALSE; /* this is implied */
+ s->method = HTTPREQ_POST_MIME;
+ s->opt_no_body = FALSE; /* this is implied */
#ifndef CURL_DISABLE_FORM_API
Curl_mime_cleanpart(data->state.formp);
Curl_safefree(data->state.formp);
* Set to a FILE * that should receive all error writes. This
* defaults to stderr for normal operations.
*/
- data->set.err = va_arg(param, FILE *);
- if(!data->set.err)
- data->set.err = stderr;
+ s->err = va_arg(param, FILE *);
+ if(!s->err)
+ s->err = stderr;
break;
case CURLOPT_SHARE:
{
char *ptr)
{
CURLcode result = CURLE_OK;
+ struct UserDefined *s = &data->set;
switch(option) {
case CURLOPT_SSL_CIPHER_LIST:
if(Curl_ssl_supports(data, SSLSUPP_CIPHER_LIST))
/* set a list of cipher we want to use in the SSL connection */
- return Curl_setstropt(&data->set.str[STRING_SSL_CIPHER_LIST], ptr);
+ return Curl_setstropt(&s->str[STRING_SSL_CIPHER_LIST], ptr);
else
return CURLE_NOT_BUILT_IN;
#ifndef CURL_DISABLE_PROXY
case CURLOPT_PROXY_SSL_CIPHER_LIST:
if(Curl_ssl_supports(data, SSLSUPP_CIPHER_LIST)) {
/* set a list of cipher we want to use in the SSL connection for proxy */
- return Curl_setstropt(&data->set.str[STRING_SSL_CIPHER_LIST_PROXY],
+ return Curl_setstropt(&s->str[STRING_SSL_CIPHER_LIST_PROXY],
ptr);
}
else
case CURLOPT_TLS13_CIPHERS:
if(Curl_ssl_supports(data, SSLSUPP_TLS13_CIPHERSUITES)) {
/* set preferred list of TLS 1.3 cipher suites */
- return Curl_setstropt(&data->set.str[STRING_SSL_CIPHER13_LIST], ptr);
+ return Curl_setstropt(&s->str[STRING_SSL_CIPHER13_LIST], ptr);
}
else
return CURLE_NOT_BUILT_IN;
case CURLOPT_PROXY_TLS13_CIPHERS:
if(Curl_ssl_supports(data, SSLSUPP_TLS13_CIPHERSUITES))
/* set preferred list of TLS 1.3 cipher suites for proxy */
- return Curl_setstropt(&data->set.str[STRING_SSL_CIPHER13_LIST_PROXY],
+ return Curl_setstropt(&s->str[STRING_SSL_CIPHER13_LIST_PROXY],
ptr);
else
return CURLE_NOT_BUILT_IN;
case CURLOPT_EGDSOCKET:
break;
case CURLOPT_REQUEST_TARGET:
- return Curl_setstropt(&data->set.str[STRING_TARGET], ptr);
+ return Curl_setstropt(&s->str[STRING_TARGET], ptr);
#ifndef CURL_DISABLE_NETRC
case CURLOPT_NETRC_FILE:
/*
* Use this file instead of the $HOME/.netrc file
*/
- return Curl_setstropt(&data->set.str[STRING_NETRC_FILE], ptr);
+ return Curl_setstropt(&s->str[STRING_NETRC_FILE], ptr);
#endif
#if !defined(CURL_DISABLE_HTTP) || !defined(CURL_DISABLE_MQTT)
* If needed, CURLOPT_POSTFIELDSIZE must have been set prior to
* CURLOPT_COPYPOSTFIELDS and not altered later.
*/
- if(!ptr || data->set.postfieldsize == -1)
- result = Curl_setstropt(&data->set.str[STRING_COPYPOSTFIELDS], ptr);
+ if(!ptr || s->postfieldsize == -1)
+ result = Curl_setstropt(&s->str[STRING_COPYPOSTFIELDS], ptr);
else {
- if(data->set.postfieldsize < 0)
+ if(s->postfieldsize < 0)
return CURLE_BAD_FUNCTION_ARGUMENT;
#if SIZEOF_CURL_OFF_T > SIZEOF_SIZE_T
/*
* Check that requested length does not overflow the size_t type.
*/
- else if(data->set.postfieldsize > SIZE_T_MAX)
+ else if(s->postfieldsize > SIZE_T_MAX)
return CURLE_OUT_OF_MEMORY;
#endif
else {
mark that postfields is used rather than read function or form
data.
*/
- char *p = Curl_memdup0(ptr, (size_t)data->set.postfieldsize);
+ char *p = Curl_memdup0(ptr, (size_t)s->postfieldsize);
if(!p)
return CURLE_OUT_OF_MEMORY;
else {
- free(data->set.str[STRING_COPYPOSTFIELDS]);
- data->set.str[STRING_COPYPOSTFIELDS] = p;
+ free(s->str[STRING_COPYPOSTFIELDS]);
+ s->str[STRING_COPYPOSTFIELDS] = p;
}
}
}
- data->set.postfields = data->set.str[STRING_COPYPOSTFIELDS];
- data->set.method = HTTPREQ_POST;
+ s->postfields = s->str[STRING_COPYPOSTFIELDS];
+ s->method = HTTPREQ_POST;
break;
case CURLOPT_POSTFIELDS:
/*
* Like above, but use static data instead of copying it.
*/
- data->set.postfields = ptr;
+ s->postfields = ptr;
/* Release old copied data. */
- Curl_safefree(data->set.str[STRING_COPYPOSTFIELDS]);
- data->set.method = HTTPREQ_POST;
+ Curl_safefree(s->str[STRING_COPYPOSTFIELDS]);
+ s->method = HTTPREQ_POST;
break;
#endif /* ! CURL_DISABLE_HTTP || ! CURL_DISABLE_MQTT */
if(ptr && !*ptr) {
char all[256];
Curl_all_content_encodings(all, sizeof(all));
- return Curl_setstropt(&data->set.str[STRING_ENCODING], all);
+ return Curl_setstropt(&s->str[STRING_ENCODING], all);
}
- return Curl_setstropt(&data->set.str[STRING_ENCODING], ptr);
+ return Curl_setstropt(&s->str[STRING_ENCODING], ptr);
#ifndef CURL_DISABLE_AWS
case CURLOPT_AWS_SIGV4:
* String that is merged to some authentication
* parameters are used by the algorithm.
*/
- result = Curl_setstropt(&data->set.str[STRING_AWS_SIGV4], ptr);
+ result = Curl_setstropt(&s->str[STRING_AWS_SIGV4], ptr);
/*
* Basic been set by default it need to be unset here
*/
- if(data->set.str[STRING_AWS_SIGV4])
- data->set.httpauth = CURLAUTH_AWS_SIGV4;
+ if(s->str[STRING_AWS_SIGV4])
+ s->httpauth = CURLAUTH_AWS_SIGV4;
break;
#endif
case CURLOPT_REFERER:
Curl_safefree(data->state.referer);
data->state.referer_alloc = FALSE;
}
- result = Curl_setstropt(&data->set.str[STRING_SET_REFERER], ptr);
- data->state.referer = data->set.str[STRING_SET_REFERER];
+ result = Curl_setstropt(&s->str[STRING_SET_REFERER], ptr);
+ data->state.referer = s->str[STRING_SET_REFERER];
break;
case CURLOPT_USERAGENT:
/*
* String to use in the HTTP User-Agent field
*/
- return Curl_setstropt(&data->set.str[STRING_USERAGENT], ptr);
+ return Curl_setstropt(&s->str[STRING_USERAGENT], ptr);
#ifndef CURL_DISABLE_COOKIES
case CURLOPT_COOKIE:
/*
* Cookie string to send to the remote server in the request.
*/
- return Curl_setstropt(&data->set.str[STRING_COOKIE], ptr);
+ return Curl_setstropt(&s->str[STRING_COOKIE], ptr);
case CURLOPT_COOKIEFILE:
/*
/*
* Set cookie filename to dump all cookies to when we are done.
*/
- result = Curl_setstropt(&data->set.str[STRING_COOKIEJAR], ptr);
+ result = Curl_setstropt(&s->str[STRING_COOKIEJAR], ptr);
if(!result) {
/*
* Activate the cookie parser. This may or may not already
* have been made.
*/
struct CookieInfo *newcookies =
- Curl_cookie_init(data, NULL, data->cookies, data->set.cookiesession);
+ Curl_cookie_init(data, NULL, data->cookies, s->cookiesession);
if(!newcookies)
result = CURLE_OUT_OF_MEMORY;
data->cookies = newcookies;
/*
* Set a custom string to use as request
*/
- return Curl_setstropt(&data->set.str[STRING_CUSTOMREQUEST], ptr);
+ return Curl_setstropt(&s->str[STRING_CUSTOMREQUEST], ptr);
/* we do not set
- data->set.method = HTTPREQ_CUSTOM;
+ s->method = HTTPREQ_CUSTOM;
here, we continue as if we were using the already set type
and this just changes the actual request keyword */
* Setting it to NULL, means no proxy but allows the environment variables
* to decide for us (if CURLOPT_SOCKS_PROXY setting it to NULL).
*/
- return Curl_setstropt(&data->set.str[STRING_PROXY], ptr);
+ return Curl_setstropt(&s->str[STRING_PROXY], ptr);
case CURLOPT_PRE_PROXY:
/*
* If the proxy is set to "" or NULL we explicitly say that we do not want
* to use the socks proxy.
*/
- return Curl_setstropt(&data->set.str[STRING_PRE_PROXY], ptr);
+ return Curl_setstropt(&s->str[STRING_PRE_PROXY], ptr);
#endif /* CURL_DISABLE_PROXY */
#ifndef CURL_DISABLE_PROXY
/*
* Set proxy authentication service name for Kerberos 5 and SPNEGO
*/
- return Curl_setstropt(&data->set.str[STRING_PROXY_SERVICE_NAME], ptr);
+ return Curl_setstropt(&s->str[STRING_PROXY_SERVICE_NAME], ptr);
#endif
case CURLOPT_SERVICE_NAME:
/*
* Set authentication service name for DIGEST-MD5, Kerberos 5 and SPNEGO
*/
- return Curl_setstropt(&data->set.str[STRING_SERVICE_NAME], ptr);
+ return Curl_setstropt(&s->str[STRING_SERVICE_NAME], ptr);
case CURLOPT_HEADERDATA:
/*
* Custom pointer to pass the header write callback function
*/
- data->set.writeheader = ptr;
+ s->writeheader = ptr;
break;
case CURLOPT_READDATA:
/*
* FILE pointer to read the file to be uploaded from. Or possibly used as
* argument to the read callback.
*/
- data->set.in_set = ptr;
+ s->in_set = ptr;
break;
case CURLOPT_WRITEDATA:
/*
* FILE pointer to write to. Or possibly used as argument to the write
* callback.
*/
- data->set.out = ptr;
+ s->out = ptr;
break;
case CURLOPT_DEBUGDATA:
/*
* Set to a void * that should receive all error writes. This
* defaults to CURLOPT_STDERR for normal operations.
*/
- data->set.debugdata = ptr;
+ s->debugdata = ptr;
break;
case CURLOPT_PROGRESSDATA:
/*
* Custom client data to pass to the progress callback
*/
- data->set.progress_client = ptr;
+ s->progress_client = ptr;
break;
case CURLOPT_SEEKDATA:
/*
* Seek control callback. Might be NULL.
*/
- data->set.seek_client = ptr;
+ s->seek_client = ptr;
break;
case CURLOPT_IOCTLDATA:
/*
* I/O control data pointer. Might be NULL.
*/
- data->set.ioctl_client = ptr;
+ s->ioctl_client = ptr;
break;
case CURLOPT_SSL_CTX_DATA:
/*
*/
#ifdef USE_SSL
if(Curl_ssl_supports(data, SSLSUPP_SSL_CTX)) {
- data->set.ssl.fsslctxp = ptr;
+ s->ssl.fsslctxp = ptr;
break;
}
else
/*
* socket callback data pointer. Might be NULL.
*/
- data->set.sockopt_client = ptr;
+ s->sockopt_client = ptr;
break;
case CURLOPT_OPENSOCKETDATA:
/*
* socket callback data pointer. Might be NULL.
*/
- data->set.opensocket_client = ptr;
+ s->opensocket_client = ptr;
break;
case CURLOPT_RESOLVER_START_DATA:
/*
* resolver start callback data pointer. Might be NULL.
*/
- data->set.resolver_start_client = ptr;
+ s->resolver_start_client = ptr;
break;
case CURLOPT_CLOSESOCKETDATA:
/*
* socket callback data pointer. Might be NULL.
*/
- data->set.closesocket_client = ptr;
+ s->closesocket_client = ptr;
break;
case CURLOPT_TRAILERDATA:
#ifndef CURL_DISABLE_HTTP
- data->set.trailer_data = ptr;
+ s->trailer_data = ptr;
#endif
break;
case CURLOPT_PREREQDATA:
- data->set.prereq_userp = ptr;
+ s->prereq_userp = ptr;
break;
case CURLOPT_ERRORBUFFER:
* Error buffer provided by the caller to get the human readable error
* string in.
*/
- data->set.errorbuffer = ptr;
+ s->errorbuffer = ptr;
break;
#ifndef CURL_DISABLE_FTP
/*
* Use FTP PORT, this also specifies which IP address to use
*/
- result = Curl_setstropt(&data->set.str[STRING_FTPPORT], ptr);
- data->set.ftp_use_port = !!(data->set.str[STRING_FTPPORT]);
+ result = Curl_setstropt(&s->str[STRING_FTPPORT], ptr);
+ s->ftp_use_port = !!(s->str[STRING_FTPPORT]);
break;
case CURLOPT_FTP_ACCOUNT:
- return Curl_setstropt(&data->set.str[STRING_FTP_ACCOUNT], ptr);
+ return Curl_setstropt(&s->str[STRING_FTP_ACCOUNT], ptr);
case CURLOPT_FTP_ALTERNATIVE_TO_USER:
- return Curl_setstropt(&data->set.str[STRING_FTP_ALTERNATIVE_TO_USER], ptr);
+ return Curl_setstropt(&s->str[STRING_FTP_ALTERNATIVE_TO_USER], ptr);
#ifdef HAVE_GSSAPI
case CURLOPT_KRBLEVEL:
/*
* A string that defines the kerberos security level.
*/
- result = Curl_setstropt(&data->set.str[STRING_KRB_LEVEL], ptr);
- data->set.krb = !!(data->set.str[STRING_KRB_LEVEL]);
+ result = Curl_setstropt(&s->str[STRING_KRB_LEVEL], ptr);
+ s->krb = !!(s->str[STRING_KRB_LEVEL]);
break;
#endif
#endif
Curl_safefree(data->state.url);
data->state.url_alloc = FALSE;
}
- result = Curl_setstropt(&data->set.str[STRING_SET_URL], ptr);
- data->state.url = data->set.str[STRING_SET_URL];
+ result = Curl_setstropt(&s->str[STRING_SET_URL], ptr);
+ data->state.url = s->str[STRING_SET_URL];
break;
case CURLOPT_USERPWD:
/*
* user:password to use in the operation
*/
- return setstropt_userpwd(ptr, &data->set.str[STRING_USERNAME],
- &data->set.str[STRING_PASSWORD]);
+ return setstropt_userpwd(ptr, &s->str[STRING_USERNAME],
+ &s->str[STRING_PASSWORD]);
case CURLOPT_USERNAME:
/*
* authentication username to use in the operation
*/
- return Curl_setstropt(&data->set.str[STRING_USERNAME], ptr);
+ return Curl_setstropt(&s->str[STRING_USERNAME], ptr);
case CURLOPT_PASSWORD:
/*
* authentication password to use in the operation
*/
- return Curl_setstropt(&data->set.str[STRING_PASSWORD], ptr);
+ return Curl_setstropt(&s->str[STRING_PASSWORD], ptr);
case CURLOPT_LOGIN_OPTIONS:
/*
* authentication options to use in the operation
*/
- return Curl_setstropt(&data->set.str[STRING_OPTIONS], ptr);
+ return Curl_setstropt(&s->str[STRING_OPTIONS], ptr);
case CURLOPT_XOAUTH2_BEARER:
/*
* OAuth 2.0 bearer token to use in the operation
*/
- return Curl_setstropt(&data->set.str[STRING_BEARER], ptr);
+ return Curl_setstropt(&s->str[STRING_BEARER], ptr);
#ifndef CURL_DISABLE_PROXY
case CURLOPT_PROXYUSERPWD: {
/* URL decode the components */
if(!result && u) {
- Curl_safefree(data->set.str[STRING_PROXYUSERNAME]);
- result = Curl_urldecode(u, 0, &data->set.str[STRING_PROXYUSERNAME], NULL,
+ Curl_safefree(s->str[STRING_PROXYUSERNAME]);
+ result = Curl_urldecode(u, 0, &s->str[STRING_PROXYUSERNAME], NULL,
REJECT_ZERO);
}
if(!result && p) {
- Curl_safefree(data->set.str[STRING_PROXYPASSWORD]);
- result = Curl_urldecode(p, 0, &data->set.str[STRING_PROXYPASSWORD], NULL,
+ Curl_safefree(s->str[STRING_PROXYPASSWORD]);
+ result = Curl_urldecode(p, 0, &s->str[STRING_PROXYPASSWORD], NULL,
REJECT_ZERO);
}
free(u);
/*
* authentication username to use in the operation
*/
- return Curl_setstropt(&data->set.str[STRING_PROXYUSERNAME], ptr);
+ return Curl_setstropt(&s->str[STRING_PROXYUSERNAME], ptr);
case CURLOPT_PROXYPASSWORD:
/*
* authentication password to use in the operation
*/
- return Curl_setstropt(&data->set.str[STRING_PROXYPASSWORD], ptr);
+ return Curl_setstropt(&s->str[STRING_PROXYPASSWORD], ptr);
case CURLOPT_NOPROXY:
/*
* proxy exception list
*/
- return Curl_setstropt(&data->set.str[STRING_NOPROXY], ptr);
+ return Curl_setstropt(&s->str[STRING_NOPROXY], ptr);
#endif /* ! CURL_DISABLE_PROXY */
case CURLOPT_RANGE:
/*
* What range of the file you want to transfer
*/
- return Curl_setstropt(&data->set.str[STRING_SET_RANGE], ptr);
+ return Curl_setstropt(&s->str[STRING_SET_RANGE], ptr);
case CURLOPT_CURLU:
/*
}
else
data->state.url = NULL;
- Curl_safefree(data->set.str[STRING_SET_URL]);
- data->set.uh = (CURLU *)ptr;
+ Curl_safefree(s->str[STRING_SET_URL]);
+ s->uh = (CURLU *)ptr;
break;
case CURLOPT_SSLCERT:
/*
* String that holds filename of the SSL certificate to use
*/
- return Curl_setstropt(&data->set.str[STRING_CERT], ptr);
+ return Curl_setstropt(&s->str[STRING_CERT], ptr);
#ifndef CURL_DISABLE_PROXY
case CURLOPT_PROXY_SSLCERT:
/*
* String that holds filename of the SSL certificate to use for proxy
*/
- return Curl_setstropt(&data->set.str[STRING_CERT_PROXY], ptr);
+ return Curl_setstropt(&s->str[STRING_CERT_PROXY], ptr);
#endif
case CURLOPT_SSLCERTTYPE:
/*
* String that holds file type of the SSL certificate to use
*/
- return Curl_setstropt(&data->set.str[STRING_CERT_TYPE], ptr);
+ return Curl_setstropt(&s->str[STRING_CERT_TYPE], ptr);
#ifndef CURL_DISABLE_PROXY
case CURLOPT_PROXY_SSLCERTTYPE:
/*
* String that holds file type of the SSL certificate to use for proxy
*/
- return Curl_setstropt(&data->set.str[STRING_CERT_TYPE_PROXY], ptr);
+ return Curl_setstropt(&s->str[STRING_CERT_TYPE_PROXY], ptr);
#endif
case CURLOPT_SSLKEY:
/*
* String that holds filename of the SSL key to use
*/
- return Curl_setstropt(&data->set.str[STRING_KEY], ptr);
+ return Curl_setstropt(&s->str[STRING_KEY], ptr);
#ifndef CURL_DISABLE_PROXY
case CURLOPT_PROXY_SSLKEY:
/*
* String that holds filename of the SSL key to use for proxy
*/
- return Curl_setstropt(&data->set.str[STRING_KEY_PROXY], ptr);
+ return Curl_setstropt(&s->str[STRING_KEY_PROXY], ptr);
#endif
case CURLOPT_SSLKEYTYPE:
/*
* String that holds file type of the SSL key to use
*/
- return Curl_setstropt(&data->set.str[STRING_KEY_TYPE], ptr);
+ return Curl_setstropt(&s->str[STRING_KEY_TYPE], ptr);
#ifndef CURL_DISABLE_PROXY
case CURLOPT_PROXY_SSLKEYTYPE:
/*
* String that holds file type of the SSL key to use for proxy
*/
- return Curl_setstropt(&data->set.str[STRING_KEY_TYPE_PROXY], ptr);
+ return Curl_setstropt(&s->str[STRING_KEY_TYPE_PROXY], ptr);
#endif
case CURLOPT_KEYPASSWD:
/*
* String that holds the SSL or SSH private key password.
*/
- return Curl_setstropt(&data->set.str[STRING_KEY_PASSWD], ptr);
+ return Curl_setstropt(&s->str[STRING_KEY_PASSWD], ptr);
#ifndef CURL_DISABLE_PROXY
case CURLOPT_PROXY_KEYPASSWD:
/*
* String that holds the SSL private key password for proxy.
*/
- return Curl_setstropt(&data->set.str[STRING_KEY_PASSWD_PROXY], ptr);
+ return Curl_setstropt(&s->str[STRING_KEY_PASSWD_PROXY], ptr);
#endif
case CURLOPT_SSLENGINE:
* String that holds the SSL crypto engine.
*/
if(ptr && ptr[0]) {
- result = Curl_setstropt(&data->set.str[STRING_SSL_ENGINE], ptr);
+ result = Curl_setstropt(&s->str[STRING_SSL_ENGINE], ptr);
if(!result) {
result = Curl_ssl_set_engine(data, ptr);
}
/*
* Set the client IP to send through HAProxy PROXY protocol
*/
- result = Curl_setstropt(&data->set.str[STRING_HAPROXY_CLIENT_IP], ptr);
+ result = Curl_setstropt(&s->str[STRING_HAPROXY_CLIENT_IP], ptr);
/* enable the HAProxy protocol */
- data->set.haproxyprotocol = TRUE;
+ s->haproxyprotocol = TRUE;
break;
#endif
* performing an operation and thus what from-IP your connection will use.
*/
return setstropt_interface(ptr,
- &data->set.str[STRING_DEVICE],
- &data->set.str[STRING_INTERFACE],
- &data->set.str[STRING_BINDHOST]);
+ &s->str[STRING_DEVICE],
+ &s->str[STRING_INTERFACE],
+ &s->str[STRING_BINDHOST]);
case CURLOPT_PINNEDPUBLICKEY:
/*
*/
#ifdef USE_SSL
if(Curl_ssl_supports(data, SSLSUPP_PINNEDPUBKEY))
- return Curl_setstropt(&data->set.str[STRING_SSL_PINNEDPUBLICKEY], ptr);
+ return Curl_setstropt(&s->str[STRING_SSL_PINNEDPUBLICKEY], ptr);
#endif
return CURLE_NOT_BUILT_IN;
*/
#ifdef USE_SSL
if(Curl_ssl_supports(data, SSLSUPP_PINNEDPUBKEY))
- return Curl_setstropt(&data->set.str[STRING_SSL_PINNEDPUBLICKEY_PROXY],
+ return Curl_setstropt(&s->str[STRING_SSL_PINNEDPUBLICKEY_PROXY],
ptr);
#endif
return CURLE_NOT_BUILT_IN;
/*
* Set CA info for SSL connection. Specify filename of the CA certificate
*/
- return Curl_setstropt(&data->set.str[STRING_SSL_CAFILE], ptr);
+ return Curl_setstropt(&s->str[STRING_SSL_CAFILE], ptr);
#ifndef CURL_DISABLE_PROXY
case CURLOPT_PROXY_CAINFO:
* Set CA info SSL connection for proxy. Specify filename of the
* CA certificate
*/
- return Curl_setstropt(&data->set.str[STRING_SSL_CAFILE_PROXY], ptr);
+ return Curl_setstropt(&s->str[STRING_SSL_CAFILE_PROXY], ptr);
#endif
case CURLOPT_CAPATH:
#ifdef USE_SSL
if(Curl_ssl_supports(data, SSLSUPP_CA_PATH))
/* This does not work on Windows. */
- return Curl_setstropt(&data->set.str[STRING_SSL_CAPATH], ptr);
+ return Curl_setstropt(&s->str[STRING_SSL_CAPATH], ptr);
#endif
return CURLE_NOT_BUILT_IN;
#ifndef CURL_DISABLE_PROXY
#ifdef USE_SSL
if(Curl_ssl_supports(data, SSLSUPP_CA_PATH))
/* This does not work on Windows. */
- return Curl_setstropt(&data->set.str[STRING_SSL_CAPATH_PROXY], ptr);
+ return Curl_setstropt(&s->str[STRING_SSL_CAPATH_PROXY], ptr);
#endif
return CURLE_NOT_BUILT_IN;
#endif
* Set CRL file info for SSL connection. Specify filename of the CRL
* to check certificates revocation
*/
- return Curl_setstropt(&data->set.str[STRING_SSL_CRLFILE], ptr);
+ return Curl_setstropt(&s->str[STRING_SSL_CRLFILE], ptr);
#ifndef CURL_DISABLE_PROXY
case CURLOPT_PROXY_CRLFILE:
* Set CRL file info for SSL connection for proxy. Specify filename of the
* CRL to check certificates revocation
*/
- return Curl_setstropt(&data->set.str[STRING_SSL_CRLFILE_PROXY], ptr);
+ return Curl_setstropt(&s->str[STRING_SSL_CRLFILE_PROXY], ptr);
#endif
case CURLOPT_ISSUERCERT:
* Set Issuer certificate file
* to check certificates issuer
*/
- return Curl_setstropt(&data->set.str[STRING_SSL_ISSUERCERT], ptr);
+ return Curl_setstropt(&s->str[STRING_SSL_ISSUERCERT], ptr);
#ifndef CURL_DISABLE_PROXY
case CURLOPT_PROXY_ISSUERCERT:
* Set Issuer certificate file
* to check certificates issuer
*/
- return Curl_setstropt(&data->set.str[STRING_SSL_ISSUERCERT_PROXY], ptr);
+ return Curl_setstropt(&s->str[STRING_SSL_ISSUERCERT_PROXY], ptr);
#endif
case CURLOPT_PRIVATE:
/*
* Set private data pointer.
*/
- data->set.private_data = ptr;
+ s->private_data = ptr;
break;
#ifdef USE_SSL
* Set accepted curves in SSL connection setup.
* Specify colon-delimited list of curve algorithm names.
*/
- return Curl_setstropt(&data->set.str[STRING_SSL_EC_CURVES], ptr);
+ return Curl_setstropt(&s->str[STRING_SSL_EC_CURVES], ptr);
case CURLOPT_SSL_SIGNATURE_ALGORITHMS:
/*
* Specify colon-delimited list of signature scheme names.
*/
if(Curl_ssl_supports(data, SSLSUPP_SIGNATURE_ALGORITHMS))
- return Curl_setstropt(&data->set.str[STRING_SSL_SIGNATURE_ALGORITHMS],
+ return Curl_setstropt(&s->str[STRING_SSL_SIGNATURE_ALGORITHMS],
ptr);
return CURLE_NOT_BUILT_IN;
#endif
/*
* Use this file instead of the $HOME/.ssh/id_dsa.pub file
*/
- return Curl_setstropt(&data->set.str[STRING_SSH_PUBLIC_KEY], ptr);
+ return Curl_setstropt(&s->str[STRING_SSH_PUBLIC_KEY], ptr);
case CURLOPT_SSH_PRIVATE_KEYFILE:
/*
* Use this file instead of the $HOME/.ssh/id_dsa file
*/
- return Curl_setstropt(&data->set.str[STRING_SSH_PRIVATE_KEY], ptr);
+ return Curl_setstropt(&s->str[STRING_SSH_PRIVATE_KEY], ptr);
#if defined(USE_LIBSSH2) || defined(USE_LIBSSH)
case CURLOPT_SSH_HOST_PUBLIC_KEY_MD5:
* Option to allow for the MD5 of the host public key to be checked
* for validation purposes.
*/
- return Curl_setstropt(&data->set.str[STRING_SSH_HOST_PUBLIC_KEY_MD5], ptr);
+ return Curl_setstropt(&s->str[STRING_SSH_HOST_PUBLIC_KEY_MD5], ptr);
case CURLOPT_SSH_KNOWNHOSTS:
/*
* Store the filename to read known hosts from.
*/
- return Curl_setstropt(&data->set.str[STRING_SSH_KNOWNHOSTS], ptr);
+ return Curl_setstropt(&s->str[STRING_SSH_KNOWNHOSTS], ptr);
#endif
case CURLOPT_SSH_KEYDATA:
/*
* Custom client data to pass to the SSH keyfunc callback
*/
- data->set.ssh_keyfunc_userp = ptr;
+ s->ssh_keyfunc_userp = ptr;
break;
#ifdef USE_LIBSSH2
case CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256:
* Option to allow for the SHA256 of the host public key to be checked
* for validation purposes.
*/
- return Curl_setstropt(&data->set.str[STRING_SSH_HOST_PUBLIC_KEY_SHA256],
+ return Curl_setstropt(&s->str[STRING_SSH_HOST_PUBLIC_KEY_SHA256],
ptr);
case CURLOPT_SSH_HOSTKEYDATA:
/*
* Custom client data to pass to the SSH keyfunc callback
*/
- data->set.ssh_hostkeyfunc_userp = ptr;
+ s->ssh_hostkeyfunc_userp = ptr;
break;
#endif /* USE_LIBSSH2 */
#endif /* USE_SSH */
case CURLOPT_PROTOCOLS_STR:
if(ptr)
- return protocol2num(ptr, &data->set.allowed_protocols);
+ return protocol2num(ptr, &s->allowed_protocols);
/* make a NULL argument reset to default */
- data->set.allowed_protocols = (curl_prot_t) CURLPROTO_ALL;
+ s->allowed_protocols = (curl_prot_t) CURLPROTO_ALL;
break;
case CURLOPT_REDIR_PROTOCOLS_STR:
if(ptr)
- return protocol2num(ptr, &data->set.redir_protocols);
+ return protocol2num(ptr, &s->redir_protocols);
/* make a NULL argument reset to default */
- data->set.redir_protocols = (curl_prot_t) CURLPROTO_REDIR;
+ s->redir_protocols = (curl_prot_t) CURLPROTO_REDIR;
break;
case CURLOPT_DEFAULT_PROTOCOL:
/* Set the protocol to use when the URL does not include any protocol */
- return Curl_setstropt(&data->set.str[STRING_DEFAULT_PROTOCOL], ptr);
+ return Curl_setstropt(&s->str[STRING_DEFAULT_PROTOCOL], ptr);
#ifndef CURL_DISABLE_SMTP
case CURLOPT_MAIL_FROM:
/* Set the SMTP mail originator */
- return Curl_setstropt(&data->set.str[STRING_MAIL_FROM], ptr);
+ return Curl_setstropt(&s->str[STRING_MAIL_FROM], ptr);
case CURLOPT_MAIL_AUTH:
/* Set the SMTP auth originator */
- return Curl_setstropt(&data->set.str[STRING_MAIL_AUTH], ptr);
+ return Curl_setstropt(&s->str[STRING_MAIL_AUTH], ptr);
#endif
case CURLOPT_SASL_AUTHZID:
/* Authorization identity (identity to act as) */
- return Curl_setstropt(&data->set.str[STRING_SASL_AUTHZID], ptr);
+ return Curl_setstropt(&s->str[STRING_SASL_AUTHZID], ptr);
#ifndef CURL_DISABLE_RTSP
case CURLOPT_RTSP_SESSION_ID:
* Set the RTSP Session ID manually. Useful if the application is
* resuming a previously established RTSP session
*/
- return Curl_setstropt(&data->set.str[STRING_RTSP_SESSION_ID], ptr);
+ return Curl_setstropt(&s->str[STRING_RTSP_SESSION_ID], ptr);
case CURLOPT_RTSP_STREAM_URI:
/*
* Set the Stream URI for the RTSP request. Unless the request is
* for generic server options, the application will need to set this.
*/
- return Curl_setstropt(&data->set.str[STRING_RTSP_STREAM_URI], ptr);
+ return Curl_setstropt(&s->str[STRING_RTSP_STREAM_URI], ptr);
case CURLOPT_RTSP_TRANSPORT:
/*
* The content of the Transport: header for the RTSP request
*/
- return Curl_setstropt(&data->set.str[STRING_RTSP_TRANSPORT], ptr);
+ return Curl_setstropt(&s->str[STRING_RTSP_TRANSPORT], ptr);
case CURLOPT_INTERLEAVEDATA:
- data->set.rtp_out = ptr;
+ s->rtp_out = ptr;
break;
#endif /* ! CURL_DISABLE_RTSP */
#ifndef CURL_DISABLE_FTP
case CURLOPT_CHUNK_DATA:
- data->set.wildcardptr = ptr;
+ s->wildcardptr = ptr;
break;
case CURLOPT_FNMATCH_DATA:
- data->set.fnmatch_data = ptr;
+ s->fnmatch_data = ptr;
break;
#endif
#ifdef USE_TLS_SRP
case CURLOPT_TLSAUTH_USERNAME:
- return Curl_setstropt(&data->set.str[STRING_TLSAUTH_USERNAME], ptr);
+ return Curl_setstropt(&s->str[STRING_TLSAUTH_USERNAME], ptr);
#ifndef CURL_DISABLE_PROXY
case CURLOPT_PROXY_TLSAUTH_USERNAME:
- return Curl_setstropt(&data->set.str[STRING_TLSAUTH_USERNAME_PROXY], ptr);
+ return Curl_setstropt(&s->str[STRING_TLSAUTH_USERNAME_PROXY], ptr);
#endif
case CURLOPT_TLSAUTH_PASSWORD:
- return Curl_setstropt(&data->set.str[STRING_TLSAUTH_PASSWORD], ptr);
+ return Curl_setstropt(&s->str[STRING_TLSAUTH_PASSWORD], ptr);
#ifndef CURL_DISABLE_PROXY
case CURLOPT_PROXY_TLSAUTH_PASSWORD:
- return Curl_setstropt(&data->set.str[STRING_TLSAUTH_PASSWORD_PROXY], ptr);
+ return Curl_setstropt(&s->str[STRING_TLSAUTH_PASSWORD_PROXY], ptr);
#endif
case CURLOPT_TLSAUTH_TYPE:
if(ptr && !curl_strequal(ptr, "SRP"))
#endif
#ifdef CURLRES_ARES
case CURLOPT_DNS_SERVERS:
- result = Curl_setstropt(&data->set.str[STRING_DNS_SERVERS], ptr);
+ result = Curl_setstropt(&s->str[STRING_DNS_SERVERS], ptr);
if(result)
return result;
return Curl_async_ares_set_dns_servers(data);
case CURLOPT_DNS_INTERFACE:
- result = Curl_setstropt(&data->set.str[STRING_DNS_INTERFACE], ptr);
+ result = Curl_setstropt(&s->str[STRING_DNS_INTERFACE], ptr);
if(result)
return result;
return Curl_async_ares_set_dns_interface(data);
case CURLOPT_DNS_LOCAL_IP4:
- result = Curl_setstropt(&data->set.str[STRING_DNS_LOCAL_IP4], ptr);
+ result = Curl_setstropt(&s->str[STRING_DNS_LOCAL_IP4], ptr);
if(result)
return result;
return Curl_async_ares_set_dns_local_ip4(data);
case CURLOPT_DNS_LOCAL_IP6:
- result = Curl_setstropt(&data->set.str[STRING_DNS_LOCAL_IP6], ptr);
+ result = Curl_setstropt(&s->str[STRING_DNS_LOCAL_IP6], ptr);
if(result)
return result;
return Curl_async_ares_set_dns_local_ip6(data);
#endif
#ifdef USE_UNIX_SOCKETS
case CURLOPT_UNIX_SOCKET_PATH:
- data->set.abstract_unix_socket = FALSE;
- return Curl_setstropt(&data->set.str[STRING_UNIX_SOCKET_PATH], ptr);
+ s->abstract_unix_socket = FALSE;
+ return Curl_setstropt(&s->str[STRING_UNIX_SOCKET_PATH], ptr);
case CURLOPT_ABSTRACT_UNIX_SOCKET:
- data->set.abstract_unix_socket = TRUE;
- return Curl_setstropt(&data->set.str[STRING_UNIX_SOCKET_PATH], ptr);
+ s->abstract_unix_socket = TRUE;
+ return Curl_setstropt(&s->str[STRING_UNIX_SOCKET_PATH], ptr);
#endif
#ifndef CURL_DISABLE_DOH
case CURLOPT_DOH_URL:
- result = Curl_setstropt(&data->set.str[STRING_DOH], ptr);
- data->set.doh = !!(data->set.str[STRING_DOH]);
+ result = Curl_setstropt(&s->str[STRING_DOH], ptr);
+ s->doh = !!(s->str[STRING_DOH]);
break;
#endif
#ifndef CURL_DISABLE_HSTS
case CURLOPT_HSTSREADDATA:
- data->set.hsts_read_userp = ptr;
+ s->hsts_read_userp = ptr;
break;
case CURLOPT_HSTSWRITEDATA:
- data->set.hsts_write_userp = ptr;
+ s->hsts_write_userp = ptr;
break;
case CURLOPT_HSTS: {
struct curl_slist *h;
return CURLE_OUT_OF_MEMORY;
}
if(ptr) {
- result = Curl_setstropt(&data->set.str[STRING_HSTS], ptr);
+ result = Curl_setstropt(&s->str[STRING_HSTS], ptr);
if(result)
return result;
/* this needs to build a list of filenames to read from, so that it can
if(!data->asi)
return CURLE_OUT_OF_MEMORY;
}
- result = Curl_setstropt(&data->set.str[STRING_ALTSVC], ptr);
+ result = Curl_setstropt(&s->str[STRING_ALTSVC], ptr);
if(result)
return result;
if(ptr)
size_t plen = 0;
if(!ptr) {
- data->set.tls_ech = CURLECH_DISABLE;
+ s->tls_ech = CURLECH_DISABLE;
return CURLE_OK;
}
plen = strlen(ptr);
if(plen > CURL_MAX_INPUT_LENGTH) {
- data->set.tls_ech = CURLECH_DISABLE;
+ s->tls_ech = CURLECH_DISABLE;
return CURLE_BAD_FUNCTION_ARGUMENT;
}
/* set tls_ech flag value, preserving CLA_CFG bit */
if(!strcmp(ptr, "false"))
- data->set.tls_ech = CURLECH_DISABLE |
- (data->set.tls_ech & CURLECH_CLA_CFG);
+ s->tls_ech = CURLECH_DISABLE |
+ (s->tls_ech & CURLECH_CLA_CFG);
else if(!strcmp(ptr, "grease"))
- data->set.tls_ech = CURLECH_GREASE |
- (data->set.tls_ech & CURLECH_CLA_CFG);
+ s->tls_ech = CURLECH_GREASE |
+ (s->tls_ech & CURLECH_CLA_CFG);
else if(!strcmp(ptr, "true"))
- data->set.tls_ech = CURLECH_ENABLE |
- (data->set.tls_ech & CURLECH_CLA_CFG);
+ s->tls_ech = CURLECH_ENABLE |
+ (s->tls_ech & CURLECH_CLA_CFG);
else if(!strcmp(ptr, "hard"))
- data->set.tls_ech = CURLECH_HARD |
- (data->set.tls_ech & CURLECH_CLA_CFG);
+ s->tls_ech = CURLECH_HARD |
+ (s->tls_ech & CURLECH_CLA_CFG);
else if(plen > 5 && !strncmp(ptr, "ecl:", 4)) {
- result = Curl_setstropt(&data->set.str[STRING_ECH_CONFIG], ptr + 4);
+ result = Curl_setstropt(&s->str[STRING_ECH_CONFIG], ptr + 4);
if(result)
return result;
- data->set.tls_ech |= CURLECH_CLA_CFG;
+ s->tls_ech |= CURLECH_CLA_CFG;
}
else if(plen > 4 && !strncmp(ptr, "pn:", 3)) {
- result = Curl_setstropt(&data->set.str[STRING_ECH_PUBLIC], ptr + 3);
+ result = Curl_setstropt(&s->str[STRING_ECH_PUBLIC], ptr + 3);
if(result)
return result;
}
static CURLcode setopt_func(struct Curl_easy *data, CURLoption option,
va_list param)
{
+ struct UserDefined *s = &data->set;
switch(option) {
case CURLOPT_PROGRESSFUNCTION:
/*
* Progress callback function
*/
- data->set.fprogress = va_arg(param, curl_progress_callback);
- if(data->set.fprogress)
+ s->fprogress = va_arg(param, curl_progress_callback);
+ if(s->fprogress)
data->progress.callback = TRUE; /* no longer internal */
else
data->progress.callback = FALSE; /* NULL enforces internal */
/*
* Transfer info callback function
*/
- data->set.fxferinfo = va_arg(param, curl_xferinfo_callback);
- if(data->set.fxferinfo)
+ s->fxferinfo = va_arg(param, curl_xferinfo_callback);
+ if(s->fxferinfo)
data->progress.callback = TRUE; /* no longer internal */
else
data->progress.callback = FALSE; /* NULL enforces internal */
/*
* stderr write callback.
*/
- data->set.fdebug = va_arg(param, curl_debug_callback);
+ s->fdebug = va_arg(param, curl_debug_callback);
/*
* if the callback provided is NULL, it will use the default callback
*/
/*
* Set header write callback
*/
- data->set.fwrite_header = va_arg(param, curl_write_callback);
+ s->fwrite_header = va_arg(param, curl_write_callback);
break;
case CURLOPT_WRITEFUNCTION:
/*
* Set data write callback
*/
- data->set.fwrite_func = va_arg(param, curl_write_callback);
- if(!data->set.fwrite_func)
+ s->fwrite_func = va_arg(param, curl_write_callback);
+ if(!s->fwrite_func)
/* When set to NULL, reset to our internal default function */
- data->set.fwrite_func = (curl_write_callback)fwrite;
+ s->fwrite_func = (curl_write_callback)fwrite;
break;
case CURLOPT_READFUNCTION:
/*
* Read data callback
*/
- data->set.fread_func_set = va_arg(param, curl_read_callback);
- if(!data->set.fread_func_set) {
- data->set.is_fread_set = 0;
+ s->fread_func_set = va_arg(param, curl_read_callback);
+ if(!s->fread_func_set) {
+ s->is_fread_set = 0;
/* When set to NULL, reset to our internal default function */
- data->set.fread_func_set = (curl_read_callback)fread;
+ s->fread_func_set = (curl_read_callback)fread;
}
else
- data->set.is_fread_set = 1;
+ s->is_fread_set = 1;
break;
case CURLOPT_SEEKFUNCTION:
/*
* Seek callback. Might be NULL.
*/
- data->set.seek_func = va_arg(param, curl_seek_callback);
+ s->seek_func = va_arg(param, curl_seek_callback);
break;
case CURLOPT_IOCTLFUNCTION:
/*
* I/O control callback. Might be NULL.
*/
- data->set.ioctl_func = va_arg(param, curl_ioctl_callback);
+ s->ioctl_func = va_arg(param, curl_ioctl_callback);
break;
case CURLOPT_SSL_CTX_FUNCTION:
/*
*/
#ifdef USE_SSL
if(Curl_ssl_supports(data, SSLSUPP_SSL_CTX)) {
- data->set.ssl.fsslctx = va_arg(param, curl_ssl_ctx_callback);
+ s->ssl.fsslctx = va_arg(param, curl_ssl_ctx_callback);
break;
}
else
/*
* socket callback function: called after socket() but before connect()
*/
- data->set.fsockopt = va_arg(param, curl_sockopt_callback);
+ s->fsockopt = va_arg(param, curl_sockopt_callback);
break;
case CURLOPT_OPENSOCKETFUNCTION:
* open/create socket callback function: called instead of socket(),
* before connect()
*/
- data->set.fopensocket = va_arg(param, curl_opensocket_callback);
+ s->fopensocket = va_arg(param, curl_opensocket_callback);
break;
case CURLOPT_CLOSESOCKETFUNCTION:
* close socket callback function: called instead of close()
* when shutting down a connection
*/
- data->set.fclosesocket = va_arg(param, curl_closesocket_callback);
+ s->fclosesocket = va_arg(param, curl_closesocket_callback);
break;
case CURLOPT_RESOLVER_START_FUNCTION:
* resolver start callback function: called before a new resolver request
* is started
*/
- data->set.resolver_start = va_arg(param, curl_resolver_start_callback);
+ s->resolver_start = va_arg(param, curl_resolver_start_callback);
break;
#ifdef USE_SSH
#ifdef USE_LIBSSH2
case CURLOPT_SSH_HOSTKEYFUNCTION:
/* the callback to check the hostkey without the knownhost file */
- data->set.ssh_hostkeyfunc = va_arg(param, curl_sshhostkeycallback);
+ s->ssh_hostkeyfunc = va_arg(param, curl_sshhostkeycallback);
break;
#endif
case CURLOPT_SSH_KEYFUNCTION:
/* setting to NULL is fine since the ssh.c functions themselves will
then revert to use the internal default */
- data->set.ssh_keyfunc = va_arg(param, curl_sshkeycallback);
+ s->ssh_keyfunc = va_arg(param, curl_sshkeycallback);
break;
#endif /* USE_SSH */
#ifndef CURL_DISABLE_RTSP
case CURLOPT_INTERLEAVEFUNCTION:
/* Set the user defined RTP write function */
- data->set.fwrite_rtp = va_arg(param, curl_write_callback);
+ s->fwrite_rtp = va_arg(param, curl_write_callback);
break;
#endif
#ifndef CURL_DISABLE_FTP
case CURLOPT_CHUNK_BGN_FUNCTION:
- data->set.chunk_bgn = va_arg(param, curl_chunk_bgn_callback);
+ s->chunk_bgn = va_arg(param, curl_chunk_bgn_callback);
break;
case CURLOPT_CHUNK_END_FUNCTION:
- data->set.chunk_end = va_arg(param, curl_chunk_end_callback);
+ s->chunk_end = va_arg(param, curl_chunk_end_callback);
break;
case CURLOPT_FNMATCH_FUNCTION:
- data->set.fnmatch = va_arg(param, curl_fnmatch_callback);
+ s->fnmatch = va_arg(param, curl_fnmatch_callback);
break;
#endif
#ifndef CURL_DISABLE_HTTP
case CURLOPT_TRAILERFUNCTION:
- data->set.trailer_callback = va_arg(param, curl_trailer_callback);
+ s->trailer_callback = va_arg(param, curl_trailer_callback);
break;
#endif
#ifndef CURL_DISABLE_HSTS
case CURLOPT_HSTSREADFUNCTION:
- data->set.hsts_read = va_arg(param, curl_hstsread_callback);
+ s->hsts_read = va_arg(param, curl_hstsread_callback);
break;
case CURLOPT_HSTSWRITEFUNCTION:
- data->set.hsts_write = va_arg(param, curl_hstswrite_callback);
+ s->hsts_write = va_arg(param, curl_hstswrite_callback);
break;
#endif
case CURLOPT_PREREQFUNCTION:
- data->set.fprereq = va_arg(param, curl_prereq_callback);
+ s->fprereq = va_arg(param, curl_prereq_callback);
break;
default:
return CURLE_UNKNOWN_OPTION;
static CURLcode setopt_offt(struct Curl_easy *data, CURLoption option,
curl_off_t offt)
{
+ struct UserDefined *s = &data->set;
switch(option) {
case CURLOPT_TIMEVALUE_LARGE:
/*
* This is the value to compare with the remote document with the
* method set with CURLOPT_TIMECONDITION
*/
- data->set.timevalue = (time_t)offt;
+ s->timevalue = (time_t)offt;
break;
/* MQTT "borrows" some of the HTTP options */
if(offt < -1)
return CURLE_BAD_FUNCTION_ARGUMENT;
- if(data->set.postfieldsize < offt &&
- data->set.postfields == data->set.str[STRING_COPYPOSTFIELDS]) {
+ if(s->postfieldsize < offt &&
+ s->postfields == s->str[STRING_COPYPOSTFIELDS]) {
/* Previous CURLOPT_COPYPOSTFIELDS is no longer valid. */
- Curl_safefree(data->set.str[STRING_COPYPOSTFIELDS]);
- data->set.postfields = NULL;
+ Curl_safefree(s->str[STRING_COPYPOSTFIELDS]);
+ s->postfields = NULL;
}
- data->set.postfieldsize = offt;
+ s->postfieldsize = offt;
break;
case CURLOPT_INFILESIZE_LARGE:
/*
*/
if(offt < -1)
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.filesize = offt;
+ s->filesize = offt;
break;
case CURLOPT_MAX_SEND_SPEED_LARGE:
/*
*/
if(offt < 0)
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.max_send_speed = offt;
+ s->max_send_speed = offt;
break;
case CURLOPT_MAX_RECV_SPEED_LARGE:
/*
*/
if(offt < 0)
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.max_recv_speed = offt;
+ s->max_recv_speed = offt;
break;
case CURLOPT_RESUME_FROM_LARGE:
/*
*/
if(offt < -1)
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.set_resume_from = offt;
+ s->set_resume_from = offt;
break;
case CURLOPT_MAXFILESIZE_LARGE:
/*
*/
if(offt < 0)
return CURLE_BAD_FUNCTION_ARGUMENT;
- data->set.max_filesize = offt;
+ s->max_filesize = offt;
break;
default:
static CURLcode setopt_blob(struct Curl_easy *data, CURLoption option,
struct curl_blob *blob)
{
+ struct UserDefined *s = &data->set;
switch(option) {
case CURLOPT_SSLCERT_BLOB:
/*
* Blob that holds file content of the SSL certificate to use
*/
- return Curl_setblobopt(&data->set.blobs[BLOB_CERT], blob);
+ return Curl_setblobopt(&s->blobs[BLOB_CERT], blob);
#ifndef CURL_DISABLE_PROXY
case CURLOPT_PROXY_SSLCERT_BLOB:
/*
* Blob that holds file content of the SSL certificate to use for proxy
*/
- return Curl_setblobopt(&data->set.blobs[BLOB_CERT_PROXY], blob);
+ return Curl_setblobopt(&s->blobs[BLOB_CERT_PROXY], blob);
case CURLOPT_PROXY_SSLKEY_BLOB:
/*
* Blob that holds file content of the SSL key to use for proxy
*/
- return Curl_setblobopt(&data->set.blobs[BLOB_KEY_PROXY], blob);
+ return Curl_setblobopt(&s->blobs[BLOB_KEY_PROXY], blob);
case CURLOPT_PROXY_CAINFO_BLOB:
/*
* Blob that holds CA info for SSL connection proxy.
*/
#ifdef USE_SSL
if(Curl_ssl_supports(data, SSLSUPP_CAINFO_BLOB))
- return Curl_setblobopt(&data->set.blobs[BLOB_CAINFO_PROXY], blob);
+ return Curl_setblobopt(&s->blobs[BLOB_CAINFO_PROXY], blob);
#endif
return CURLE_NOT_BUILT_IN;
case CURLOPT_PROXY_ISSUERCERT_BLOB:
/*
* Blob that holds Issuer certificate to check certificates issuer
*/
- return Curl_setblobopt(&data->set.blobs[BLOB_SSL_ISSUERCERT_PROXY],
+ return Curl_setblobopt(&s->blobs[BLOB_SSL_ISSUERCERT_PROXY],
blob);
#endif
case CURLOPT_SSLKEY_BLOB:
/*
* Blob that holds file content of the SSL key to use
*/
- return Curl_setblobopt(&data->set.blobs[BLOB_KEY], blob);
+ return Curl_setblobopt(&s->blobs[BLOB_KEY], blob);
case CURLOPT_CAINFO_BLOB:
/*
* Blob that holds CA info for SSL connection.
*/
#ifdef USE_SSL
if(Curl_ssl_supports(data, SSLSUPP_CAINFO_BLOB))
- return Curl_setblobopt(&data->set.blobs[BLOB_CAINFO], blob);
+ return Curl_setblobopt(&s->blobs[BLOB_CAINFO], blob);
#endif
return CURLE_NOT_BUILT_IN;
case CURLOPT_ISSUERCERT_BLOB:
/*
* Blob that holds Issuer certificate to check certificates issuer
*/
- return Curl_setblobopt(&data->set.blobs[BLOB_SSL_ISSUERCERT], blob);
+ return Curl_setblobopt(&s->blobs[BLOB_SSL_ISSUERCERT], blob);
default:
return CURLE_UNKNOWN_OPTION;
projects / thirdparty / curl.git / commitdiff
