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 */
#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)
}
/* 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);
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) {
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;
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);
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: */
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);
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;
}
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)
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);
return result;
#endif
- gen_trace_setopts(global, config, curl);
+ gen_trace_setopts(config, curl);
{
#ifdef DEBUGBUILD
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);
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;
}
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;
}
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;
}
my_setopt_long(curl, CURLOPT_HTTP_TRANSFER_DECODING, 0);
}
- result = tcp_setopts(global, config, curl);
+ result = tcp_setopts(config, curl);
if(result)
return result;
/* 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)
*
***************************************************************************/
-CURLcode config2setopts(struct GlobalConfig *global,
- struct OperationConfig *config,
+CURLcode config2setopts(struct OperationConfig *config,
struct per_transfer *per,
CURL *curl,
CURLSH *share);
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;
}
#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;
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) {
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);
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)
{
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 */
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;
}
}
return PARAM_READ_ERROR; /* file not found */
}
- return add_url(global, config, nextarg, FALSE);
+ return add_url(config, nextarg, FALSE);
}
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");
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;
file = fopen(nextarg, FOPEN_READTEXT);
}
if(!file) {
- warnf(global,
+ warnf(config->global,
"Couldn't read file \"%s\" "
"specified for \"--ech ecl:\" option",
nextarg);
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)
{
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 {
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");
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;
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;
}
}
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);
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;
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.");
}
/* 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) {
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;
}
/* 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;
/* 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",
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
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 */
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);
}
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);
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)) {
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 */
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);
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);
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;
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 */
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));
}
}
/* 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
}
}
- result = getparameter(orig_opt, nextarg, &passarg, global, config);
+ result = getparameter(orig_opt, nextarg, &passarg, config);
unicodefree(nextarg);
config = global->last;
bool used;
/* Just add the URL please */
- result = getparameter("--url", orig_opt, &used, global, config);
+ result = getparameter("--url", orig_opt, &used, config);
}
if(!result) {
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,
"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);
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)) {
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)
{
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;
}
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;
/* 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)) &&
if(!header) {
if(file)
fclose(file);
- errorf(global,
+ errorf(config->global,
"Failed to allocate memory for custom etag header");
return CURLE_OUT_OF_MEMORY;
}
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;
}
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);
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)
{
* 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;
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 {
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)
* 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 */
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;
}
/* 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;
/* --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;
}
/* 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;
}
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;
}
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 "-".
}
if(httpgetfields || config->query) {
- result = append2query(global, config, per,
+ result = append2query(config, per,
httpgetfields ? httpgetfields : config->query);
if(result)
break;
hdrcbdata->global = global;
hdrcbdata->config = config;
- result = config2setopts(global, config, per, curl, share);
+ result = config2setopts(config, per, curl, share);
if(result)
break;
}
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)
}
/* 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)
}
if(!result)
- result = single_transfer(global, config, share, added, skipped);
+ result = single_transfer(config, share, added, skipped);
return result;
}
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;
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) {
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;
FILE *file = NULL;
bool usedarg = FALSE;
int rc = 0;
- struct OperationConfig *operation = global->last;
+ struct OperationConfig *config = global->last;
char *pathalloc = NULL;
if(!filename) {
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?");
}
}
#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;
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;
}
}
/* 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)
{
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++) {
#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)
{
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;
#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)
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;
}
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)
{
/* 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)
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);
/* 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)
{
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);
}
}
/* 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);",
}
/* 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)
{
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);
}
/* 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)
{
}
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);
}
/* 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)
{
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);
}
/* 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;
va_end(arg);
- if(global->libcurl && pval && !ret) {
+ if(config->global->libcurl && pval && !ret) {
/* we only use this if --libcurl was used */
if(!str) {
/* 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 */
#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)
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;
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);
goto out;
}
- r = tool_ssls_easy(global, config, share, &easy);
+ r = tool_ssls_easy(config, share, &easy);
if(r)
goto 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;
#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 */
projects / thirdparty / curl.git / commitdiff
