curl/curl
1
1
Fork 0
mirror of https://github.com/curl/curl.git synced 2025-09-07 04:45:03 +03:00
Code Issues Packages Projects Releases Wiki Activity

curl: remove the global argument from many functions

Browse Source 
Since the config struct has a pointer to it, both pointers don't need to
be passed on.

Closes #17890
This commit is contained in:
Daniel Stenberg 2025-07-10 18:33:50 +02:00
parent d516628d14
commit f0b8137c1c
No known key found for this signature in database
GPG Key ID: 5CC908FDB71E12C2
10 changed files with 182 additions and 220 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
src/config2setopts.c
View File

@ -171,10 +171,9 @@ static CURLcode url_proto_and_rewrite(char **url,
return result; return result;
} }
static CURLcode ssh_setopts(struct GlobalConfig *global, static CURLcode ssh_setopts(struct OperationConfig *config, CURL *curl)
struct OperationConfig *config,
CURL *curl)
{ {
struct GlobalConfig *global = config->global;
CURLcode result; CURLcode result;
/* SSH and SSL private key uses same command-line option */ /* SSH and SSL private key uses same command-line option */
@ -231,10 +230,9 @@ extern const unsigned char curl_ca_embed[];
#endif #endif
/* only called if libcurl supports TLS */ /* only called if libcurl supports TLS */
static CURLcode ssl_setopts(struct GlobalConfig *global, static CURLcode ssl_setopts(struct OperationConfig *config, CURL *curl)
struct OperationConfig *config,
CURL *curl)
{ {
struct GlobalConfig *global = config->global;
CURLcode result = CURLE_OK; CURLcode result = CURLE_OK;
if(config->cacert) if(config->cacert)
@ -461,12 +459,10 @@ static CURLcode ssl_setopts(struct GlobalConfig *global,
} }
/* only called for HTTP transfers */ /* only called for HTTP transfers */
static CURLcode http_setopts(struct GlobalConfig *global, static CURLcode http_setopts(struct OperationConfig *config,
struct OperationConfig *config,
CURL *curl) CURL *curl)
{ {
long postRedir = 0; long postRedir = 0;
(void) global; /* for builds without --libcurl */
my_setopt_long(curl, CURLOPT_FOLLOWLOCATION, my_setopt_long(curl, CURLOPT_FOLLOWLOCATION,
config->followlocation); config->followlocation);
@ -521,9 +517,7 @@ static CURLcode http_setopts(struct GlobalConfig *global,
return CURLE_OK; return CURLE_OK;
} }
static CURLcode cookie_setopts(struct GlobalConfig *global, static CURLcode cookie_setopts(struct OperationConfig *config, CURL *curl)
struct OperationConfig *config,
CURL *curl)
{ {
CURLcode result = CURLE_OK; CURLcode result = CURLE_OK;
if(config->cookies) { if(config->cookies) {
@ -540,7 +534,7 @@ static CURLcode cookie_setopts(struct GlobalConfig *global,
result = curlx_dyn_addf(&cookies, ";%s", cl->data); result = curlx_dyn_addf(&cookies, ";%s", cl->data);
if(result) { if(result) {
warnf(global, warnf(config->global,
"skipped provided cookie, the cookie header " "skipped provided cookie, the cookie header "
"would go over %u bytes", MAX_COOKIE_LINE); "would go over %u bytes", MAX_COOKIE_LINE);
return result; return result;
@ -568,11 +562,9 @@ static CURLcode cookie_setopts(struct GlobalConfig *global,
return result; return result;
} }
static CURLcode tcp_setopts(struct GlobalConfig *global, static CURLcode tcp_setopts(struct OperationConfig *config,
struct OperationConfig *config,
CURL *curl) CURL *curl)
{ {
(void) global; /* for builds without --libcurl */
if(!config->tcp_nodelay) if(!config->tcp_nodelay)
my_setopt_long(curl, CURLOPT_TCP_NODELAY, 0); my_setopt_long(curl, CURLOPT_TCP_NODELAY, 0);
@ -597,11 +589,8 @@ static CURLcode tcp_setopts(struct GlobalConfig *global,
return CURLE_OK; return CURLE_OK;
} }
static CURLcode ftp_setopts(struct GlobalConfig *global, static CURLcode ftp_setopts(struct OperationConfig *config, CURL *curl)
struct OperationConfig *config,
CURL *curl)
{ {
(void) global; /* for builds without --libcurl */
my_setopt_str(curl, CURLOPT_FTPPORT, config->ftpport); my_setopt_str(curl, CURLOPT_FTPPORT, config->ftpport);
/* new in libcurl 7.9.2: */ /* new in libcurl 7.9.2: */
@ -637,23 +626,20 @@ static CURLcode ftp_setopts(struct GlobalConfig *global,
return CURLE_OK; return CURLE_OK;
} }
static void gen_trace_setopts(struct GlobalConfig *global, static void gen_trace_setopts(struct OperationConfig *config, CURL *curl)
struct OperationConfig *config,
CURL *curl)
{ {
if(global->tracetype != TRACE_NONE) { if(config->global->tracetype != TRACE_NONE) {
my_setopt(curl, CURLOPT_DEBUGFUNCTION, tool_debug_cb); my_setopt(curl, CURLOPT_DEBUGFUNCTION, tool_debug_cb);
my_setopt(curl, CURLOPT_DEBUGDATA, config); my_setopt(curl, CURLOPT_DEBUGDATA, config);
my_setopt_long(curl, CURLOPT_VERBOSE, 1L); my_setopt_long(curl, CURLOPT_VERBOSE, 1L);
} }
} }
static void gen_cb_setopts(struct GlobalConfig *global, static void gen_cb_setopts(struct OperationConfig *config,
struct OperationConfig *config,
struct per_transfer *per, struct per_transfer *per,
CURL *curl) CURL *curl)
{ {
(void) global; /* for builds without --libcurl */ struct GlobalConfig *global = config->global;
(void) config; (void) config;
/* where to store */ /* where to store */
my_setopt(curl, CURLOPT_WRITEDATA, per); my_setopt(curl, CURLOPT_WRITEDATA, per);
@ -690,17 +676,13 @@ static void gen_cb_setopts(struct GlobalConfig *global,
my_setopt(curl, CURLOPT_HEADERDATA, per); my_setopt(curl, CURLOPT_HEADERDATA, per);
} }
static CURLcode proxy_setopts(struct GlobalConfig *global, static CURLcode proxy_setopts(struct OperationConfig *config, CURL *curl)
struct OperationConfig *config,
CURL *curl)
{ {
(void) global; /* for builds without --libcurl */
if(config->proxy) { if(config->proxy) {
CURLcode result = my_setopt_str(curl, CURLOPT_PROXY, config->proxy); CURLcode result = my_setopt_str(curl, CURLOPT_PROXY, config->proxy);
if(result) { if(result) {
errorf(global, "proxy support is disabled in this libcurl"); errorf(config->global, "proxy support is disabled in this libcurl");
config->synthetic_error = TRUE; config->synthetic_error = TRUE;
return CURLE_NOT_BUILT_IN; return CURLE_NOT_BUILT_IN;
} }
@ -753,11 +735,8 @@ static CURLcode proxy_setopts(struct GlobalConfig *global,
return CURLE_OK; return CURLE_OK;
} }
static void tls_srp_setopts(struct GlobalConfig *global, static void tls_srp_setopts(struct OperationConfig *config, CURL *curl)
struct OperationConfig *config,
CURL *curl)
{ {
(void) global; /* for builds without --libcurl */
if(config->tls_username) if(config->tls_username)
my_setopt_str(curl, CURLOPT_TLSAUTH_USERNAME, config->tls_username); my_setopt_str(curl, CURLOPT_TLSAUTH_USERNAME, config->tls_username);
if(config->tls_password) if(config->tls_password)
@ -775,12 +754,12 @@ static void tls_srp_setopts(struct GlobalConfig *global,
config->proxy_tls_authtype); config->proxy_tls_authtype);
} }
CURLcode config2setopts(struct GlobalConfig *global, CURLcode config2setopts(struct OperationConfig *config,
struct OperationConfig *config,
struct per_transfer *per, struct per_transfer *per,
CURL *curl, CURL *curl,
CURLSH *share) CURLSH *share)
{ {
struct GlobalConfig *global = config->global;
const char *use_proto; const char *use_proto;
CURLcode result = url_proto_and_rewrite(&per->url, config, &use_proto); CURLcode result = url_proto_and_rewrite(&per->url, config, &use_proto);
@ -801,7 +780,7 @@ CURLcode config2setopts(struct GlobalConfig *global,
return result; return result;
#endif #endif
gen_trace_setopts(global, config, curl); gen_trace_setopts(config, curl);
{ {
#ifdef DEBUGBUILD #ifdef DEBUGBUILD
@ -825,7 +804,7 @@ CURLcode config2setopts(struct GlobalConfig *global,
my_setopt_long(curl, CURLOPT_NOPROGRESS, my_setopt_long(curl, CURLOPT_NOPROGRESS,
global->noprogress || global->silent); global->noprogress || global->silent);
/* call after the line above. It may override CURLOPT_NOPROGRESS */ /* call after the line above. It may override CURLOPT_NOPROGRESS */
gen_cb_setopts(global, config, per, curl); gen_cb_setopts(config, per, curl);
if(config->no_body) if(config->no_body)
my_setopt_long(curl, CURLOPT_NOBODY, 1); my_setopt_long(curl, CURLOPT_NOBODY, 1);
@ -833,7 +812,7 @@ CURLcode config2setopts(struct GlobalConfig *global,
if(config->oauth_bearer) if(config->oauth_bearer)
my_setopt_str(curl, CURLOPT_XOAUTH2_BEARER, config->oauth_bearer); my_setopt_str(curl, CURLOPT_XOAUTH2_BEARER, config->oauth_bearer);
result = proxy_setopts(global, config, curl); result = proxy_setopts(config, curl);
if(result) if(result)
return result; return result;
@ -913,15 +892,15 @@ CURLcode config2setopts(struct GlobalConfig *global,
} }
if(use_proto == proto_http || use_proto == proto_https) { if(use_proto == proto_http || use_proto == proto_https) {
result = http_setopts(global, config, curl); result = http_setopts(config, curl);
if(!result) if(!result)
result = cookie_setopts(global, config, curl); result = cookie_setopts(config, curl);
if(result) if(result)
return result; return result;
} }
if(use_proto == proto_ftp || use_proto == proto_ftps) { if(use_proto == proto_ftp || use_proto == proto_ftps) {
result = ftp_setopts(global, config, curl); result = ftp_setopts(config, curl);
if(result) if(result)
return result; return result;
} }
@ -940,13 +919,13 @@ CURLcode config2setopts(struct GlobalConfig *global,
my_setopt_str(curl, CURLOPT_PROXY_KEYPASSWD, config->proxy_key_passwd); my_setopt_str(curl, CURLOPT_PROXY_KEYPASSWD, config->proxy_key_passwd);
if(use_proto == proto_scp || use_proto == proto_sftp) { if(use_proto == proto_scp || use_proto == proto_sftp) {
result = ssh_setopts(global, config, curl); result = ssh_setopts(config, curl);
if(result) if(result)
return result; return result;
} }
if(feature_ssl) { if(feature_ssl) {
result = ssl_setopts(global, config, curl); result = ssl_setopts(config, curl);
if(result) if(result)
return result; return result;
} }
@ -1036,7 +1015,7 @@ CURLcode config2setopts(struct GlobalConfig *global,
my_setopt_long(curl, CURLOPT_HTTP_TRANSFER_DECODING, 0); my_setopt_long(curl, CURLOPT_HTTP_TRANSFER_DECODING, 0);
} }
result = tcp_setopts(global, config, curl); result = tcp_setopts(config, curl);
if(result) if(result)
return result; return result;
@ -1072,7 +1051,7 @@ CURLcode config2setopts(struct GlobalConfig *global,
/* new in 7.21.4 */ /* new in 7.21.4 */
if(feature_tls_srp) if(feature_tls_srp)
tls_srp_setopts(global, config, curl); tls_srp_setopts(config, curl);
/* new in 7.22.0 */ /* new in 7.22.0 */
if(config->gssapi_delegation) if(config->gssapi_delegation)

3
src/config2setopts.h
View File

@ -24,8 +24,7 @@
* *
***************************************************************************/ ***************************************************************************/
CURLcode config2setopts(struct GlobalConfig *global, CURLcode config2setopts(struct OperationConfig *config,
struct OperationConfig *config,
struct per_transfer *per, struct per_transfer *per,
CURL *curl, CURL *curl,
CURLSH *share); CURLSH *share);

107
src/tool_getparam.c
View File

@ -690,13 +690,12 @@ error:
return err; return err;
} }
static void sethttpver(struct GlobalConfig *global, static void sethttpver(struct OperationConfig *config,
struct OperationConfig *config,
long httpversion) long httpversion)
{ {
if(config->httpversion && if(config->httpversion &&
(config->httpversion != httpversion)) (config->httpversion != httpversion))
warnf(global, "Overrides previous HTTP version option"); warnf(config->global, "Overrides previous HTTP version option");
config->httpversion = httpversion; config->httpversion = httpversion;
} }
@ -841,7 +840,6 @@ static int find_tos(const void *a, const void *b)
#define MAX_QUERY_LEN 100000 /* larger is not likely to ever work */ #define MAX_QUERY_LEN 100000 /* larger is not likely to ever work */
static ParameterError url_query(const char *nextarg, static ParameterError url_query(const char *nextarg,
struct GlobalConfig *global,
struct OperationConfig *config) struct OperationConfig *config)
{ {
size_t size = 0; size_t size = 0;
@ -857,7 +855,7 @@ static ParameterError url_query(const char *nextarg,
err = PARAM_NO_MEM; err = PARAM_NO_MEM;
} }
else else
err = data_urlencode(global, nextarg, &query, &size); err = data_urlencode(config->global, nextarg, &query, &size);
if(!err) { if(!err) {
if(config->query) { if(config->query) {
@ -878,13 +876,13 @@ static ParameterError url_query(const char *nextarg,
static ParameterError set_data(cmdline_t cmd, static ParameterError set_data(cmdline_t cmd,
const char *nextarg, const char *nextarg,
struct GlobalConfig *global,
struct OperationConfig *config) struct OperationConfig *config)
{ {
char *postdata = NULL; char *postdata = NULL;
FILE *file; FILE *file;
size_t size = 0; size_t size = 0;
ParameterError err = PARAM_OK; ParameterError err = PARAM_OK;
struct GlobalConfig *global = config->global;
if(cmd == C_DATA_URLENCODE) { /* --data-urlencode */ if(cmd == C_DATA_URLENCODE) { /* --data-urlencode */
err = data_urlencode(global, nextarg, &postdata, &size); err = data_urlencode(global, nextarg, &postdata, &size);
@ -1039,8 +1037,7 @@ const struct LongShort *findlongopt(const char *opt)
sizeof(aliases[0]), findarg); sizeof(aliases[0]), findarg);
} }
static ParameterError add_url(struct GlobalConfig *global, static ParameterError add_url(struct OperationConfig *config,
struct OperationConfig *config,
const char *thisurl, const char *thisurl,
bool remote_noglob) bool remote_noglob)
{ {
@ -1076,15 +1073,14 @@ static ParameterError add_url(struct GlobalConfig *global,
url->useremote = url->noglob = TRUE; url->useremote = url->noglob = TRUE;
if(!err && (++config->num_urls > 1) && if(!err && (++config->num_urls > 1) &&
(config->etag_save_file || config->etag_compare_file)) { (config->etag_save_file || config->etag_compare_file)) {
errorf(global, "The etag options only work on a single URL"); errorf(config->global, "The etag options only work on a single URL");
return PARAM_BAD_USE; return PARAM_BAD_USE;
} }
} }
return err; return err;
} }
static ParameterError parse_url(struct GlobalConfig *global, static ParameterError parse_url(struct OperationConfig *config,
struct OperationConfig *config,
const char *nextarg) const char *nextarg)
{ {
/* nextarg is never NULL here */ /* nextarg is never NULL here */
@ -1104,7 +1100,7 @@ static ParameterError parse_url(struct GlobalConfig *global,
curlx_dyn_init(&line, 8092); curlx_dyn_init(&line, 8092);
while(my_get_line(f, &line, &error)) { while(my_get_line(f, &line, &error)) {
const char *ptr = curlx_dyn_ptr(&line); const char *ptr = curlx_dyn_ptr(&line);
err = add_url(global, config, ptr, TRUE); err = add_url(config, ptr, TRUE);
if(err) if(err)
break; break;
} }
@ -1117,7 +1113,7 @@ static ParameterError parse_url(struct GlobalConfig *global,
} }
return PARAM_READ_ERROR; /* file not found */ return PARAM_READ_ERROR; /* file not found */
} }
return add_url(global, config, nextarg, FALSE); return add_url(config, nextarg, FALSE);
} }
@ -1157,10 +1153,10 @@ static ParameterError parse_localport(struct OperationConfig *config,
return PARAM_OK; return PARAM_OK;
} }
static ParameterError parse_continue_at(struct GlobalConfig *global, static ParameterError parse_continue_at(struct OperationConfig *config,
struct OperationConfig *config,
const char *nextarg) const char *nextarg)
{ {
struct GlobalConfig *global = config->global;
ParameterError err = PARAM_OK; ParameterError err = PARAM_OK;
if(config->range) { if(config->range) {
errorf(global, "--continue-at is mutually exclusive with --range"); errorf(global, "--continue-at is mutually exclusive with --range");
@ -1189,8 +1185,7 @@ static ParameterError parse_continue_at(struct GlobalConfig *global,
return err; return err;
} }
static ParameterError parse_ech(struct GlobalConfig *global, static ParameterError parse_ech(struct OperationConfig *config,
struct OperationConfig *config,
const char *nextarg) const char *nextarg)
{ {
ParameterError err = PARAM_OK; ParameterError err = PARAM_OK;
@ -1218,7 +1213,7 @@ static ParameterError parse_ech(struct GlobalConfig *global,
file = fopen(nextarg, FOPEN_READTEXT); file = fopen(nextarg, FOPEN_READTEXT);
} }
if(!file) { if(!file) {
warnf(global, warnf(config->global,
"Couldn't read file \"%s\" " "Couldn't read file \"%s\" "
"specified for \"--ech ecl:\" option", "specified for \"--ech ecl:\" option",
nextarg); nextarg);
@ -1242,8 +1237,7 @@ static ParameterError parse_ech(struct GlobalConfig *global,
return err; return err;
} }
static ParameterError parse_header(struct GlobalConfig *global, static ParameterError parse_header(struct OperationConfig *config,
struct OperationConfig *config,
cmdline_t cmd, cmdline_t cmd,
const char *nextarg) const char *nextarg)
{ {
@ -1255,7 +1249,7 @@ static ParameterError parse_header(struct GlobalConfig *global,
bool use_stdin = !strcmp(&nextarg[1], "-"); bool use_stdin = !strcmp(&nextarg[1], "-");
FILE *file = use_stdin ? stdin : fopen(&nextarg[1], FOPEN_READTEXT); FILE *file = use_stdin ? stdin : fopen(&nextarg[1], FOPEN_READTEXT);
if(!file) { if(!file) {
errorf(global, "Failed to open %s", &nextarg[1]); errorf(config->global, "Failed to open %s", &nextarg[1]);
err = PARAM_READ_ERROR; err = PARAM_READ_ERROR;
} }
else { else {
@ -1384,13 +1378,13 @@ static ParameterError parse_quote(struct OperationConfig *config,
return err; return err;
} }
static ParameterError parse_range(struct GlobalConfig *global, static ParameterError parse_range(struct OperationConfig *config,
struct OperationConfig *config,
const char *nextarg) const char *nextarg)
{ {
ParameterError err = PARAM_OK; ParameterError err = PARAM_OK;
curl_off_t value; curl_off_t value;
const char *orig = nextarg; const char *orig = nextarg;
struct GlobalConfig *global = config->global;
if(config->use_resume) { if(config->use_resume) {
errorf(global, "--continue-at is mutually exclusive with --range"); errorf(global, "--continue-at is mutually exclusive with --range");
@ -1527,8 +1521,7 @@ static ParameterError parse_verbose(struct GlobalConfig *global,
return err; return err;
} }
static ParameterError parse_writeout(struct GlobalConfig *global, static ParameterError parse_writeout(struct OperationConfig *config,
struct OperationConfig *config,
const char *nextarg) const char *nextarg)
{ {
ParameterError err = PARAM_OK; ParameterError err = PARAM_OK;
@ -1548,7 +1541,7 @@ static ParameterError parse_writeout(struct GlobalConfig *global,
fname = nextarg; fname = nextarg;
file = fopen(fname, FOPEN_READTEXT); file = fopen(fname, FOPEN_READTEXT);
if(!file) { if(!file) {
errorf(global, "Failed to open %s", fname); errorf(config->global, "Failed to open %s", fname);
return PARAM_READ_ERROR; return PARAM_READ_ERROR;
} }
} }
@ -1559,7 +1552,7 @@ static ParameterError parse_writeout(struct GlobalConfig *global,
if(err) if(err)
return err; return err;
if(!config->writeout) if(!config->writeout)
warnf(global, "Failed to read %s", fname); warnf(config->global, "Failed to read %s", fname);
} }
else else
err = getstr(&config->writeout, nextarg, ALLOW_BLANK); err = getstr(&config->writeout, nextarg, ALLOW_BLANK);
@ -1567,8 +1560,7 @@ static ParameterError parse_writeout(struct GlobalConfig *global,
return err; return err;
} }
static ParameterError parse_time_cond(struct GlobalConfig *global, static ParameterError parse_time_cond(struct OperationConfig *config,
struct OperationConfig *config,
const char *nextarg) const char *nextarg)
{ {
ParameterError err = PARAM_OK; ParameterError err = PARAM_OK;
@ -1596,14 +1588,14 @@ static ParameterError parse_time_cond(struct GlobalConfig *global,
if(-1 == config->condtime) { if(-1 == config->condtime) {
curl_off_t value; curl_off_t value;
/* now let's see if it is a filename to get the time from instead! */ /* now let's see if it is a filename to get the time from instead! */
int rc = getfiletime(nextarg, global, &value); int rc = getfiletime(nextarg, config->global, &value);
if(!rc) if(!rc)
/* pull the time out from the file */ /* pull the time out from the file */
config->condtime = value; config->condtime = value;
else { else {
/* failed, remove time condition */ /* failed, remove time condition */
config->timecond = CURL_TIMECOND_NONE; config->timecond = CURL_TIMECOND_NONE;
warnf(global, warnf(config->global,
"Illegal date format for -z, --time-cond (and not " "Illegal date format for -z, --time-cond (and not "
"a filename). Disabling time condition. " "a filename). Disabling time condition. "
"See curl_getdate(3) for valid date syntax."); "See curl_getdate(3) for valid date syntax.");
@ -1691,8 +1683,7 @@ static void opt_depr(struct GlobalConfig *global,
} }
/* opt_none is the function that handles ARG_NONE options */ /* opt_none is the function that handles ARG_NONE options */
static ParameterError opt_none(struct GlobalConfig *global, static ParameterError opt_none(struct OperationConfig *config,
struct OperationConfig *config,
const struct LongShort *a) const struct LongShort *a)
{ {
switch(a->cmd) { switch(a->cmd) {
@ -1707,37 +1698,37 @@ static ParameterError opt_none(struct GlobalConfig *global,
case C_HTTP1_0: /* --http1.0 */ case C_HTTP1_0: /* --http1.0 */
/* HTTP version 1.0 */ /* HTTP version 1.0 */
sethttpver(global, config, CURL_HTTP_VERSION_1_0); sethttpver(config, CURL_HTTP_VERSION_1_0);
break; break;
case C_HTTP1_1: /* --http1.1 */ case C_HTTP1_1: /* --http1.1 */
/* HTTP version 1.1 */ /* HTTP version 1.1 */
sethttpver(global, config, CURL_HTTP_VERSION_1_1); sethttpver(config, CURL_HTTP_VERSION_1_1);
break; break;
case C_HTTP2: /* --http2 */ case C_HTTP2: /* --http2 */
/* HTTP version 2.0 */ /* HTTP version 2.0 */
if(!feature_http2) if(!feature_http2)
return PARAM_LIBCURL_DOESNT_SUPPORT; return PARAM_LIBCURL_DOESNT_SUPPORT;
sethttpver(global, config, CURL_HTTP_VERSION_2_0); sethttpver(config, CURL_HTTP_VERSION_2_0);
break; break;
case C_HTTP2_PRIOR_KNOWLEDGE: /* --http2-prior-knowledge */ case C_HTTP2_PRIOR_KNOWLEDGE: /* --http2-prior-knowledge */
/* HTTP version 2.0 over clean TCP */ /* HTTP version 2.0 over clean TCP */
if(!feature_http2) if(!feature_http2)
return PARAM_LIBCURL_DOESNT_SUPPORT; return PARAM_LIBCURL_DOESNT_SUPPORT;
sethttpver(global, config, CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE); sethttpver(config, CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE);
break; break;
case C_HTTP3: /* --http3: */ case C_HTTP3: /* --http3: */
/* Try HTTP/3, allow fallback */ /* Try HTTP/3, allow fallback */
if(!feature_http3) if(!feature_http3)
return PARAM_LIBCURL_DOESNT_SUPPORT; return PARAM_LIBCURL_DOESNT_SUPPORT;
else else
sethttpver(global, config, CURL_HTTP_VERSION_3); sethttpver(config, CURL_HTTP_VERSION_3);
break; break;
case C_HTTP3_ONLY: /* --http3-only */ case C_HTTP3_ONLY: /* --http3-only */
/* Try HTTP/3 without fallback */ /* Try HTTP/3 without fallback */
if(!feature_http3) if(!feature_http3)
return PARAM_LIBCURL_DOESNT_SUPPORT; return PARAM_LIBCURL_DOESNT_SUPPORT;
else else
sethttpver(global, config, CURL_HTTP_VERSION_3ONLY); sethttpver(config, CURL_HTTP_VERSION_3ONLY);
break; break;
case C_TLSV1: /* --tlsv1 */ case C_TLSV1: /* --tlsv1 */
config->ssl_version = CURL_SSLVERSION_TLSv1; config->ssl_version = CURL_SSLVERSION_TLSv1;
@ -1771,11 +1762,11 @@ static ParameterError opt_none(struct GlobalConfig *global,
} }
/* opt_bool is the function that handles boolean options */ /* opt_bool is the function that handles boolean options */
static ParameterError opt_bool(struct GlobalConfig *global, static ParameterError opt_bool(struct OperationConfig *config,
struct OperationConfig *config,
const struct LongShort *a, const struct LongShort *a,
bool toggle) bool toggle)
{ {
struct GlobalConfig *global = config->global;
switch(a->cmd) { switch(a->cmd) {
case C_ALPN: /* --alpn */ case C_ALPN: /* --alpn */
config->noalpn = !toggle; config->noalpn = !toggle;
@ -2161,13 +2152,13 @@ static ParameterError opt_bool(struct GlobalConfig *global,
/* opt_filestring handles string and file options */ /* opt_filestring handles string and file options */
static ParameterError opt_filestring(struct GlobalConfig *global, static ParameterError opt_filestring(struct OperationConfig *config,
struct OperationConfig *config,
const struct LongShort *a, const struct LongShort *a,
const char *nextarg) const char *nextarg)
{ {
ParameterError err = PARAM_OK; ParameterError err = PARAM_OK;
curl_off_t value; curl_off_t value;
struct GlobalConfig *global = config->global;
static const char *redir_protos[] = { static const char *redir_protos[] = {
"http", "http",
"https", "https",
@ -2292,7 +2283,7 @@ static ParameterError opt_filestring(struct GlobalConfig *global,
config->max_filesize = value; config->max_filesize = value;
break; break;
case C_URL: /* --url */ case C_URL: /* --url */
err = parse_url(global, config, nextarg); err = parse_url(config, nextarg);
break; break;
case C_SOCKS5: /* --socks5 */ case C_SOCKS5: /* --socks5 */
/* socks5 proxy to use, and resolves the name locally and passes on the /* socks5 proxy to use, and resolves the name locally and passes on the
@ -2480,7 +2471,7 @@ static ParameterError opt_filestring(struct GlobalConfig *global,
err = getstr(&config->cookiejar, nextarg, DENY_BLANK); err = getstr(&config->cookiejar, nextarg, DENY_BLANK);
break; break;
case C_CONTINUE_AT: /* --continue-at */ case C_CONTINUE_AT: /* --continue-at */
err = parse_continue_at(global, config, nextarg); err = parse_continue_at(config, nextarg);
break; break;
case C_DATA: /* --data */ case C_DATA: /* --data */
case C_DATA_ASCII: /* --data-ascii */ case C_DATA_ASCII: /* --data-ascii */
@ -2488,10 +2479,10 @@ static ParameterError opt_filestring(struct GlobalConfig *global,
case C_DATA_URLENCODE: /* --data-urlencode */ case C_DATA_URLENCODE: /* --data-urlencode */
case C_JSON: /* --json */ case C_JSON: /* --json */
case C_DATA_RAW: /* --data-raw */ case C_DATA_RAW: /* --data-raw */
err = set_data((cmdline_t)a->cmd, nextarg, global, config); err = set_data((cmdline_t)a->cmd, nextarg, config);
break; break;
case C_URL_QUERY: /* --url-query */ case C_URL_QUERY: /* --url-query */
err = url_query(nextarg, global, config); err = url_query(nextarg, config);
break; break;
case C_DUMP_HEADER: /* --dump-header */ case C_DUMP_HEADER: /* --dump-header */
err = getstr(&config->headerfile, nextarg, DENY_BLANK); err = getstr(&config->headerfile, nextarg, DENY_BLANK);
@ -2540,7 +2531,7 @@ static ParameterError opt_filestring(struct GlobalConfig *global,
} }
break; break;
case C_ECH: /* --ech */ case C_ECH: /* --ech */
err = parse_ech(global, config, nextarg); err = parse_ech(config, nextarg);
break; break;
case C_CAPATH: /* --capath */ case C_CAPATH: /* --capath */
err = getstr(&config->capath, nextarg, DENY_BLANK); err = getstr(&config->capath, nextarg, DENY_BLANK);
@ -2690,7 +2681,7 @@ static ParameterError opt_filestring(struct GlobalConfig *global,
break; break;
case C_HEADER: /* --header */ case C_HEADER: /* --header */
case C_PROXY_HEADER: /* --proxy-header */ case C_PROXY_HEADER: /* --proxy-header */
err = parse_header(global, config, (cmdline_t)a->cmd, nextarg); err = parse_header(config, (cmdline_t)a->cmd, nextarg);
break; break;
case C_CONFIG: /* --config */ case C_CONFIG: /* --config */
if(parseconfig(nextarg, global)) { if(parseconfig(nextarg, global)) {
@ -2727,7 +2718,7 @@ static ParameterError opt_filestring(struct GlobalConfig *global,
err = parse_quote(config, nextarg); err = parse_quote(config, nextarg);
break; break;
case C_RANGE: /* --range */ case C_RANGE: /* --range */
err = parse_range(global, config, nextarg); err = parse_range(config, nextarg);
break; break;
case C_TELNET_OPTION: /* --telnet-option */ case C_TELNET_OPTION: /* --telnet-option */
/* Telnet options */ /* Telnet options */
@ -2745,7 +2736,7 @@ static ParameterError opt_filestring(struct GlobalConfig *global,
err = getstr(&config->proxyuserpwd, nextarg, ALLOW_BLANK); err = getstr(&config->proxyuserpwd, nextarg, ALLOW_BLANK);
break; break;
case C_WRITE_OUT: /* --write-out */ case C_WRITE_OUT: /* --write-out */
err = parse_writeout(global, config, nextarg); err = parse_writeout(config, nextarg);
break; break;
case C_PREPROXY: /* --preproxy */ case C_PREPROXY: /* --preproxy */
err = getstr(&config->preproxy, nextarg, DENY_BLANK); err = getstr(&config->preproxy, nextarg, DENY_BLANK);
@ -2786,7 +2777,7 @@ static ParameterError opt_filestring(struct GlobalConfig *global,
break; break;
} }
case C_TIME_COND: /* --time-cond */ case C_TIME_COND: /* --time-cond */
err = parse_time_cond(global, config, nextarg); err = parse_time_cond(config, nextarg);
break; break;
case C_UPLOAD_FLAGS: /* --upload-flags */ case C_UPLOAD_FLAGS: /* --upload-flags */
err = parse_upload_flags(config, nextarg); err = parse_upload_flags(config, nextarg);
@ -2799,7 +2790,6 @@ ParameterError getparameter(const char *flag, /* f or -long-flag */
const char *nextarg, /* NULL if unset */ const char *nextarg, /* NULL if unset */
bool *usedarg, /* set to TRUE if the arg bool *usedarg, /* set to TRUE if the arg
has been used */ has been used */
struct GlobalConfig *global,
struct OperationConfig *config) struct OperationConfig *config)
{ {
const char *parse = NULL; const char *parse = NULL;
@ -2810,6 +2800,7 @@ ParameterError getparameter(const char *flag, /* f or -long-flag */
by using --OPTION or --no-OPTION */ by using --OPTION or --no-OPTION */
bool nextalloc = FALSE; /* if nextarg is allocated */ bool nextalloc = FALSE; /* if nextarg is allocated */
const struct LongShort *a = NULL; const struct LongShort *a = NULL;
struct GlobalConfig *global = config->global;
verbose_nopts = 0; /* options processed in `flag`*/ verbose_nopts = 0; /* options processed in `flag`*/
*usedarg = FALSE; /* default is that we do not use the arg */ *usedarg = FALSE; /* default is that we do not use the arg */
@ -2921,7 +2912,7 @@ ParameterError getparameter(const char *flag, /* f or -long-flag */
nextarg); nextarg);
} }
/* ARG_FILE | ARG_STRG */ /* ARG_FILE | ARG_STRG */
err = opt_filestring(global, config, a, nextarg); err = opt_filestring(config, a, nextarg);
if(a->desc & ARG_CLEAR) if(a->desc & ARG_CLEAR)
cleanarg(CURL_UNCONST(nextarg)); cleanarg(CURL_UNCONST(nextarg));
} }
@ -2932,9 +2923,9 @@ ParameterError getparameter(const char *flag, /* f or -long-flag */
} }
/* ARG_NONE | ARG_BOOL */ /* ARG_NONE | ARG_BOOL */
if(ARGTYPE(a->desc) == ARG_BOOL) if(ARGTYPE(a->desc) == ARG_BOOL)
err = opt_bool(global, config, a, toggle); err = opt_bool(config, a, toggle);
else else
err = opt_none(global, config, a); err = opt_none(config, a);
} }
++verbose_nopts; /* processed one option from `flag` input, loop for ++verbose_nopts; /* processed one option from `flag` input, loop for
@ -2978,7 +2969,7 @@ ParameterError parse_args(struct GlobalConfig *global, int argc,
} }
} }
result = getparameter(orig_opt, nextarg, &passarg, global, config); result = getparameter(orig_opt, nextarg, &passarg, config);
unicodefree(nextarg); unicodefree(nextarg);
config = global->last; config = global->last;
@ -3014,7 +3005,7 @@ ParameterError parse_args(struct GlobalConfig *global, int argc,
bool used; bool used;
/* Just add the URL please */ /* Just add the URL please */
result = getparameter("--url", orig_opt, &used, global, config); result = getparameter("--url", orig_opt, &used, config);
} }
if(!result) { if(!result) {

3
src/tool_getparam.h
View File

@ -365,8 +365,7 @@ const struct LongShort *findshortopt(char letter);
ParameterError getparameter(const char *flag, const char *nextarg, ParameterError getparameter(const char *flag, const char *nextarg,
bool *usedarg, bool *usedarg,
struct GlobalConfig *global, struct OperationConfig *config);
struct OperationConfig *operation);
#ifdef UNITTESTS #ifdef UNITTESTS
void parse_cert_parameter(const char *cert_parameter, void parse_cert_parameter(const char *cert_parameter,

74
src/tool_operate.c
View File

@ -110,8 +110,7 @@ extern const unsigned char curl_ca_embed[];
"this situation and\nhow to fix it, please visit the webpage mentioned " \ "this situation and\nhow to fix it, please visit the webpage mentioned " \
"above.\n" "above.\n"
static CURLcode single_transfer(struct GlobalConfig *global, static CURLcode single_transfer(struct OperationConfig *config,
struct OperationConfig *config,
CURLSH *share, CURLSH *share,
bool *added, bool *added,
bool *skipped); bool *skipped);
@ -273,6 +272,8 @@ static CURLcode pre_transfer(struct GlobalConfig *global,
CURLcode result = CURLE_OK; CURLcode result = CURLE_OK;
#ifdef CURL_DISABLE_LIBCURL_OPTION #ifdef CURL_DISABLE_LIBCURL_OPTION
(void)global; /* otherwise used in the my_setopt macros */ (void)global; /* otherwise used in the my_setopt macros */
#else
struct OperationConfig *config = global->current;
#endif #endif
if(per->uploadfile && !stdin_upload(per->uploadfile)) { if(per->uploadfile && !stdin_upload(per->uploadfile)) {
@ -772,8 +773,7 @@ static CURLcode set_cert_types(struct OperationConfig *config)
return CURLE_OK; return CURLE_OK;
} }
static CURLcode append2query(struct GlobalConfig *global, static CURLcode append2query(struct OperationConfig *config,
struct OperationConfig *config,
struct per_transfer *per, struct per_transfer *per,
const char *q) const char *q)
{ {
@ -785,7 +785,7 @@ static CURLcode append2query(struct GlobalConfig *global,
CURLU_GUESS_SCHEME); CURLU_GUESS_SCHEME);
if(uerr) { if(uerr) {
result = urlerr_cvt(uerr); result = urlerr_cvt(uerr);
errorf(global, "(%d) Could not parse the URL, " errorf(config->global, "(%d) Could not parse the URL, "
"failed to set query", result); "failed to set query", result);
config->synthetic_error = TRUE; config->synthetic_error = TRUE;
} }
@ -807,8 +807,7 @@ static CURLcode append2query(struct GlobalConfig *global,
return result; return result;
} }
static CURLcode etag_compare(struct GlobalConfig *global, static CURLcode etag_compare(struct OperationConfig *config)
struct OperationConfig *config)
{ {
CURLcode result = CURLE_OK; CURLcode result = CURLE_OK;
char *etag_from_file = NULL; char *etag_from_file = NULL;
@ -818,7 +817,7 @@ static CURLcode etag_compare(struct GlobalConfig *global,
/* open file for reading: */ /* open file for reading: */
FILE *file = fopen(config->etag_compare_file, FOPEN_READTEXT); FILE *file = fopen(config->etag_compare_file, FOPEN_READTEXT);
if(!file) if(!file)
warnf(global, "Failed to open %s: %s", config->etag_compare_file, warnf(config->global, "Failed to open %s: %s", config->etag_compare_file,
strerror(errno)); strerror(errno));
if((PARAM_OK == file2string(&etag_from_file, file)) && if((PARAM_OK == file2string(&etag_from_file, file)) &&
@ -832,7 +831,7 @@ static CURLcode etag_compare(struct GlobalConfig *global,
if(!header) { if(!header) {
if(file) if(file)
fclose(file); fclose(file);
errorf(global, errorf(config->global,
"Failed to allocate memory for custom etag header"); "Failed to allocate memory for custom etag header");
return CURLE_OUT_OF_MEMORY; return CURLE_OUT_OF_MEMORY;
} }
@ -848,13 +847,13 @@ static CURLcode etag_compare(struct GlobalConfig *global,
return result; return result;
} }
static CURLcode etag_store(struct GlobalConfig *global, static CURLcode etag_store(struct OperationConfig *config,
struct OperationConfig *config,
struct OutStruct *etag_save, struct OutStruct *etag_save,
bool *skip) bool *skip)
{ {
if(config->create_dirs) { if(config->create_dirs) {
CURLcode result = create_dir_hierarchy(config->etag_save_file, global); CURLcode result = create_dir_hierarchy(config->etag_save_file,
config->global);
if(result) if(result)
return result; return result;
} }
@ -864,7 +863,7 @@ static CURLcode etag_store(struct GlobalConfig *global,
FILE *newfile = fopen(config->etag_save_file, "ab"); FILE *newfile = fopen(config->etag_save_file, "ab");
if(!newfile) { if(!newfile) {
struct State *state = &config->state; struct State *state = &config->state;
warnf(global, "Failed creating file for saving etags: \"%s\". " warnf(config->global, "Failed creating file for saving etags: \"%s\". "
"Skip this transfer", config->etag_save_file); "Skip this transfer", config->etag_save_file);
tool_safefree(state->outfiles); tool_safefree(state->outfiles);
glob_cleanup(&state->urls); glob_cleanup(&state->urls);
@ -885,8 +884,7 @@ static CURLcode etag_store(struct GlobalConfig *global,
return CURLE_OK; return CURLE_OK;
} }
static CURLcode setup_headerfile(struct GlobalConfig *global, static CURLcode setup_headerfile(struct OperationConfig *config,
struct OperationConfig *config,
struct per_transfer *per, struct per_transfer *per,
struct OutStruct *heads) struct OutStruct *heads)
{ {
@ -909,7 +907,8 @@ static CURLcode setup_headerfile(struct GlobalConfig *global,
* that it does not need to be opened/closed for every transfer. * that it does not need to be opened/closed for every transfer.
*/ */
if(config->create_dirs) { if(config->create_dirs) {
CURLcode result = create_dir_hierarchy(config->headerfile, global); CURLcode result = create_dir_hierarchy(config->headerfile,
config->global);
/* create_dir_hierarchy shows error upon CURLE_WRITE_ERROR */ /* create_dir_hierarchy shows error upon CURLE_WRITE_ERROR */
if(result) if(result)
return result; return result;
@ -922,7 +921,7 @@ static CURLcode setup_headerfile(struct GlobalConfig *global,
newfile = fopen(config->headerfile, "ab"); newfile = fopen(config->headerfile, "ab");
if(!newfile) { if(!newfile) {
errorf(global, "Failed to open %s", config->headerfile); errorf(config->global, "Failed to open %s", config->headerfile);
return CURLE_WRITE_ERROR; return CURLE_WRITE_ERROR;
} }
else { else {
@ -939,8 +938,7 @@ static CURLcode setup_headerfile(struct GlobalConfig *global,
return CURLE_OK; return CURLE_OK;
} }
static CURLcode setup_outfile(struct GlobalConfig *global, static CURLcode setup_outfile(struct OperationConfig *config,
struct OperationConfig *config,
struct per_transfer *per, struct per_transfer *per,
struct OutStruct *outs, struct OutStruct *outs,
bool *skipped) bool *skipped)
@ -950,6 +948,7 @@ static CURLcode setup_outfile(struct GlobalConfig *global,
* decided we want to use the remote filename. * decided we want to use the remote filename.
*/ */
struct State *state = &config->state; struct State *state = &config->state;
struct GlobalConfig *global = config->global;
if(!per->outfile) { if(!per->outfile) {
/* extract the filename from the URL */ /* extract the filename from the URL */
@ -1044,10 +1043,10 @@ static CURLcode setup_outfile(struct GlobalConfig *global,
return CURLE_OK; return CURLE_OK;
} }
static void check_stdin_upload(struct GlobalConfig *global, static void check_stdin_upload(struct OperationConfig *config,
struct OperationConfig *config,
struct per_transfer *per) struct per_transfer *per)
{ {
struct GlobalConfig *global = config->global;
/* count to see if there are more than one auth bit set /* count to see if there are more than one auth bit set
in the authtype field */ in the authtype field */
int authbits = 0; int authbits = 0;
@ -1105,14 +1104,14 @@ static void check_stdin_upload(struct GlobalConfig *global,
} }
/* create the next (singular) transfer */ /* create the next (singular) transfer */
static CURLcode single_transfer(struct GlobalConfig *global, static CURLcode single_transfer(struct OperationConfig *config,
struct OperationConfig *config,
CURLSH *share, CURLSH *share,
bool *added, bool *added,
bool *skipped) bool *skipped)
{ {
CURLcode result = CURLE_OK; CURLcode result = CURLE_OK;
struct getout *urlnode; struct getout *urlnode;
struct GlobalConfig *global = config->global;
bool orig_noprogress = global->noprogress; bool orig_noprogress = global->noprogress;
bool orig_isatty = global->isatty; bool orig_isatty = global->isatty;
struct State *state = &config->state; struct State *state = &config->state;
@ -1239,14 +1238,14 @@ static CURLcode single_transfer(struct GlobalConfig *global,
/* --etag-compare */ /* --etag-compare */
if(config->etag_compare_file) { if(config->etag_compare_file) {
result = etag_compare(global, config); result = etag_compare(config);
if(result) if(result)
break; break;
} }
if(config->etag_save_file) { if(config->etag_save_file) {
bool badetag = FALSE; bool badetag = FALSE;
result = etag_store(global, config, etag_save, &badetag); result = etag_store(config, etag_save, &badetag);
if(result || badetag) if(result || badetag)
break; break;
} }
@ -1288,7 +1287,7 @@ static CURLcode single_transfer(struct GlobalConfig *global,
/* Single header file for all URLs */ /* Single header file for all URLs */
if(config->headerfile) { if(config->headerfile) {
result = setup_headerfile(global, config, per, heads); result = setup_headerfile(config, per, heads);
if(result) if(result)
break; break;
} }
@ -1330,7 +1329,7 @@ static CURLcode single_transfer(struct GlobalConfig *global,
if((urlnode->useremote || if((urlnode->useremote ||
(per->outfile && strcmp("-", per->outfile)))) { (per->outfile && strcmp("-", per->outfile)))) {
result = setup_outfile(global, config, per, outs, skipped); result = setup_outfile(config, per, outs, skipped);
if(result) if(result)
break; break;
} }
@ -1338,7 +1337,7 @@ static CURLcode single_transfer(struct GlobalConfig *global,
if(per->uploadfile) { if(per->uploadfile) {
if(stdin_upload(per->uploadfile)) if(stdin_upload(per->uploadfile))
check_stdin_upload(global, config, per); check_stdin_upload(config, per);
else { else {
/* /*
* We have specified a file to upload and it is not "-". * We have specified a file to upload and it is not "-".
@ -1366,7 +1365,7 @@ static CURLcode single_transfer(struct GlobalConfig *global,
} }
if(httpgetfields || config->query) { if(httpgetfields || config->query) {
result = append2query(global, config, per, result = append2query(config, per,
httpgetfields ? httpgetfields : config->query); httpgetfields ? httpgetfields : config->query);
if(result) if(result)
break; break;
@ -1394,7 +1393,7 @@ static CURLcode single_transfer(struct GlobalConfig *global,
hdrcbdata->global = global; hdrcbdata->global = global;
hdrcbdata->config = config; hdrcbdata->config = config;
result = config2setopts(global, config, per, curl, share); result = config2setopts(config, per, curl, share);
if(result) if(result)
break; break;
@ -1847,7 +1846,8 @@ static CURLcode check_finished(struct parastate *s)
} }
if(checkmore) { if(checkmore) {
/* one or more transfers completed, add more! */ /* one or more transfers completed, add more! */
CURLcode tres = add_parallel_transfers(global, s->multi, s->share, CURLcode tres = add_parallel_transfers(global,
s->multi, s->share,
&s->more_transfers, &s->more_transfers,
&s->added_transfers); &s->added_transfers);
if(tres) if(tres)
@ -2132,8 +2132,7 @@ fail:
} }
/* setup a transfer for the given config */ /* setup a transfer for the given config */
static CURLcode transfer_per_config(struct GlobalConfig *global, static CURLcode transfer_per_config(struct OperationConfig *config,
struct OperationConfig *config,
CURLSH *share, CURLSH *share,
bool *added, bool *added,
bool *skipped) bool *skipped)
@ -2173,7 +2172,7 @@ static CURLcode transfer_per_config(struct GlobalConfig *global,
} }
if(!result) if(!result)
result = single_transfer(global, config, share, added, skipped); result = single_transfer(config, share, added, skipped);
return result; return result;
} }
@ -2190,8 +2189,7 @@ static CURLcode create_transfer(struct GlobalConfig *global,
CURLcode result = CURLE_OK; CURLcode result = CURLE_OK;
*added = FALSE; *added = FALSE;
while(global->current) { while(global->current) {
result = transfer_per_config(global, global->current, share, added, result = transfer_per_config(global->current, share, added, skipped);
skipped);
if(!result && !*added) { if(!result && !*added) {
/* when one set is drained, continue to next */ /* when one set is drained, continue to next */
global->current = global->current->next; global->current = global->current->next;
@ -2341,7 +2339,7 @@ CURLcode operate(struct GlobalConfig *global, int argc, argv_item_t argv[])
curl_share_setopt(share, CURLSHOPT_SHARE, CURL_LOCK_DATA_HSTS); curl_share_setopt(share, CURLSHOPT_SHARE, CURL_LOCK_DATA_HSTS);
if(global->ssl_sessions && feature_ssls_export) if(global->ssl_sessions && feature_ssls_export)
result = tool_ssls_load(global, global->first, share, result = tool_ssls_load(global->first, share,
global->ssl_sessions); global->ssl_sessions);
if(!result) { if(!result) {
@ -2359,7 +2357,7 @@ CURLcode operate(struct GlobalConfig *global, int argc, argv_item_t argv[])
result = run_all_transfers(global, share, result); result = run_all_transfers(global, share, result);
if(global->ssl_sessions && feature_ssls_export) { if(global->ssl_sessions && feature_ssls_export) {
CURLcode r2 = tool_ssls_save(global, global->first, share, CURLcode r2 = tool_ssls_save(global->first, share,
global->ssl_sessions); global->ssl_sessions);
if(r2 && !result) if(r2 && !result)
result = r2; result = r2;

24
src/tool_parsecfg.c
View File

@ -46,7 +46,7 @@ int parseconfig(const char *filename, struct GlobalConfig *global)
FILE *file = NULL; FILE *file = NULL;
bool usedarg = FALSE; bool usedarg = FALSE;
int rc = 0; int rc = 0;
struct OperationConfig *operation = global->last; struct OperationConfig *config = global->last;
char *pathalloc = NULL; char *pathalloc = NULL;
if(!filename) { if(!filename) {
@ -156,9 +156,9 @@ int parseconfig(const char *filename, struct GlobalConfig *global)
case '#': /* comment */ case '#': /* comment */
break; break;
default: default:
warnf(operation->global, "%s:%d: warning: '%s' uses unquoted " warnf(config->global, "%s:%d: warning: '%s' uses unquoted "
"whitespace", filename, lineno, option); "whitespace", filename, lineno, option);
warnf(operation->global, "This may cause side-effects. " warnf(config->global, "This may cause side-effects. "
"Consider using double quotes?"); "Consider using double quotes?");
} }
} }
@ -171,24 +171,24 @@ int parseconfig(const char *filename, struct GlobalConfig *global)
#ifdef DEBUG_CONFIG #ifdef DEBUG_CONFIG
fprintf(tool_stderr, "PARAM: \"%s\"\n",(param ? param : "(null)")); fprintf(tool_stderr, "PARAM: \"%s\"\n",(param ? param : "(null)"));
#endif #endif
res = getparameter(option, param, &usedarg, global, operation); res = getparameter(option, param, &usedarg, config);
operation = global->last; config = global->last;
if(!res && param && *param && !usedarg) if(!res && param && *param && !usedarg)
/* we passed in a parameter that was not used! */ /* we passed in a parameter that was not used! */
res = PARAM_GOT_EXTRA_PARAMETER; res = PARAM_GOT_EXTRA_PARAMETER;
if(res == PARAM_NEXT_OPERATION) { if(res == PARAM_NEXT_OPERATION) {
if(operation->url_list && operation->url_list->url) { if(config->url_list && config->url_list->url) {
/* Allocate the next config */ /* Allocate the next config */
operation->next = config_alloc(global); config->next = config_alloc(global);
if(operation->next) { if(config->next) {
/* Update the last operation pointer */ /* Update the last operation pointer */
global->last = operation->next; global->last = config->next;
/* Move onto the new config */ /* Move onto the new config */
operation->next->prev = operation; config->next->prev = config;
operation = operation->next; config = config->next;
} }
else else
res = PARAM_NO_MEM; res = PARAM_NO_MEM;
@ -206,7 +206,7 @@ int parseconfig(const char *filename, struct GlobalConfig *global)
res != PARAM_ENGINES_REQUESTED && res != PARAM_ENGINES_REQUESTED &&
res != PARAM_CA_EMBED_REQUESTED) { res != PARAM_CA_EMBED_REQUESTED) {
const char *reason = param2text(res); const char *reason = param2text(res);
errorf(operation->global, "%s:%d: '%s' %s", errorf(config->global, "%s:%d: '%s' %s",
filename, lineno, option, reason); filename, lineno, option, reason);
rc = (int)res; rc = (int)res;
} }

52
src/tool_setopt.c
View File

@ -223,7 +223,7 @@ static char *c_escape(const char *str, curl_off_t len)
} }
/* setopt wrapper for enum types */ /* setopt wrapper for enum types */
CURLcode tool_setopt_enum(CURL *curl, struct GlobalConfig *global, CURLcode tool_setopt_enum(CURL *curl, struct OperationConfig *config,
const char *name, CURLoption tag, const char *name, CURLoption tag,
const struct NameValue *nvlist, long lval) const struct NameValue *nvlist, long lval)
{ {
@ -234,7 +234,7 @@ CURLcode tool_setopt_enum(CURL *curl, struct GlobalConfig *global,
if(!lval) if(!lval)
skip = TRUE; skip = TRUE;
if(global->libcurl && !skip && !ret) { if(config->global->libcurl && !skip && !ret) {
/* we only use this for real if --libcurl was used */ /* we only use this for real if --libcurl was used */
const struct NameValue *nv = NULL; const struct NameValue *nv = NULL;
for(nv = nvlist; nv->name; nv++) { for(nv = nvlist; nv->name; nv++) {
@ -256,13 +256,13 @@ CURLcode tool_setopt_enum(CURL *curl, struct GlobalConfig *global,
#ifdef DEBUGBUILD #ifdef DEBUGBUILD
if(ret) if(ret)
warnf(global, "option %s returned error (%d)", name, (int)ret); warnf(config->global, "option %s returned error (%d)", name, (int)ret);
#endif #endif
return ret; return ret;
} }
/* setopt wrapper for CURLOPT_SSLVERSION */ /* setopt wrapper for CURLOPT_SSLVERSION */
CURLcode tool_setopt_SSLVERSION(CURL *curl, struct GlobalConfig *global, CURLcode tool_setopt_SSLVERSION(CURL *curl, struct OperationConfig *config,
const char *name, CURLoption tag, const char *name, CURLoption tag,
long lval) long lval)
{ {
@ -273,7 +273,7 @@ CURLcode tool_setopt_SSLVERSION(CURL *curl, struct GlobalConfig *global,
if(!lval) if(!lval)
skip = TRUE; skip = TRUE;
if(global->libcurl && !skip && !ret) { if(config->global->libcurl && !skip && !ret) {
/* we only use this for real if --libcurl was used */ /* we only use this for real if --libcurl was used */
const struct NameValue *nv = NULL; const struct NameValue *nv = NULL;
const struct NameValue *nv2 = NULL; const struct NameValue *nv2 = NULL;
@ -301,13 +301,13 @@ CURLcode tool_setopt_SSLVERSION(CURL *curl, struct GlobalConfig *global,
#ifdef DEBUGBUILD #ifdef DEBUGBUILD
if(ret) if(ret)
warnf(global, "option %s returned error (%d)", name, (int)ret); warnf(config->global, "option %s returned error (%d)", name, (int)ret);
#endif #endif
return ret; return ret;
} }
/* setopt wrapper for bitmasks */ /* setopt wrapper for bitmasks */
CURLcode tool_setopt_bitmask(CURL *curl, struct GlobalConfig *global, CURLcode tool_setopt_bitmask(CURL *curl, struct OperationConfig *config,
const char *name, CURLoption tag, const char *name, CURLoption tag,
const struct NameValueUnsigned *nvlist, const struct NameValueUnsigned *nvlist,
long lval) long lval)
@ -317,7 +317,7 @@ CURLcode tool_setopt_bitmask(CURL *curl, struct GlobalConfig *global,
if(!lval) if(!lval)
skip = TRUE; skip = TRUE;
if(global->libcurl && !skip && !ret) { if(config->global->libcurl && !skip && !ret) {
/* we only use this for real if --libcurl was used */ /* we only use this for real if --libcurl was used */
char preamble[80]; char preamble[80];
unsigned long rest = (unsigned long)lval; unsigned long rest = (unsigned long)lval;
@ -379,13 +379,13 @@ static CURLcode libcurl_generate_slist(struct curl_slist *slist, int *slistno)
} }
static CURLcode libcurl_generate_mime(CURL *curl, static CURLcode libcurl_generate_mime(CURL *curl,
struct GlobalConfig *global, struct OperationConfig *config,
struct tool_mime *toolmime, struct tool_mime *toolmime,
int *mimeno); /* Forward. */ int *mimeno); /* Forward. */
/* Wrapper to generate source code for a mime part. */ /* Wrapper to generate source code for a mime part. */
static CURLcode libcurl_generate_mime_part(CURL *curl, static CURLcode libcurl_generate_mime_part(CURL *curl,
struct GlobalConfig *global, struct OperationConfig *config,
struct tool_mime *part, struct tool_mime *part,
int mimeno) int mimeno)
{ {
@ -396,7 +396,7 @@ static CURLcode libcurl_generate_mime_part(CURL *curl,
/* Parts are linked in reverse order. */ /* Parts are linked in reverse order. */
if(part->prev) if(part->prev)
ret = libcurl_generate_mime_part(curl, global, part->prev, mimeno); ret = libcurl_generate_mime_part(curl, config, part->prev, mimeno);
/* Create the part. */ /* Create the part. */
if(!ret) if(!ret)
@ -407,7 +407,7 @@ static CURLcode libcurl_generate_mime_part(CURL *curl,
switch(part->kind) { switch(part->kind) {
case TOOLMIME_PARTS: case TOOLMIME_PARTS:
ret = libcurl_generate_mime(curl, global, part, &submimeno); ret = libcurl_generate_mime(curl, config, part, &submimeno);
if(!ret) { if(!ret) {
ret = easysrc_addf(&easysrc_code, "curl_mime_subparts(part%d, mime%d);", ret = easysrc_addf(&easysrc_code, "curl_mime_subparts(part%d, mime%d);",
mimeno, submimeno); mimeno, submimeno);
@ -507,7 +507,7 @@ static CURLcode libcurl_generate_mime_part(CURL *curl,
/* Wrapper to generate source code for a mime structure. */ /* Wrapper to generate source code for a mime structure. */
static CURLcode libcurl_generate_mime(CURL *curl, static CURLcode libcurl_generate_mime(CURL *curl,
struct GlobalConfig *global, struct OperationConfig *config,
struct tool_mime *toolmime, struct tool_mime *toolmime,
int *mimeno) int *mimeno)
{ {
@ -529,7 +529,7 @@ static CURLcode libcurl_generate_mime(CURL *curl,
if(toolmime->subparts && !ret) { if(toolmime->subparts && !ret) {
ret = easysrc_addf(&easysrc_decl, "curl_mimepart *part%d;", *mimeno); ret = easysrc_addf(&easysrc_decl, "curl_mimepart *part%d;", *mimeno);
if(!ret) if(!ret)
ret = libcurl_generate_mime_part(curl, global, ret = libcurl_generate_mime_part(curl, config,
toolmime->subparts, *mimeno); toolmime->subparts, *mimeno);
} }
@ -537,16 +537,15 @@ static CURLcode libcurl_generate_mime(CURL *curl,
} }
/* setopt wrapper for CURLOPT_MIMEPOST */ /* setopt wrapper for CURLOPT_MIMEPOST */
CURLcode tool_setopt_mimepost(CURL *curl, struct GlobalConfig *global, CURLcode tool_setopt_mimepost(CURL *curl, struct OperationConfig *config,
const char *name, CURLoption tag, const char *name, CURLoption tag,
curl_mime *mimepost) curl_mime *mimepost)
{ {
CURLcode ret = curl_easy_setopt(curl, tag, mimepost); CURLcode ret = curl_easy_setopt(curl, tag, mimepost);
int mimeno = 0; int mimeno = 0;
if(!ret && global->libcurl) { if(!ret && config->global->libcurl) {
ret = libcurl_generate_mime(curl, global, ret = libcurl_generate_mime(curl, config, config->mimeroot, &mimeno);
global->current->mimeroot, &mimeno);
if(!ret) if(!ret)
ret = easysrc_addf(&easysrc_code, "curl_easy_setopt(hnd, %s, mime%d);", ret = easysrc_addf(&easysrc_code, "curl_easy_setopt(hnd, %s, mime%d);",
@ -557,7 +556,7 @@ CURLcode tool_setopt_mimepost(CURL *curl, struct GlobalConfig *global,
} }
/* setopt wrapper for curl_slist options */ /* setopt wrapper for curl_slist options */
CURLcode tool_setopt_slist(CURL *curl, struct GlobalConfig *global, CURLcode tool_setopt_slist(CURL *curl, struct OperationConfig *config,
const char *name, CURLoption tag, const char *name, CURLoption tag,
struct curl_slist *list) struct curl_slist *list)
{ {
@ -565,7 +564,7 @@ CURLcode tool_setopt_slist(CURL *curl, struct GlobalConfig *global,
ret = curl_easy_setopt(curl, tag, list); ret = curl_easy_setopt(curl, tag, list);
if(global->libcurl && list && !ret) { if(config->global->libcurl && list && !ret) {
int i; int i;
ret = libcurl_generate_slist(list, &i); ret = libcurl_generate_slist(list, &i);
@ -578,7 +577,7 @@ CURLcode tool_setopt_slist(CURL *curl, struct GlobalConfig *global,
} }
/* options that set long */ /* options that set long */
CURLcode tool_setopt_long(CURL *curl, struct GlobalConfig *global, CURLcode tool_setopt_long(CURL *curl, struct OperationConfig *config,
const char *name, CURLoption tag, const char *name, CURLoption tag,
long lval) long lval)
{ {
@ -595,7 +594,7 @@ CURLcode tool_setopt_long(CURL *curl, struct GlobalConfig *global,
} }
ret = curl_easy_setopt(curl, tag, lval); ret = curl_easy_setopt(curl, tag, lval);
if((lval != defval) && global->libcurl && !ret) { if((lval != defval) && config->global->libcurl && !ret) {
/* we only use this for real if --libcurl was used */ /* we only use this for real if --libcurl was used */
ret = easysrc_addf(&easysrc_code, "curl_easy_setopt(hnd, %s, %ldL);", ret = easysrc_addf(&easysrc_code, "curl_easy_setopt(hnd, %s, %ldL);",
name, lval); name, lval);
@ -604,7 +603,7 @@ CURLcode tool_setopt_long(CURL *curl, struct GlobalConfig *global,
} }
/* options that set curl_off_t */ /* options that set curl_off_t */
CURLcode tool_setopt_offt(CURL *curl, struct GlobalConfig *global, CURLcode tool_setopt_offt(CURL *curl, struct OperationConfig *config,
const char *name, CURLoption tag, const char *name, CURLoption tag,
curl_off_t lval) curl_off_t lval)
{ {
@ -612,7 +611,7 @@ CURLcode tool_setopt_offt(CURL *curl, struct GlobalConfig *global,
DEBUGASSERT((tag >= CURLOPTTYPE_OFF_T) && (tag < CURLOPTTYPE_BLOB)); DEBUGASSERT((tag >= CURLOPTTYPE_OFF_T) && (tag < CURLOPTTYPE_BLOB));
ret = curl_easy_setopt(curl, tag, lval); ret = curl_easy_setopt(curl, tag, lval);
if(global->libcurl && !ret && lval) { if(config->global->libcurl && !ret && lval) {
/* we only use this for real if --libcurl was used */ /* we only use this for real if --libcurl was used */
ret = easysrc_addf(&easysrc_code, "curl_easy_setopt(hnd, %s, (curl_off_t)%" ret = easysrc_addf(&easysrc_code, "curl_easy_setopt(hnd, %s, (curl_off_t)%"
CURL_FORMAT_CURL_OFF_T ");", name, lval); CURL_FORMAT_CURL_OFF_T ");", name, lval);
@ -622,8 +621,7 @@ CURLcode tool_setopt_offt(CURL *curl, struct GlobalConfig *global,
} }
/* setopt wrapper for setting object and function pointer options */ /* setopt wrapper for setting object and function pointer options */
CURLcode tool_setopt(CURL *curl, bool str, struct GlobalConfig *global, CURLcode tool_setopt(CURL *curl, bool str, struct OperationConfig *config,
struct OperationConfig *config,
const char *name, CURLoption tag, ...) const char *name, CURLoption tag, ...)
{ {
va_list arg; va_list arg;
@ -645,7 +643,7 @@ CURLcode tool_setopt(CURL *curl, bool str, struct GlobalConfig *global,
va_end(arg); va_end(arg);
if(global->libcurl && pval && !ret) { if(config->global->libcurl && pval && !ret) {
/* we only use this if --libcurl was used */ /* we only use this if --libcurl was used */
if(!str) { if(!str) {

36
src/tool_setopt.h
View File

@ -75,60 +75,60 @@ extern const struct NameValueUnsigned setopt_nv_CURLHSTS[];
/* Intercept setopt calls for --libcurl */ /* Intercept setopt calls for --libcurl */
CURLcode tool_setopt_enum(CURL *curl, struct GlobalConfig *global, CURLcode tool_setopt_enum(CURL *curl, struct OperationConfig *config,
const char *name, CURLoption tag, const char *name, CURLoption tag,
const struct NameValue *nv, long lval); const struct NameValue *nv, long lval);
CURLcode tool_setopt_SSLVERSION(CURL *curl, struct GlobalConfig *global, CURLcode tool_setopt_SSLVERSION(CURL *curl, struct OperationConfig *config,
const char *name, CURLoption tag, const char *name, CURLoption tag,
long lval); long lval);
CURLcode tool_setopt_flags(CURL *curl, struct GlobalConfig *global, CURLcode tool_setopt_flags(CURL *curl, struct OperationConfig *config,
const char *name, CURLoption tag, const char *name, CURLoption tag,
const struct NameValue *nv, long lval); const struct NameValue *nv, long lval);
CURLcode tool_setopt_bitmask(CURL *curl, struct GlobalConfig *global, CURLcode tool_setopt_bitmask(CURL *curl, struct OperationConfig *config,
const char *name, CURLoption tag, const char *name, CURLoption tag,
const struct NameValueUnsigned *nv, long lval); const struct NameValueUnsigned *nv, long lval);
CURLcode tool_setopt_mimepost(CURL *curl, struct GlobalConfig *global, CURLcode tool_setopt_mimepost(CURL *curl, struct OperationConfig *config,
const char *name, CURLoption tag, const char *name, CURLoption tag,
curl_mime *mimepost); curl_mime *mimepost);
CURLcode tool_setopt_slist(CURL *curl, struct GlobalConfig *global, CURLcode tool_setopt_slist(CURL *curl, struct OperationConfig *config,
const char *name, CURLoption tag, const char *name, CURLoption tag,
struct curl_slist *list); struct curl_slist *list);
CURLcode tool_setopt_long(CURL *curl, struct GlobalConfig *global, CURLcode tool_setopt_long(CURL *curl, struct OperationConfig *config,
const char *name, CURLoption tag, const char *name, CURLoption tag,
long lval); long lval);
CURLcode tool_setopt_offt(CURL *curl, struct GlobalConfig *global, CURLcode tool_setopt_offt(CURL *curl, struct OperationConfig *config,
const char *name, CURLoption tag, const char *name, CURLoption tag,
curl_off_t lval); curl_off_t lval);
CURLcode tool_setopt(CURL *curl, bool str, struct GlobalConfig *global, CURLcode tool_setopt(CURL *curl, bool str,
struct OperationConfig *config, struct OperationConfig *config,
const char *name, CURLoption tag, ...); const char *name, CURLoption tag, ...);
#define my_setopt(x,y,z) \ #define my_setopt(x,y,z) \
tool_setopt(x, FALSE, global, config, #y, y, z) tool_setopt(x, FALSE, config, #y, y, z)
#define my_setopt_long(x,y,z) \ #define my_setopt_long(x,y,z) \
tool_setopt_long(x, global, #y, y, z) tool_setopt_long(x, config, #y, y, z)
#define my_setopt_offt(x,y,z) \ #define my_setopt_offt(x,y,z) \
tool_setopt_offt(x, global, #y, y, z) tool_setopt_offt(x, config, #y, y, z)
#define my_setopt_str(x,y,z) \ #define my_setopt_str(x,y,z) \
tool_setopt(x, TRUE, global, config, #y, y, z) tool_setopt(x, TRUE, config, #y, y, z)
#define my_setopt_enum(x,y,z) \ #define my_setopt_enum(x,y,z) \
tool_setopt_enum(x, global, #y, y, setopt_nv_ ## y, z) tool_setopt_enum(x, config, #y, y, setopt_nv_ ## y, z)
#define my_setopt_SSLVERSION(x,y,z) \ #define my_setopt_SSLVERSION(x,y,z) \
tool_setopt_SSLVERSION(x, global, #y, y, z) tool_setopt_SSLVERSION(x, config, #y, y, z)
#define my_setopt_bitmask(x,y,z) \ #define my_setopt_bitmask(x,y,z) \
tool_setopt_bitmask(x, global, #y, y, setopt_nv_ ## y, z) tool_setopt_bitmask(x, config, #y, y, setopt_nv_ ## y, z)
#define my_setopt_mimepost(x,y,z) \ #define my_setopt_mimepost(x,y,z) \
tool_setopt_mimepost(x, global, #y, y, z) tool_setopt_mimepost(x, config, #y, y, z)
#define my_setopt_slist(x,y,z) \ #define my_setopt_slist(x,y,z) \
tool_setopt_slist(x, global, #y, y, z) tool_setopt_slist(x, config, #y, y, z)
#else /* CURL_DISABLE_LIBCURL_OPTION */ #else /* CURL_DISABLE_LIBCURL_OPTION */

20
src/tool_ssls.c
View File

@ -34,11 +34,11 @@
#define MAX_SSLS_LINE (64 * 1024) #define MAX_SSLS_LINE (64 * 1024)
static CURLcode tool_ssls_easy(struct GlobalConfig *global, static CURLcode tool_ssls_easy(struct OperationConfig *config,
struct OperationConfig *config,
CURLSH *share, CURL **peasy) CURLSH *share, CURL **peasy)
{ {
CURLcode result = CURLE_OK; CURLcode result = CURLE_OK;
struct GlobalConfig *global = config->global;
*peasy = curl_easy_init(); *peasy = curl_easy_init();
if(!*peasy) if(!*peasy)
@ -53,8 +53,7 @@ static CURLcode tool_ssls_easy(struct GlobalConfig *global,
return result; return result;
} }
CURLcode tool_ssls_load(struct GlobalConfig *global, CURLcode tool_ssls_load(struct OperationConfig *config,
struct OperationConfig *config,
CURLSH *share, const char *filename) CURLSH *share, const char *filename)
{ {
FILE *fp; FILE *fp;
@ -66,6 +65,7 @@ CURLcode tool_ssls_load(struct GlobalConfig *global,
CURLcode r = CURLE_OK; CURLcode r = CURLE_OK;
int i, imported; int i, imported;
bool error = FALSE; bool error = FALSE;
struct GlobalConfig *global = config->global;
curlx_dyn_init(&buf, MAX_SSLS_LINE); curlx_dyn_init(&buf, MAX_SSLS_LINE);
fp = fopen(filename, FOPEN_READTEXT); fp = fopen(filename, FOPEN_READTEXT);
@ -74,7 +74,7 @@ CURLcode tool_ssls_load(struct GlobalConfig *global,
goto out; goto out;
} }
r = tool_ssls_easy(global, config, share, &easy); r = tool_ssls_easy(config, share, &easy);
if(r) if(r)
goto out; goto out;
@ -187,23 +187,23 @@ out:
return r; return r;
} }
CURLcode tool_ssls_save(struct GlobalConfig *global, CURLcode tool_ssls_save(struct OperationConfig *config,
struct OperationConfig *config,
CURLSH *share, const char *filename) CURLSH *share, const char *filename)
{ {
struct tool_ssls_ctx ctx; struct tool_ssls_ctx ctx;
CURL *easy = NULL; CURL *easy = NULL;
CURLcode r = CURLE_OK; CURLcode r = CURLE_OK;
ctx.global = global; ctx.global = config->global;
ctx.exported = 0; ctx.exported = 0;
ctx.fp = fopen(filename, FOPEN_WRITETEXT); ctx.fp = fopen(filename, FOPEN_WRITETEXT);
if(!ctx.fp) { if(!ctx.fp) {
warnf(global, "Warning: Failed to create SSL session file %s", filename); warnf(config->global, "Warning: Failed to create SSL session file %s",
filename);
goto out; goto out;
} }
r = tool_ssls_easy(global, config, share, &easy); r = tool_ssls_easy(config, share, &easy);
if(r) if(r)
goto out; goto out;

6
src/tool_ssls.h
View File

@ -27,11 +27,9 @@
#include "tool_operate.h" #include "tool_operate.h"
CURLcode tool_ssls_load(struct GlobalConfig *global, CURLcode tool_ssls_load(struct OperationConfig *config,
struct OperationConfig *config,
CURLSH *share, const char *filename); CURLSH *share, const char *filename);
CURLcode tool_ssls_save(struct GlobalConfig *global, CURLcode tool_ssls_save(struct OperationConfig *config,
struct OperationConfig *config,
CURLSH *share, const char *filename); CURLSH *share, const char *filename);
#endif /* HEADER_CURL_TOOL_SSLS_H */ #endif /* HEADER_CURL_TOOL_SSLS_H */