generic-library/curl
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

curl tool: fix some OOM handling issues

Browse Source
This commit is contained in:
Yang Tse 2011-09-24 05:32:51 +02:00
parent 5f0764870f
commit 081e289315
3 changed files with 227 additions and 183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

378
src/main.c
View File

@ -3408,8 +3408,8 @@ int my_trace(CURL *handle, curl_infotype type,
return 0;
}
#define RETRY_SLEEP_DEFAULT 1000 /* ms */
#define RETRY_SLEEP_MAX 600000 /* ms == 10 minutes */
#define RETRY_SLEEP_DEFAULT 1000L /* ms */
#define RETRY_SLEEP_MAX 600000L /* ms == 10 minutes */
static bool
output_expected(const char* url, const char* uploadfile)
@ -3684,66 +3684,57 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
char errorbuffer[CURL_ERROR_SIZE];
struct ProgressData progressbar;
struct getout *urlnode;
struct getout *nextnode;
struct OutStruct outs;
struct OutStruct heads;
struct InStruct input;
URLGlob *urls=NULL;
URLGlob *inglob=NULL;
int urlnum;
int infilenum;
char *uploadfile=NULL; /* a single file, never a glob */
CURL *curl = NULL;
char *httpgetfields = NULL;
curl_off_t uploadfilesize; /* -1 means unknown */
bool stillflags=TRUE;
char *httpgetfields=NULL;
CURL *curl;
bool stillflags;
int res = 0;
int i;
long retry_sleep_default;
long retry_sleep;
char *env;
errorbuffer[0] = '\0';
memset(&outs, 0, sizeof(struct OutStruct));
memset(&heads, 0, sizeof(struct OutStruct));
memory_tracking_init();
/* Initialize curl library - do not call any libcurl functions before.
Note that the memory_tracking_init() magic above is an exception, but
then that's not part of the official public API.
/*
** Initialize curl library - do not call any libcurl functions before
** this point. Note that the memory_tracking_init() magic above is an
** exception, but then that's not part of the official public API.
*/
if(main_init() != CURLE_OK) {
helpf(config->errors, "error initializing curl library\n");
return CURLE_FAILED_INIT;
}
/*
* Get a curl handle to use for all forthcoming curl transfers. Cleanup
* when all transfers are done.
*/
/* Get libcurl info right away */
if(get_libcurl_info() != CURLE_OK) {
helpf(config->errors, "error retrieving curl library information\n");
main_free();
return CURLE_FAILED_INIT;
}
/* Get a curl handle to use for all forthcoming curl transfers */
curl = curl_easy_init();
if(!curl) {
clean_getout(config);
helpf(config->errors, "error initializing curl easy handle\n");
main_free();
return CURLE_FAILED_INIT;
}
config->easy = curl;
memset(&outs,0,sizeof(outs));
/* Store a pointer to our 'outs' struct used for output writing */
config->outs = &outs;
/* we get libcurl info right away */
if(get_libcurl_info() != CURLE_OK) {
clean_getout(config);
return CURLE_FAILED_INIT;
}
errorbuffer[0]=0; /* prevent junk from being output */
/*
** Beyond this point no return'ing from this function allowed.
** Jump to label 'quit_curl' in order to abandon this function
** from outside of nested loops further down below.
*/
/* setup proper locale from environment */
#ifdef HAVE_SETLOCALE
@ -3752,9 +3743,9 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
/* inits */
config->postfieldsize = -1;
config->showerror=TRUE;
config->use_httpget=FALSE;
config->create_dirs=FALSE;
config->showerror = TRUE;
config->use_httpget = FALSE;
config->create_dirs = FALSE;
config->maxredirs = DEFAULT_MAXREDIRS;
config->proto = CURLPROTO_ALL; /* FIXME: better to read from library */
config->proto_present = FALSE;
@ -3762,7 +3753,7 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
CURLPROTO_ALL & ~(CURLPROTO_FILE|CURLPROTO_SCP); /* not FILE or SCP */
config->proto_redir_present = FALSE;
if(argc>1 &&
if((argc > 1) &&
(!curlx_strnequal("--", argv[1], 2) && (argv[1][0] == '-')) &&
strchr(argv[1], 'q')) {
/*
@ -3777,25 +3768,26 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
if((argc < 2) && !config->url_list) {
helpf(config->errors, NULL);
return CURLE_FAILED_INIT;
res = CURLE_FAILED_INIT;
goto quit_curl;
}
/* Parse options */
for(i = 1; i < argc; i++) {
for(i = 1, stillflags = TRUE; i < argc; i++) {
if(stillflags &&
('-' == argv[i][0])) {
char *nextarg;
bool passarg;
char *origopt=argv[i];
char *origopt = argv[i];
char *flag = argv[i];
if(curlx_strequal("--", argv[i]))
/* this indicates the end of the flags and thus enables the
following (URL) argument to start with -. */
stillflags=FALSE;
stillflags = FALSE;
else {
nextarg= (i < argc - 1)? argv[i+1]: NULL;
nextarg = (i < (argc-1)) ? argv[i+1] : NULL;
res = getparameter(flag, nextarg, &passarg, config);
if(res) {
@ -3805,8 +3797,8 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
helpf(config->errors, "option %s: %s\n", origopt, reason);
retval = CURLE_FAILED_INIT;
}
clean_getout(config);
return retval;
res = retval;
goto quit_curl;
}
if(passarg) /* we're supposed to skip this */
@ -3818,24 +3810,20 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
/* just add the URL please */
res = getparameter((char *)"--url", argv[i], &used, config);
if(res)
return res;
goto quit_curl;
}
}
retry_sleep_default = config->retry_delay?
config->retry_delay*1000:RETRY_SLEEP_DEFAULT; /* ms */
retry_sleep = retry_sleep_default;
if((!config->url_list || !config->url_list->url) && !config->list_engines) {
clean_getout(config);
helpf(config->errors, "no URL specified!\n");
return CURLE_FAILED_INIT;
res = CURLE_FAILED_INIT;
goto quit_curl;
}
if(!config->useragent)
config->useragent = my_useragent();
if(!config->useragent) {
clean_getout(config);
helpf(config->errors, "out of memory\n");
res = CURLE_OUT_OF_MEMORY;
goto quit_curl;
}
@ -3852,12 +3840,14 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
if(!config->cacert &&
!config->capath &&
!config->insecure_ok) {
char *env;
env = curlx_getenv("CURL_CA_BUNDLE");
if(env) {
config->cacert = strdup(env);
if(!config->cacert) {
clean_getout(config);
curl_free(env);
helpf(config->errors, "out of memory\n");
res = CURLE_OUT_OF_MEMORY;
goto quit_curl;
}
}
@ -3866,8 +3856,9 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
if(env) {
config->capath = strdup(env);
if(!config->capath) {
clean_getout(config);
curl_free(env);
helpf(config->errors, "out of memory\n");
res = CURLE_OUT_OF_MEMORY;
goto quit_curl;
}
}
@ -3876,8 +3867,9 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
if(env) {
config->cacert = strdup(env);
if(!config->cacert) {
clean_getout(config);
curl_free(env);
helpf(config->errors, "out of memory\n");
res = CURLE_OUT_OF_MEMORY;
goto quit_curl;
}
}
@ -3889,10 +3881,8 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
#ifdef WIN32
else {
res = FindWin32CACert(config, "curl-ca-bundle.crt");
if(res) {
clean_getout(config);
if(res)
goto quit_curl;
}
}
#endif
}
@ -3905,27 +3895,28 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
if(SetHTTPrequest(config,
(config->no_body?HTTPREQ_HEAD:HTTPREQ_GET),
&config->httpreq)) {
Curl_safefree(httpgetfields);
return PARAM_BAD_USE;
res = PARAM_BAD_USE;
goto quit_curl;
}
}
else {
if(SetHTTPrequest(config, HTTPREQ_SIMPLEPOST, &config->httpreq))
return PARAM_BAD_USE;
if(SetHTTPrequest(config, HTTPREQ_SIMPLEPOST, &config->httpreq)) {
res = PARAM_BAD_USE;
goto quit_curl;
}
}
}
/* This is the first entry added to easysrc and it initializes the slist */
easysrc = curl_slist_append(easysrc, "CURL *hnd = curl_easy_init();");
if(!easysrc) {
clean_getout(config);
helpf(config->errors, "out of memory\n");
res = CURLE_OUT_OF_MEMORY;
goto quit_curl;
}
if(config->list_engines) {
struct curl_slist *engines = NULL;
curl_easy_getinfo(curl, CURLINFO_SSL_ENGINES, &engines);
list_engines(engines);
curl_slist_free_all(engines);
@ -3933,44 +3924,58 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
goto quit_curl;
}
/* After this point, we should call curl_easy_cleanup() if we decide to bail
* out from this function! */
urlnode = config->url_list;
/* Single header file for all URLs */
if(config->headerfile) {
/* open file for output: */
if(strcmp(config->headerfile,"-")) {
heads.filename = config->headerfile;
heads.alloc_filename = FALSE;
if(strcmp(config->headerfile, "-")) {
FILE *newfile = fopen(config->headerfile, "wb");
if(!newfile) {
warnf(config, "Failed to open %s\n", config->headerfile);
res = CURLE_WRITE_ERROR;
goto quit_curl;
}
else {
heads.filename = config->headerfile;
heads.alloc_filename = FALSE;
heads.stream = newfile;
heads.config = config;
}
}
else {
heads.filename = config->headerfile; /* "-" */
heads.alloc_filename = FALSE;
heads.stream = stdout;
heads.config = config;
}
else
heads.stream=stdout;
heads.config = config;
}
/*
** Nested loops start here.
*/
/* loop through the list of given URLs */
while(urlnode) {
for(urlnode = config->url_list; urlnode; urlnode = urlnode->next) {
int up; /* upload file counter within a single upload glob */
char *dourl;
char *url;
char *infiles; /* might be a glob pattern */
char *outfiles=NULL;
char *outfiles;
int infilenum;
URLGlob *inglob;
/* get the full URL (it might be NULL) */
dourl=urlnode->url;
outfiles = NULL;
infilenum = 0;
inglob = NULL;
url = dourl;
/* urlnode->url is the full URL (it might be NULL) */
if(NULL == url) {
/* This node had no URL, skip it and continue to the next */
if(!urlnode->url) {
/* This node has no URL. Free node data without destroying the
node itself nor modifying next pointer and continue to next */
Curl_safefree(urlnode->outfile);
/* move on to the next URL */
nextnode=urlnode->next;
Curl_safefree(urlnode); /* free the node */
urlnode = nextnode;
continue; /* next please */
Curl_safefree(urlnode->infile);
urlnode->flags = 0;
continue; /* next URL please */
}
/* default output stream is stdout */
@ -3983,7 +3988,8 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
if(urlnode->outfile) {
outfiles = strdup(urlnode->outfile);
if(!outfiles) {
clean_getout(config);
helpf(config->errors, "out of memory\n");
res = CURLE_OUT_OF_MEMORY;
break;
}
}
@ -3994,8 +4000,7 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
/* Unless explicitly shut off */
res = glob_url(&inglob, infiles, &infilenum,
config->showerror?config->errors:NULL);
if(res != CURLE_OK) {
clean_getout(config);
if(res) {
Curl_safefree(outfiles);
break;
}
@ -4005,8 +4010,15 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
single globbed string. If no upload, we enter the loop once anyway. */
for(up = 0 ;; up++) {
long retry_numretries;
char *uploadfile; /* a single file, never a glob */
int separator;
URLGlob *urls;
int urlnum;
uploadfile = NULL;
separator = 0;
urls = NULL;
urlnum = 0;
if(!up && !infiles)
Curl_nop_stmt;
@ -4021,15 +4033,13 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
break;
}
separator = 0;
uploadfilesize = -1;
if(!config->globoff) {
/* Unless explicitly shut off, we expand '{...}' and '[...]'
expressions and return total number of URLs in pattern set */
res = glob_url(&urls, dourl, &urlnum,
res = glob_url(&urls, urlnode->url, &urlnum,
config->showerror?config->errors:NULL);
if(res != CURLE_OK) {
if(res) {
Curl_safefree(uploadfile);
break;
}
}
@ -4045,19 +4055,27 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
int infd;
bool infdopen;
char *outfile;
struct InStruct input;
struct timeval retrystart;
curl_off_t uploadfilesize;
long retry_numretries;
long retry_sleep_default;
long retry_sleep;
char *this_url;
outfile = NULL;
infdopen = FALSE;
infd = STDIN_FILENO;
uploadfilesize = -1; /* -1 means unknown */
if(urls)
url = glob_next_url(urls);
else if(!i)
url = strdup(url);
this_url = glob_next_url(urls);
else if(!i) {
this_url = strdup(urlnode->url);
}
else
url = NULL;
if(!url)
this_url = NULL;
if(!this_url)
break;
if(outfiles) {
@ -4078,7 +4096,7 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
if(!outfile) {
/* extract the file name from the URL */
outfile = get_url_file_name(url);
outfile = get_url_file_name(this_url);
if((!outfile || !*outfile) && !config->content_disposition) {
helpf(config->errors, "Remote file name has no length!\n");
res = CURLE_WRITE_ERROR;
@ -4160,8 +4178,8 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
*/
struct_stat fileinfo;
url = add_file_name_to_url(curl, url, uploadfile);
if(!url) {
this_url = add_file_name_to_url(curl, this_url, uploadfile);
if(!this_url) {
res = CURLE_OUT_OF_MEMORY;
goto show_error;
}
@ -4194,7 +4212,7 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
/* we ignore file size for char/block devices, sockets, etc. */
if(S_ISREG(fileinfo.st_mode))
uploadfilesize=fileinfo.st_size;
uploadfilesize = fileinfo.st_size;
}
else if(uploadfile && stdin_upload(uploadfile)) {
@ -4237,7 +4255,7 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
if(uploadfile && config->resume_from_current)
config->resume_from = -1; /* -1 will then force get-it-yourself */
if(output_expected(url, uploadfile)
if(output_expected(this_url, uploadfile)
&& outs.stream && isatty(fileno(outs.stream)))
/* we send the output to a tty, therefore we switch off the progress
meter */
@ -4245,19 +4263,19 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
if(urlnum > 1 && !(config->mute)) {
fprintf(config->errors, "\n[%d/%d]: %s --> %s\n",
i+1, urlnum, url, outfile ? outfile : "<stdout>");
i+1, urlnum, this_url, outfile ? outfile : "<stdout>");
if(separator)
printf("%s%s\n", CURLseparator, url);
printf("%s%s\n", CURLseparator, this_url);
}
if(httpgetfields) {
char *urlbuffer;
/* Find out whether the url contains a file name */
const char *pc = strstr(url, "://");
const char *pc = strstr(this_url, "://");
char sep = '?';
if(pc)
pc += 3;
else
pc = url;
pc = this_url;
pc = strrchr(pc, '/'); /* check for a slash */
@ -4272,21 +4290,21 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
/*
* Then append ? followed by the get fields to the url.
*/
urlbuffer = malloc(strlen(url) + strlen(httpgetfields) + 3);
urlbuffer = malloc(strlen(this_url) + strlen(httpgetfields) + 3);
if(!urlbuffer) {
res = CURLE_OUT_OF_MEMORY;
goto show_error;
}
if(pc)
sprintf(urlbuffer, "%s%c%s", url, sep, httpgetfields);
sprintf(urlbuffer, "%s%c%s", this_url, sep, httpgetfields);
else
/* Append / before the ? to create a well-formed url
if the url contains a hostname only
*/
sprintf(urlbuffer, "%s/?%s", url, httpgetfields);
sprintf(urlbuffer, "%s/?%s", this_url, httpgetfields);
Curl_safefree(url); /* free previous URL */
url = urlbuffer; /* use our new URL instead! */
Curl_safefree(this_url); /* free previous URL */
this_url = urlbuffer; /* use our new URL instead! */
}
if(!config->errors)
@ -4312,7 +4330,7 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
my_setopt(curl, CURLOPT_READDATA, &input);
/* what call to read */
if((outfile && !curlx_strequal("-", outfile)) ||
!checkprefix("telnet:", url))
!checkprefix("telnet:", this_url))
my_setopt(curl, CURLOPT_READFUNCTION, my_fread);
/* in 7.18.0, the CURLOPT_SEEKFUNCTION/DATA pair is taking over what
@ -4328,7 +4346,7 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
/* size of uploaded file: */
if(uploadfilesize != -1)
my_setopt(curl, CURLOPT_INFILESIZE_LARGE, uploadfilesize);
my_setopt_str(curl, CURLOPT_URL, url); /* what to fetch */
my_setopt_str(curl, CURLOPT_URL, this_url); /* what to fetch */
my_setopt(curl, CURLOPT_NOPROGRESS, config->noprogress);
if(config->no_body) {
my_setopt(curl, CURLOPT_NOBODY, 1);
@ -4741,8 +4759,12 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
my_setopt_str(curl, CURLOPT_GSSAPI_DELEGATION,
config->gssapi_delegation);
retry_numretries = config->req_retry;
/* initialize retry vars for loop below */
retry_sleep_default = (config->retry_delay) ?
config->retry_delay*1000L : RETRY_SLEEP_DEFAULT; /* ms */
retry_numretries = config->req_retry;
retry_sleep = retry_sleep_default; /* ms */
retrystart = cutil_tvnow();
for(;;) {
@ -4761,7 +4783,7 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
if(retry_numretries &&
(!config->retry_maxtime ||
(cutil_tvdiff(cutil_tvnow(), retrystart)<
config->retry_maxtime*1000)) ) {
config->retry_maxtime*1000L)) ) {
enum {
RETRY_NO,
RETRY_TIMEOUT,
@ -4779,10 +4801,10 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
/* If it returned OK. _or_ failonerror was enabled and it
returned due to such an error, check for HTTP transient
errors to retry on. */
char *this_url=NULL;
curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &this_url);
if(this_url &&
checkprefix("http", this_url)) {
char *effective_url = NULL;
curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &effective_url);
if(effective_url &&
checkprefix("http", effective_url)) {
/* This was HTTP(S) */
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response);
@ -4825,7 +4847,7 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
warnf(config, "Transient problem: %s "
"Will retry in %ld seconds. "
"%ld retries left.\n",
m[retry], retry_sleep/1000, retry_numretries);
m[retry], retry_sleep/1000L, retry_numretries);
go_sleep(retry_sleep);
retry_numretries--;
@ -4870,7 +4892,6 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
} /* if retry_numretries */
/* In all ordinary cases, just break out of loop here */
retry_sleep = retry_sleep_default;
break; /* curl_easy_perform loop */
}
@ -4974,30 +4995,15 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
}
#endif
/* Cleanup loop-local variables for next loop iteration or exit */
/* Free loop-local allocated memory and close loop-local opened fd */
Curl_safefree(outfile);
Curl_safefree(this_url);
if(infdopen) {
close(infd);
infdopen = FALSE; /* not needed */
infd = STDIN_FILENO; /* not needed */
}
Curl_safefree(outfile);
/* ... */
Curl_safefree(url);
if(res) {
/* Free list of remaining URLs */
if(urls) {
glob_cleanup(urls);
urls = NULL;
}
/* Free list of globbed upload files */
if(inglob) {
glob_cleanup(inglob);
inglob = NULL;
}
infdopen = FALSE;
infd = STDIN_FILENO;
}
/* upon error exit loop */
@ -5006,52 +5012,84 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
} /* loop to the next URL */
/* Free loop-local allocated memory and close loop-local opened fd */
Curl_safefree(uploadfile);
if(urls) {
/* cleanup memory used for URL globbing patterns */
/* Free list of remaining URLs */
glob_cleanup(urls);
urls = NULL;
}
Curl_safefree(uploadfile);
/* upon error exit loop */
if(res)
break;
} /* loop to the next globbed upload file */
/* Free loop-local allocated memory and close loop-local opened fd */
Curl_safefree(outfiles);
if(inglob) {
/* Free list of globbed upload files */
glob_cleanup(inglob);
inglob = NULL;
}
Curl_safefree(outfiles);
/* empty this urlnode struct */
/* Free this URL node data without destroying the
the node itself nor modifying next pointer. */
Curl_safefree(urlnode->url);
Curl_safefree(urlnode->outfile);
Curl_safefree(urlnode->infile);
urlnode->flags = 0;
/* move on to the next URL */
nextnode=urlnode->next;
Curl_safefree(urlnode); /* free the node */
urlnode = nextnode;
/*
** Bail out upon critical errors
*/
switch(res) {
case CURLE_FAILED_INIT:
case CURLE_OUT_OF_MEMORY:
case CURLE_FUNCTION_NOT_FOUND:
case CURLE_BAD_FUNCTION_ARGUMENT:
goto quit_curl;
default:
/* Merrily loop to next URL */
break;
}
} /* while-loop through all URLs */
} /* for-loop through all URLs */
/*
** Nested loops end here.
*/
quit_curl:
/* Free function-local referenced allocated memory */
Curl_safefree(httpgetfields);
Curl_safefree(config->engine);
/* Free list of given URLs */
clean_getout(config);
/* cleanup the curl handle! */
curl_easy_cleanup(curl);
config->easy = NULL; /* cleanup now */
/* Cleanup the curl handle now that our
progressbar struct is still in scope */
if(curl) {
curl_easy_cleanup(curl);
config->easy = curl = NULL;
}
if(easysrc)
curl_slist_append(easysrc, "curl_easy_cleanup(hnd);");
if(heads.stream && (heads.stream != stdout))
fclose(heads.stream);
/* Close function-local opened file descriptors */
if(config->headerfile) {
if(strcmp(heads.filename, "-") && heads.stream)
fclose(heads.stream);
if(heads.alloc_filename)
Curl_safefree(heads.filename);
}
if(config->trace_fopened && config->trace_stream)
fclose(config->trace_stream);
@ -5061,7 +5099,7 @@ operate(struct Configurable *config, int argc, argv_item_t argv[])
so not everything can be closed and cleaned before this is called */
dumpeasysrc(config);
if(config->errors_fopened)
if(config->errors_fopened && config->errors)
fclose(config->errors);
main_free(); /* cleanup */

29
src/tool_cfgable.c
View File

@ -31,6 +31,8 @@
void free_config_fields(struct Configurable *config)
{
struct getout *urlnode;
if(config->easy) {
curl_easy_cleanup(config->easy);
config->easy = NULL;
@ -65,10 +67,19 @@ void free_config_fields(struct Configurable *config)
Curl_safefree(config->netrc_file);
/* config->url_list not handled */
/* config->url_last not handled */
/* config->url_get not handled */
/* config->url_out not handled */
urlnode = config->url_list;
while(urlnode) {
struct getout *next = urlnode->next;
Curl_safefree(urlnode->url);
Curl_safefree(urlnode->outfile);
Curl_safefree(urlnode->infile);
Curl_safefree(urlnode);
urlnode = next;
}
config->url_list = NULL;
config->url_last = NULL;
config->url_get = NULL;
config->url_out = NULL;
Curl_safefree(config->cipher_list);
Curl_safefree(config->cert);
@ -81,18 +92,17 @@ void free_config_fields(struct Configurable *config)
Curl_safefree(config->key_passwd);
Curl_safefree(config->pubkey);
Curl_safefree(config->hostpubmd5);
/* config->engine not handled */
Curl_safefree(config->engine);
Curl_safefree(config->customrequest);
Curl_safefree(config->krblevel);
Curl_safefree(config->trace_dump);
/* config->trace_stream not handled */
config->trace_stream = NULL; /* closed elsewhere when appropriate */
Curl_safefree(config->writeout);
/* config->errors not handled */
config->errors = NULL; /* closed elsewhere when appropriate */
curl_slist_free_all(config->quote);
curl_slist_free_all(config->postquote);
@ -118,7 +128,6 @@ void free_config_fields(struct Configurable *config)
Curl_safefree(config->libcurl);
/* config->outs not handled */
config->outs = NULL; /* closed elsewhere when appropriate */
}

3
src/tool_sdecls.h
View File

@ -58,9 +58,6 @@ struct OutStruct {
* or a file descriptor as returned from an 'open' call for some file.
*
* 'config' member is a pointer to associated 'Configurable' struct.
*
* TODO: evaluate if an additional struct member should be added to
* allow easier handling of 'stdin' vs other 'file' descriptors.
*/
struct InStruct {