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

3
src/config2setopts.h
View File

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

107
src/tool_getparam.c
View File

@ -690,13 +690,12 @@ error:
return err;
}
static void sethttpver(struct GlobalConfig *global,
struct OperationConfig *config,
static void sethttpver(struct OperationConfig *config,
long httpversion)
{
if(config->httpversion &&
(config->httpversion != httpversion))
warnf(global, "Overrides previous HTTP version option");
warnf(config->global, "Overrides previous HTTP version option");
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 */
static ParameterError url_query(const char *nextarg,
struct GlobalConfig *global,
struct OperationConfig *config)
{
size_t size = 0;
@ -857,7 +855,7 @@ static ParameterError url_query(const char *nextarg,
err = PARAM_NO_MEM;
}
else
err = data_urlencode(global, nextarg, &query, &size);
err = data_urlencode(config->global, nextarg, &query, &size);
if(!err) {
if(config->query) {
@ -878,13 +876,13 @@ static ParameterError url_query(const char *nextarg,
static ParameterError set_data(cmdline_t cmd,
const char *nextarg,
struct GlobalConfig *global,
struct OperationConfig *config)
{
char *postdata = NULL;
FILE *file;
size_t size = 0;
ParameterError err = PARAM_OK;
struct GlobalConfig *global = config->global;
if(cmd == C_DATA_URLENCODE) { /* --data-urlencode */
err = data_urlencode(global, nextarg, &postdata, &size);
@ -1039,8 +1037,7 @@ const struct LongShort *findlongopt(const char *opt)
sizeof(aliases[0]), findarg);
}
static ParameterError add_url(struct GlobalConfig *global,
struct OperationConfig *config,
static ParameterError add_url(struct OperationConfig *config,
const char *thisurl,
bool remote_noglob)
{
@ -1076,15 +1073,14 @@ static ParameterError add_url(struct GlobalConfig *global,
url->useremote = url->noglob = TRUE;
if(!err && (++config->num_urls > 1) &&
(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 err;
}
static ParameterError parse_url(struct GlobalConfig *global,
struct OperationConfig *config,
static ParameterError parse_url(struct OperationConfig *config,
const char *nextarg)
{
/* nextarg is never NULL here */
@ -1104,7 +1100,7 @@ static ParameterError parse_url(struct GlobalConfig *global,
curlx_dyn_init(&line, 8092);
while(my_get_line(f, &line, &error)) {
const char *ptr = curlx_dyn_ptr(&line);
err = add_url(global, config, ptr, TRUE);
err = add_url(config, ptr, TRUE);
if(err)
break;
}
@ -1117,7 +1113,7 @@ static ParameterError parse_url(struct GlobalConfig *global,
}
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;
}
static ParameterError parse_continue_at(struct GlobalConfig *global,
struct OperationConfig *config,
static ParameterError parse_continue_at(struct OperationConfig *config,
const char *nextarg)
{
struct GlobalConfig *global = config->global;
ParameterError err = PARAM_OK;
if(config->range) {
errorf(global, "--continue-at is mutually exclusive with --range");
@ -1189,8 +1185,7 @@ static ParameterError parse_continue_at(struct GlobalConfig *global,
return err;
}
static ParameterError parse_ech(struct GlobalConfig *global,
struct OperationConfig *config,
static ParameterError parse_ech(struct OperationConfig *config,
const char *nextarg)
{
ParameterError err = PARAM_OK;
@ -1218,7 +1213,7 @@ static ParameterError parse_ech(struct GlobalConfig *global,
file = fopen(nextarg, FOPEN_READTEXT);
}
if(!file) {
warnf(global,
warnf(config->global,
"Couldn't read file \"%s\" "
"specified for \"--ech ecl:\" option",
nextarg);
@ -1242,8 +1237,7 @@ static ParameterError parse_ech(struct GlobalConfig *global,
return err;
}
static ParameterError parse_header(struct GlobalConfig *global,
struct OperationConfig *config,
static ParameterError parse_header(struct OperationConfig *config,
cmdline_t cmd,
const char *nextarg)
{
@ -1255,7 +1249,7 @@ static ParameterError parse_header(struct GlobalConfig *global,
bool use_stdin = !strcmp(&nextarg[1], "-");
FILE *file = use_stdin ? stdin : fopen(&nextarg[1], FOPEN_READTEXT);
if(!file) {
errorf(global, "Failed to open %s", &nextarg[1]);
errorf(config->global, "Failed to open %s", &nextarg[1]);
err = PARAM_READ_ERROR;
}
else {
@ -1384,13 +1378,13 @@ static ParameterError parse_quote(struct OperationConfig *config,
return err;
}
static ParameterError parse_range(struct GlobalConfig *global,
struct OperationConfig *config,
static ParameterError parse_range(struct OperationConfig *config,
const char *nextarg)
{
ParameterError err = PARAM_OK;
curl_off_t value;
const char *orig = nextarg;
struct GlobalConfig *global = config->global;
if(config->use_resume) {
errorf(global, "--continue-at is mutually exclusive with --range");
@ -1527,8 +1521,7 @@ static ParameterError parse_verbose(struct GlobalConfig *global,
return err;
}
static ParameterError parse_writeout(struct GlobalConfig *global,
struct OperationConfig *config,
static ParameterError parse_writeout(struct OperationConfig *config,
const char *nextarg)
{
ParameterError err = PARAM_OK;
@ -1548,7 +1541,7 @@ static ParameterError parse_writeout(struct GlobalConfig *global,
fname = nextarg;
file = fopen(fname, FOPEN_READTEXT);
if(!file) {
errorf(global, "Failed to open %s", fname);
errorf(config->global, "Failed to open %s", fname);
return PARAM_READ_ERROR;
}
}
@ -1559,7 +1552,7 @@ static ParameterError parse_writeout(struct GlobalConfig *global,
if(err)
return err;
if(!config->writeout)
warnf(global, "Failed to read %s", fname);
warnf(config->global, "Failed to read %s", fname);
}
else
err = getstr(&config->writeout, nextarg, ALLOW_BLANK);
@ -1567,8 +1560,7 @@ static ParameterError parse_writeout(struct GlobalConfig *global,
return err;
}
static ParameterError parse_time_cond(struct GlobalConfig *global,
struct OperationConfig *config,
static ParameterError parse_time_cond(struct OperationConfig *config,
const char *nextarg)
{
ParameterError err = PARAM_OK;
@ -1596,14 +1588,14 @@ static ParameterError parse_time_cond(struct GlobalConfig *global,
if(-1 == config->condtime) {
curl_off_t value;
/* 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)
/* pull the time out from the file */
config->condtime = value;
else {
/* failed, remove time condition */
config->timecond = CURL_TIMECOND_NONE;
warnf(global,
warnf(config->global,
"Illegal date format for -z, --time-cond (and not "
"a filename). Disabling time condition. "
"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 */
static ParameterError opt_none(struct GlobalConfig *global,
struct OperationConfig *config,
static ParameterError opt_none(struct OperationConfig *config,
const struct LongShort *a)
{
switch(a->cmd) {
@ -1707,37 +1698,37 @@ static ParameterError opt_none(struct GlobalConfig *global,
case C_HTTP1_0: /* --http1.0 */
/* HTTP version 1.0 */
sethttpver(global, config, CURL_HTTP_VERSION_1_0);
sethttpver(config, CURL_HTTP_VERSION_1_0);
break;
case C_HTTP1_1: /* --http1.1 */
/* HTTP version 1.1 */
sethttpver(global, config, CURL_HTTP_VERSION_1_1);
sethttpver(config, CURL_HTTP_VERSION_1_1);
break;
case C_HTTP2: /* --http2 */
/* HTTP version 2.0 */
if(!feature_http2)
return PARAM_LIBCURL_DOESNT_SUPPORT;
sethttpver(global, config, CURL_HTTP_VERSION_2_0);
sethttpver(config, CURL_HTTP_VERSION_2_0);
break;
case C_HTTP2_PRIOR_KNOWLEDGE: /* --http2-prior-knowledge */
/* HTTP version 2.0 over clean TCP */
if(!feature_http2)
return PARAM_LIBCURL_DOESNT_SUPPORT;
sethttpver(global, config, CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE);
sethttpver(config, CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE);
break;
case C_HTTP3: /* --http3: */
/* Try HTTP/3, allow fallback */
if(!feature_http3)
return PARAM_LIBCURL_DOESNT_SUPPORT;
else
sethttpver(global, config, CURL_HTTP_VERSION_3);
sethttpver(config, CURL_HTTP_VERSION_3);
break;
case C_HTTP3_ONLY: /* --http3-only */
/* Try HTTP/3 without fallback */
if(!feature_http3)
return PARAM_LIBCURL_DOESNT_SUPPORT;
else
sethttpver(global, config, CURL_HTTP_VERSION_3ONLY);
sethttpver(config, CURL_HTTP_VERSION_3ONLY);
break;
case C_TLSV1: /* --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 */
static ParameterError opt_bool(struct GlobalConfig *global,
struct OperationConfig *config,
static ParameterError opt_bool(struct OperationConfig *config,
const struct LongShort *a,
bool toggle)
{
struct GlobalConfig *global = config->global;
switch(a->cmd) {
case C_ALPN: /* --alpn */
config->noalpn = !toggle;
@ -2161,13 +2152,13 @@ static ParameterError opt_bool(struct GlobalConfig *global,
/* opt_filestring handles string and file options */
static ParameterError opt_filestring(struct GlobalConfig *global,
struct OperationConfig *config,
static ParameterError opt_filestring(struct OperationConfig *config,
const struct LongShort *a,
const char *nextarg)
{
ParameterError err = PARAM_OK;
curl_off_t value;
struct GlobalConfig *global = config->global;
static const char *redir_protos[] = {
"http",
"https",
@ -2292,7 +2283,7 @@ static ParameterError opt_filestring(struct GlobalConfig *global,
config->max_filesize = value;
break;
case C_URL: /* --url */
err = parse_url(global, config, nextarg);
err = parse_url(config, nextarg);
break;
case C_SOCKS5: /* --socks5 */
/* 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);
break;
case C_CONTINUE_AT: /* --continue-at */
err = parse_continue_at(global, config, nextarg);
err = parse_continue_at(config, nextarg);
break;
case C_DATA: /* --data */
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_JSON: /* --json */
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;
case C_URL_QUERY: /* --url-query */
err = url_query(nextarg, global, config);
err = url_query(nextarg, config);
break;
case C_DUMP_HEADER: /* --dump-header */
err = getstr(&config->headerfile, nextarg, DENY_BLANK);
@ -2540,7 +2531,7 @@ static ParameterError opt_filestring(struct GlobalConfig *global,
}
break;
case C_ECH: /* --ech */
err = parse_ech(global, config, nextarg);
err = parse_ech(config, nextarg);
break;
case C_CAPATH: /* --capath */
err = getstr(&config->capath, nextarg, DENY_BLANK);
@ -2690,7 +2681,7 @@ static ParameterError opt_filestring(struct GlobalConfig *global,
break;
case C_HEADER: /* --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;
case C_CONFIG: /* --config */
if(parseconfig(nextarg, global)) {
@ -2727,7 +2718,7 @@ static ParameterError opt_filestring(struct GlobalConfig *global,
err = parse_quote(config, nextarg);
break;
case C_RANGE: /* --range */
err = parse_range(global, config, nextarg);
err = parse_range(config, nextarg);
break;
case C_TELNET_OPTION: /* --telnet-option */
/* Telnet options */
@ -2745,7 +2736,7 @@ static ParameterError opt_filestring(struct GlobalConfig *global,
err = getstr(&config->proxyuserpwd, nextarg, ALLOW_BLANK);
break;
case C_WRITE_OUT: /* --write-out */
err = parse_writeout(global, config, nextarg);
err = parse_writeout(config, nextarg);
break;
case C_PREPROXY: /* --preproxy */
err = getstr(&config->preproxy, nextarg, DENY_BLANK);
@ -2786,7 +2777,7 @@ static ParameterError opt_filestring(struct GlobalConfig *global,
break;
}
case C_TIME_COND: /* --time-cond */
err = parse_time_cond(global, config, nextarg);
err = parse_time_cond(config, nextarg);
break;
case C_UPLOAD_FLAGS: /* --upload-flags */
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 */
bool *usedarg, /* set to TRUE if the arg
has been used */
struct GlobalConfig *global,
struct OperationConfig *config)
{
const char *parse = NULL;
@ -2810,6 +2800,7 @@ ParameterError getparameter(const char *flag, /* f or -long-flag */
by using --OPTION or --no-OPTION */
bool nextalloc = FALSE; /* if nextarg is allocated */
const struct LongShort *a = NULL;
struct GlobalConfig *global = config->global;
verbose_nopts = 0; /* options processed in `flag`*/
*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);
}
/* ARG_FILE | ARG_STRG */
err = opt_filestring(global, config, a, nextarg);
err = opt_filestring(config, a, nextarg);
if(a->desc & ARG_CLEAR)
cleanarg(CURL_UNCONST(nextarg));
}
@ -2932,9 +2923,9 @@ ParameterError getparameter(const char *flag, /* f or -long-flag */
}
/* ARG_NONE | ARG_BOOL */
if(ARGTYPE(a->desc) == ARG_BOOL)
err = opt_bool(global, config, a, toggle);
err = opt_bool(config, a, toggle);
else
err = opt_none(global, config, a);
err = opt_none(config, a);
}
++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);
config = global->last;
@ -3014,7 +3005,7 @@ ParameterError parse_args(struct GlobalConfig *global, int argc,
bool used;
/* Just add the URL please */
result = getparameter("--url", orig_opt, &used, global, config);
result = getparameter("--url", orig_opt, &used, config);
}
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,
bool *usedarg,
struct GlobalConfig *global,
struct OperationConfig *operation);
struct OperationConfig *config);
#ifdef UNITTESTS
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 " \
"above.\n"
static CURLcode single_transfer(struct GlobalConfig *global,
struct OperationConfig *config,
static CURLcode single_transfer(struct OperationConfig *config,
CURLSH *share,
bool *added,
bool *skipped);
@ -273,6 +272,8 @@ static CURLcode pre_transfer(struct GlobalConfig *global,
CURLcode result = CURLE_OK;
#ifdef CURL_DISABLE_LIBCURL_OPTION
(void)global; /* otherwise used in the my_setopt macros */
#else
struct OperationConfig *config = global->current;
#endif
if(per->uploadfile && !stdin_upload(per->uploadfile)) {
@ -772,8 +773,7 @@ static CURLcode set_cert_types(struct OperationConfig *config)
return CURLE_OK;
}
static CURLcode append2query(struct GlobalConfig *global,
struct OperationConfig *config,
static CURLcode append2query(struct OperationConfig *config,
struct per_transfer *per,
const char *q)
{
@ -785,7 +785,7 @@ static CURLcode append2query(struct GlobalConfig *global,
CURLU_GUESS_SCHEME);
if(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);
config->synthetic_error = TRUE;
}
@ -807,8 +807,7 @@ static CURLcode append2query(struct GlobalConfig *global,
return result;
}
static CURLcode etag_compare(struct GlobalConfig *global,
struct OperationConfig *config)
static CURLcode etag_compare(struct OperationConfig *config)
{
CURLcode result = CURLE_OK;
char *etag_from_file = NULL;
@ -818,7 +817,7 @@ static CURLcode etag_compare(struct GlobalConfig *global,
/* open file for reading: */
FILE *file = fopen(config->etag_compare_file, FOPEN_READTEXT);
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));
if((PARAM_OK == file2string(&etag_from_file, file)) &&
@ -832,7 +831,7 @@ static CURLcode etag_compare(struct GlobalConfig *global,
if(!header) {
if(file)
fclose(file);
errorf(global,
errorf(config->global,
"Failed to allocate memory for custom etag header");
return CURLE_OUT_OF_MEMORY;
}
@ -848,13 +847,13 @@ static CURLcode etag_compare(struct GlobalConfig *global,
return result;
}
static CURLcode etag_store(struct GlobalConfig *global,
struct OperationConfig *config,
static CURLcode etag_store(struct OperationConfig *config,
struct OutStruct *etag_save,
bool *skip)
{
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)
return result;
}
@ -864,7 +863,7 @@ static CURLcode etag_store(struct GlobalConfig *global,
FILE *newfile = fopen(config->etag_save_file, "ab");
if(!newfile) {
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);
tool_safefree(state->outfiles);
glob_cleanup(&state->urls);
@ -885,8 +884,7 @@ static CURLcode etag_store(struct GlobalConfig *global,
return CURLE_OK;
}
static CURLcode setup_headerfile(struct GlobalConfig *global,
struct OperationConfig *config,
static CURLcode setup_headerfile(struct OperationConfig *config,
struct per_transfer *per,
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.
*/
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 */
if(result)
return result;
@ -922,7 +921,7 @@ static CURLcode setup_headerfile(struct GlobalConfig *global,
newfile = fopen(config->headerfile, "ab");
if(!newfile) {
errorf(global, "Failed to open %s", config->headerfile);
errorf(config->global, "Failed to open %s", config->headerfile);
return CURLE_WRITE_ERROR;
}
else {
@ -939,8 +938,7 @@ static CURLcode setup_headerfile(struct GlobalConfig *global,
return CURLE_OK;
}
static CURLcode setup_outfile(struct GlobalConfig *global,
struct OperationConfig *config,
static CURLcode setup_outfile(struct OperationConfig *config,
struct per_transfer *per,
struct OutStruct *outs,
bool *skipped)
@ -950,6 +948,7 @@ static CURLcode setup_outfile(struct GlobalConfig *global,
* decided we want to use the remote filename.
*/
struct State *state = &config->state;
struct GlobalConfig *global = config->global;
if(!per->outfile) {
/* extract the filename from the URL */
@ -1044,10 +1043,10 @@ static CURLcode setup_outfile(struct GlobalConfig *global,
return CURLE_OK;
}
static void check_stdin_upload(struct GlobalConfig *global,
struct OperationConfig *config,
static void check_stdin_upload(struct OperationConfig *config,
struct per_transfer *per)
{
struct GlobalConfig *global = config->global;
/* count to see if there are more than one auth bit set
in the authtype field */
int authbits = 0;
@ -1105,14 +1104,14 @@ static void check_stdin_upload(struct GlobalConfig *global,
}
/* create the next (singular) transfer */
static CURLcode single_transfer(struct GlobalConfig *global,
struct OperationConfig *config,
static CURLcode single_transfer(struct OperationConfig *config,
CURLSH *share,
bool *added,
bool *skipped)
{
CURLcode result = CURLE_OK;
struct getout *urlnode;
struct GlobalConfig *global = config->global;
bool orig_noprogress = global->noprogress;
bool orig_isatty = global->isatty;
struct State *state = &config->state;
@ -1239,14 +1238,14 @@ static CURLcode single_transfer(struct GlobalConfig *global,
/* --etag-compare */
if(config->etag_compare_file) {
result = etag_compare(global, config);
result = etag_compare(config);
if(result)
break;
}
if(config->etag_save_file) {
bool badetag = FALSE;
result = etag_store(global, config, etag_save, &badetag);
result = etag_store(config, etag_save, &badetag);
if(result || badetag)
break;
}
@ -1288,7 +1287,7 @@ static CURLcode single_transfer(struct GlobalConfig *global,
/* Single header file for all URLs */
if(config->headerfile) {
result = setup_headerfile(global, config, per, heads);
result = setup_headerfile(config, per, heads);
if(result)
break;
}
@ -1330,7 +1329,7 @@ static CURLcode single_transfer(struct GlobalConfig *global,
if((urlnode->useremote ||
(per->outfile && strcmp("-", per->outfile)))) {
result = setup_outfile(global, config, per, outs, skipped);
result = setup_outfile(config, per, outs, skipped);
if(result)
break;
}
@ -1338,7 +1337,7 @@ static CURLcode single_transfer(struct GlobalConfig *global,
if(per->uploadfile) {
if(stdin_upload(per->uploadfile))
check_stdin_upload(global, config, per);
check_stdin_upload(config, per);
else {
/*
* 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) {
result = append2query(global, config, per,
result = append2query(config, per,
httpgetfields ? httpgetfields : config->query);
if(result)
break;
@ -1394,7 +1393,7 @@ static CURLcode single_transfer(struct GlobalConfig *global,
hdrcbdata->global = global;
hdrcbdata->config = config;
result = config2setopts(global, config, per, curl, share);
result = config2setopts(config, per, curl, share);
if(result)
break;
@ -1847,7 +1846,8 @@ static CURLcode check_finished(struct parastate *s)
}
if(checkmore) {
/* 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->added_transfers);
if(tres)
@ -2132,8 +2132,7 @@ fail:
}
/* setup a transfer for the given config */
static CURLcode transfer_per_config(struct GlobalConfig *global,
struct OperationConfig *config,
static CURLcode transfer_per_config(struct OperationConfig *config,
CURLSH *share,
bool *added,
bool *skipped)
@ -2173,7 +2172,7 @@ static CURLcode transfer_per_config(struct GlobalConfig *global,
}
if(!result)
result = single_transfer(global, config, share, added, skipped);
result = single_transfer(config, share, added, skipped);
return result;
}
@ -2190,8 +2189,7 @@ static CURLcode create_transfer(struct GlobalConfig *global,
CURLcode result = CURLE_OK;
*added = FALSE;
while(global->current) {
result = transfer_per_config(global, global->current, share, added,
skipped);
result = transfer_per_config(global->current, share, added, skipped);
if(!result && !*added) {
/* when one set is drained, continue to 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);
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);
if(!result) {
@ -2359,7 +2357,7 @@ CURLcode operate(struct GlobalConfig *global, int argc, argv_item_t argv[])
result = run_all_transfers(global, share, result);
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);
if(r2 && !result)
result = r2;

24
src/tool_parsecfg.c
View File

@ -46,7 +46,7 @@ int parseconfig(const char *filename, struct GlobalConfig *global)
FILE *file = NULL;
bool usedarg = FALSE;
int rc = 0;
struct OperationConfig *operation = global->last;
struct OperationConfig *config = global->last;
char *pathalloc = NULL;
if(!filename) {
@ -156,9 +156,9 @@ int parseconfig(const char *filename, struct GlobalConfig *global)
case '#': /* comment */
break;
default:
warnf(operation->global, "%s:%d: warning: '%s' uses unquoted "
warnf(config->global, "%s:%d: warning: '%s' uses unquoted "
"whitespace", filename, lineno, option);
warnf(operation->global, "This may cause side-effects. "
warnf(config->global, "This may cause side-effects. "
"Consider using double quotes?");
}
}
@ -171,24 +171,24 @@ int parseconfig(const char *filename, struct GlobalConfig *global)
#ifdef DEBUG_CONFIG
fprintf(tool_stderr, "PARAM: \"%s\"\n",(param ? param : "(null)"));
#endif
res = getparameter(option, param, &usedarg, global, operation);
operation = global->last;
res = getparameter(option, param, &usedarg, config);
config = global->last;
if(!res && param && *param && !usedarg)
/* we passed in a parameter that was not used! */
res = PARAM_GOT_EXTRA_PARAMETER;
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 */
operation->next = config_alloc(global);
if(operation->next) {
config->next = config_alloc(global);
if(config->next) {
/* Update the last operation pointer */
global->last = operation->next;
global->last = config->next;
/* Move onto the new config */
operation->next->prev = operation;
operation = operation->next;
config->next->prev = config;
config = config->next;
}
else
res = PARAM_NO_MEM;
@ -206,7 +206,7 @@ int parseconfig(const char *filename, struct GlobalConfig *global)
res != PARAM_ENGINES_REQUESTED &&
res != PARAM_CA_EMBED_REQUESTED) {
const char *reason = param2text(res);
errorf(operation->global, "%s:%d: '%s' %s",
errorf(config->global, "%s:%d: '%s' %s",
filename, lineno, option, reason);
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 */
CURLcode tool_setopt_enum(CURL *curl, struct GlobalConfig *global,
CURLcode tool_setopt_enum(CURL *curl, struct OperationConfig *config,
const char *name, CURLoption tag,
const struct NameValue *nvlist, long lval)
{
@ -234,7 +234,7 @@ CURLcode tool_setopt_enum(CURL *curl, struct GlobalConfig *global,
if(!lval)
skip = TRUE;
if(global->libcurl && !skip && !ret) {
if(config->global->libcurl && !skip && !ret) {
/* we only use this for real if --libcurl was used */
const struct NameValue *nv = NULL;
for(nv = nvlist; nv->name; nv++) {
@ -256,13 +256,13 @@ CURLcode tool_setopt_enum(CURL *curl, struct GlobalConfig *global,
#ifdef DEBUGBUILD
if(ret)
warnf(global, "option %s returned error (%d)", name, (int)ret);
warnf(config->global, "option %s returned error (%d)", name, (int)ret);
#endif
return ret;
}
/* 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,
long lval)
{
@ -273,7 +273,7 @@ CURLcode tool_setopt_SSLVERSION(CURL *curl, struct GlobalConfig *global,
if(!lval)
skip = TRUE;
if(global->libcurl && !skip && !ret) {
if(config->global->libcurl && !skip && !ret) {
/* we only use this for real if --libcurl was used */
const struct NameValue *nv = NULL;
const struct NameValue *nv2 = NULL;
@ -301,13 +301,13 @@ CURLcode tool_setopt_SSLVERSION(CURL *curl, struct GlobalConfig *global,
#ifdef DEBUGBUILD
if(ret)
warnf(global, "option %s returned error (%d)", name, (int)ret);
warnf(config->global, "option %s returned error (%d)", name, (int)ret);
#endif
return ret;
}
/* 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 struct NameValueUnsigned *nvlist,
long lval)
@ -317,7 +317,7 @@ CURLcode tool_setopt_bitmask(CURL *curl, struct GlobalConfig *global,
if(!lval)
skip = TRUE;
if(global->libcurl && !skip && !ret) {
if(config->global->libcurl && !skip && !ret) {
/* we only use this for real if --libcurl was used */
char preamble[80];
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,
struct GlobalConfig *global,
struct OperationConfig *config,
struct tool_mime *toolmime,
int *mimeno); /* Forward. */
/* Wrapper to generate source code for a mime part. */
static CURLcode libcurl_generate_mime_part(CURL *curl,
struct GlobalConfig *global,
struct OperationConfig *config,
struct tool_mime *part,
int mimeno)
{
@ -396,7 +396,7 @@ static CURLcode libcurl_generate_mime_part(CURL *curl,
/* Parts are linked in reverse order. */
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. */
if(!ret)
@ -407,7 +407,7 @@ static CURLcode libcurl_generate_mime_part(CURL *curl,
switch(part->kind) {
case TOOLMIME_PARTS:
ret = libcurl_generate_mime(curl, global, part, &submimeno);
ret = libcurl_generate_mime(curl, config, part, &submimeno);
if(!ret) {
ret = easysrc_addf(&easysrc_code, "curl_mime_subparts(part%d, mime%d);",
mimeno, submimeno);
@ -507,7 +507,7 @@ static CURLcode libcurl_generate_mime_part(CURL *curl,
/* Wrapper to generate source code for a mime structure. */
static CURLcode libcurl_generate_mime(CURL *curl,
struct GlobalConfig *global,
struct OperationConfig *config,
struct tool_mime *toolmime,
int *mimeno)
{
@ -529,7 +529,7 @@ static CURLcode libcurl_generate_mime(CURL *curl,
if(toolmime->subparts && !ret) {
ret = easysrc_addf(&easysrc_decl, "curl_mimepart *part%d;", *mimeno);
if(!ret)
ret = libcurl_generate_mime_part(curl, global,
ret = libcurl_generate_mime_part(curl, config,
toolmime->subparts, *mimeno);
}
@ -537,16 +537,15 @@ static CURLcode libcurl_generate_mime(CURL *curl,
}
/* 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,
curl_mime *mimepost)
{
CURLcode ret = curl_easy_setopt(curl, tag, mimepost);
int mimeno = 0;
if(!ret && global->libcurl) {
ret = libcurl_generate_mime(curl, global,
global->current->mimeroot, &mimeno);
if(!ret && config->global->libcurl) {
ret = libcurl_generate_mime(curl, config, config->mimeroot, &mimeno);
if(!ret)
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 */
CURLcode tool_setopt_slist(CURL *curl, struct GlobalConfig *global,
CURLcode tool_setopt_slist(CURL *curl, struct OperationConfig *config,
const char *name, CURLoption tag,
struct curl_slist *list)
{
@ -565,7 +564,7 @@ CURLcode tool_setopt_slist(CURL *curl, struct GlobalConfig *global,
ret = curl_easy_setopt(curl, tag, list);
if(global->libcurl && list && !ret) {
if(config->global->libcurl && list && !ret) {
int i;
ret = libcurl_generate_slist(list, &i);
@ -578,7 +577,7 @@ CURLcode tool_setopt_slist(CURL *curl, struct GlobalConfig *global,
}
/* 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,
long lval)
{
@ -595,7 +594,7 @@ CURLcode tool_setopt_long(CURL *curl, struct GlobalConfig *global,
}
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 */
ret = easysrc_addf(&easysrc_code, "curl_easy_setopt(hnd, %s, %ldL);",
name, lval);
@ -604,7 +603,7 @@ CURLcode tool_setopt_long(CURL *curl, struct GlobalConfig *global,
}
/* 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,
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));
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 */
ret = easysrc_addf(&easysrc_code, "curl_easy_setopt(hnd, %s, (curl_off_t)%"
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 */
CURLcode tool_setopt(CURL *curl, bool str, struct GlobalConfig *global,
struct OperationConfig *config,
CURLcode tool_setopt(CURL *curl, bool str, struct OperationConfig *config,
const char *name, CURLoption tag, ...)
{
va_list arg;
@ -645,7 +643,7 @@ CURLcode tool_setopt(CURL *curl, bool str, struct GlobalConfig *global,
va_end(arg);
if(global->libcurl && pval && !ret) {
if(config->global->libcurl && pval && !ret) {
/* we only use this if --libcurl was used */
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 */
CURLcode tool_setopt_enum(CURL *curl, struct GlobalConfig *global,
CURLcode tool_setopt_enum(CURL *curl, struct OperationConfig *config,
const char *name, CURLoption tag,
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,
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 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 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,
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,
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,
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,
curl_off_t lval);
CURLcode tool_setopt(CURL *curl, bool str, struct GlobalConfig *global,
CURLcode tool_setopt(CURL *curl, bool str,
struct OperationConfig *config,
const char *name, CURLoption tag, ...);
#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) \
tool_setopt_long(x, global, #y, y, z)
tool_setopt_long(x, config, #y, 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) \
tool_setopt(x, TRUE, global, config, #y, y, z)
tool_setopt(x, TRUE, config, #y, 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) \
tool_setopt_SSLVERSION(x, global, #y, y, z)
tool_setopt_SSLVERSION(x, config, #y, 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) \
tool_setopt_mimepost(x, global, #y, y, z)
tool_setopt_mimepost(x, config, #y, 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 */

20
src/tool_ssls.c
View File

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

6
src/tool_ssls.h
View File

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