Make voutf() always add one.
Closes #11226
#ifdef DEBUGBUILD
if(size * nmemb > (size_t)CURL_MAX_HTTP_HEADER) {
warnf(per->config->global, "Header data exceeds single call write "
- "limit!\n");
+ "limit!");
return CURL_WRITEFUNC_ERROR;
}
#endif
DEBUGASSERT(config);
global = config->global;
if(!fname || !*fname) {
- warnf(global, "Remote filename has no length!\n");
+ warnf(global, "Remote filename has no length!");
return FALSE;
}
if(config->output_dir && outs->is_cd_filename) {
aname = aprintf("%s/%s", config->output_dir, fname);
if(!aname) {
- errorf(global, "out of memory\n");
+ errorf(global, "out of memory");
return FALSE;
}
fname = aname;
/* Guard against wraparound in new filename */
if(newlen < len) {
free(aname);
- errorf(global, "overflow in filename generation\n");
+ errorf(global, "overflow in filename generation");
return FALSE;
}
newname = malloc(newlen);
if(!newname) {
- errorf(global, "out of memory\n");
+ errorf(global, "out of memory");
free(aname);
return FALSE;
}
}
if(!file) {
- warnf(global, "Failed to open the file %s: %s\n", fname,
+ warnf(global, "Failed to open the file %s: %s", fname,
strerror(errno));
free(aname);
return FALSE;
if(config->show_headers) {
if(bytes > (size_t)CURL_MAX_HTTP_HEADER) {
warnf(config->global, "Header data size exceeds single call write "
- "limit!\n");
+ "limit!");
return CURL_WRITEFUNC_ERROR;
}
}
else {
if(bytes > (size_t)CURL_MAX_WRITE_SIZE) {
- warnf(config->global, "Data size exceeds single call write limit!\n");
+ warnf(config->global, "Data size exceeds single call write limit!");
return CURL_WRITEFUNC_ERROR;
}
}
check_fails = TRUE;
}
if(check_fails) {
- warnf(config->global, "Invalid output struct data for write callback\n");
+ warnf(config->global, "Invalid output struct data for write callback");
return CURL_WRITEFUNC_ERROR;
}
}
if(memchr(buffer, 0, bytes)) {
warnf(config->global, "Binary output can mess up your terminal. "
"Use \"--output -\" to tell curl to output it to your terminal "
- "anyway, or consider \"--output <FILE>\" to save to a file.\n");
+ "anyway, or consider \"--output <FILE>\" to save to a file.");
config->synthetic_error = TRUE;
return CURL_WRITEFUNC_ERROR;
}
else
out = stdout;
if(!out)
- warnf(config, "Failed to open %s to write libcurl code!\n", o);
+ warnf(config, "Failed to open %s to write libcurl code!", o);
else {
int i;
const char *c;
| ((curl_off_t)ft.dwHighDateTime) << 32;
if(converted < CURL_OFF_T_C(116444736000000000)) {
- warnf(global, "Failed to get filetime: underflow\n");
+ warnf(global, "Failed to get filetime: underflow");
}
else {
result = (converted - CURL_OFF_T_C(116444736000000000)) / 10000000;
}
else {
warnf(global, "Failed to get filetime: "
- "GetFileTime failed: GetLastError %u\n",
+ "GetFileTime failed: GetLastError %u",
(unsigned int)GetLastError());
}
CloseHandle(hfile);
}
else if(GetLastError() != ERROR_FILE_NOT_FOUND) {
warnf(global, "Failed to get filetime: "
- "CreateFile failed: GetLastError %u\n",
+ "CreateFile failed: GetLastError %u",
(unsigned int)GetLastError());
}
#else
result = (curl_off_t)statbuf.st_mtime;
}
else if(errno != ENOENT) {
- warnf(global, "Failed to get filetime: %s\n", strerror(errno));
+ warnf(global, "Failed to get filetime: %s", strerror(errno));
}
#endif
return result;
Windows FILETIME without overflow: 30827-12-31T23:59:59. */
if(filetime > CURL_OFF_T_C(910670515199)) {
warnf(global, "Failed to set filetime %" CURL_FORMAT_CURL_OFF_T
- " on outfile: overflow\n", filetime);
+ " on outfile: overflow", filetime);
curlx_unicodefree(tchar_filename);
return;
}
ft.dwHighDateTime = (DWORD)(converted >> 32);
if(!SetFileTime(hfile, NULL, &ft, &ft)) {
warnf(global, "Failed to set filetime %" CURL_FORMAT_CURL_OFF_T
- " on outfile: SetFileTime failed: GetLastError %u\n",
+ " on outfile: SetFileTime failed: GetLastError %u",
filetime, (unsigned int)GetLastError());
}
CloseHandle(hfile);
}
else {
warnf(global, "Failed to set filetime %" CURL_FORMAT_CURL_OFF_T
- " on outfile: CreateFile failed: GetLastError %u\n",
+ " on outfile: CreateFile failed: GetLastError %u",
filetime, (unsigned int)GetLastError());
}
times[0].tv_usec = times[1].tv_usec = 0;
if(utimes(filename, times)) {
warnf(global, "Failed to set filetime %" CURL_FORMAT_CURL_OFF_T
- " on '%s': %s\n", filetime, filename, strerror(errno));
+ " on '%s': %s", filetime, filename, strerror(errno));
}
#elif defined(HAVE_UTIME)
times.modtime = (time_t)filetime;
if(utime(filename, ×)) {
warnf(global, "Failed to set filetime %" CURL_FORMAT_CURL_OFF_T
- " on '%s': %s\n", filetime, filename, strerror(errno));
+ " on '%s': %s", filetime, filename, strerror(errno));
}
#endif
}
if(ferror(stdin)) {
/* Show error only once. */
if(sip->config) {
- warnf(sip->config, "stdin: %s\n", strerror(errno));
+ warnf(sip->config, "stdin: %s", strerror(errno));
sip->config = NULL;
}
return CURL_READFUNC_ABORT;
++ptr;
}
if(trailing_data)
- warnf(config->global, "Trailing data after quoted form parameter\n");
+ warnf(config->global, "Trailing data after quoted form parameter");
*str = ptr;
return word_begin + 1;
}
pos++;
if(!incomment) {
if(hdrlen == sizeof(hdrbuf) - 1) {
- warnf(config->global, "File %s line %d: header too long (truncated)\n",
+ warnf(config->global, "File %s line %d: header too long (truncated)",
filename, lineno);
c = ' ';
}
/* verify that this is a fine type specifier */
if(2 != sscanf(type, "%127[^/ ]/%127[^;, \n]", type_major, type_minor)) {
- warnf(config->global, "Illegally formatted content-type field!\n");
+ warnf(config->global, "Illegally formatted content-type field!");
curl_slist_free_all(headers);
return -1; /* illegal content-type syntax! */
}
*endpos = '\0';
fp = fopen(hdrfile, FOPEN_READTEXT);
if(!fp)
- warnf(config->global, "Cannot read from %s: %s\n", hdrfile,
+ warnf(config->global, "Cannot read from %s: %s", hdrfile,
strerror(errno));
else {
int i = read_field_headers(config, hdrfile, fp, &headers);
sep = *p;
*endpos = '\0';
if(*unknown)
- warnf(config->global, "skip unknown form field: %s\n", unknown);
+ warnf(config->global, "skip unknown form field: %s", unknown);
}
}
if(ptype)
*ptype = type;
else if(type)
- warnf(config->global, "Field content type not allowed here: %s\n", type);
+ warnf(config->global, "Field content type not allowed here: %s", type);
if(pfilename)
*pfilename = filename;
else if(filename)
warnf(config->global,
- "Field file name not allowed here: %s\n", filename);
+ "Field file name not allowed here: %s", filename);
if(pencoder)
*pencoder = encoder;
else if(encoder)
warnf(config->global,
- "Field encoder not allowed here: %s\n", encoder);
+ "Field encoder not allowed here: %s", encoder);
if(pheaders)
*pheaders = headers;
else if(headers) {
warnf(config->global,
- "Field headers not allowed here: %s\n", headers->data);
+ "Field headers not allowed here: %s", headers->data);
curl_slist_free_all(headers);
}
else if(!name && !strcmp(contp, ")") && !literal_value) {
/* Ending a multipart. */
if(*mimecurrent == *mimeroot) {
- warnf(config->global, "no multipart to terminate!\n");
+ warnf(config->global, "no multipart to terminate!");
goto fail;
}
*mimecurrent = (*mimecurrent)->parent;
libcurl. */
if(part->size > 0) {
warnf(config->global,
- "error while reading standard input\n");
+ "error while reading standard input");
goto fail;
}
Curl_safefree(part->data);
libcurl. */
if(part->size > 0) {
warnf(config->global,
- "error while reading standard input\n");
+ "error while reading standard input");
goto fail;
}
Curl_safefree(part->data);
if(sep) {
*contp = (char) sep;
warnf(config->global,
- "garbage at end of field specification: %s\n", contp);
+ "garbage at end of field specification: %s", contp);
}
}
SET_TOOL_MIME_PTR(part, name);
}
else {
- warnf(config->global, "Illegally formatted input field!\n");
+ warnf(config->global, "Illegally formatted input field!");
goto fail;
}
err = 0;
curl_off_t value;
if(curlx_strtoofft(arg, &unit, 10, &value)) {
- warnf(global, "invalid number specified for %s\n", which);
+ warnf(global, "invalid number specified for %s", which);
return PARAM_BAD_USE;
}
/* for plain bytes, leave as-is */
break;
default:
- warnf(global, "unsupported %s unit. Use G, M, K or B!\n", which);
+ warnf(global, "unsupported %s unit. Use G, M, K or B!", which);
return PARAM_BAD_USE;
}
*value_out = value;
if(!file)
warnf(global,
"Couldn't read data from file \"%s\", this makes "
- "an empty POST.\n", nextarg);
+ "an empty POST.", nextarg);
}
err = file2memory(&postdata, &size, file);
{
if(config->httpversion &&
(config->httpversion != httpversion))
- warnf(global, "Overrides previous HTTP version option\n");
+ warnf(global, "Overrides previous HTTP version option");
config->httpversion = httpversion;
}
if((aliases[hit].desc == ARG_FILENAME) &&
(nextarg[0] == '-') && nextarg[1]) {
/* if the file name looks like a command line option */
- warnf(global, "The file name argument '%s' looks like a flag.\n",
+ warnf(global, "The file name argument '%s' looks like a flag.",
nextarg);
}
}
case 'g': /* --trace */
GetStr(&global->trace_dump, nextarg);
if(global->tracetype && (global->tracetype != TRACE_BIN))
- warnf(global, "--trace overrides an earlier trace/verbose option\n");
+ warnf(global, "--trace overrides an earlier trace/verbose option");
global->tracetype = TRACE_BIN;
break;
case 'G': /* --npn */
- warnf(global, "--npn is no longer supported\n");
+ warnf(global, "--npn is no longer supported");
break;
case 'h': /* --trace-ascii */
GetStr(&global->trace_dump, nextarg);
if(global->tracetype && (global->tracetype != TRACE_ASCII))
warnf(global,
- "--trace-ascii overrides an earlier trace/verbose option\n");
+ "--trace-ascii overrides an earlier trace/verbose option");
global->tracetype = TRACE_ASCII;
break;
case 'H': /* --alpn */
numerator = 24*60*60*1000;
break;
default:
- errorf(global, "unsupported --rate unit\n");
+ errorf(global, "unsupported --rate unit");
return PARAM_BAD_USE;
}
}
config->ftp_ssl = toggle;
if(config->ftp_ssl)
warnf(global,
- "--ssl is an insecure option, consider --ssl-reqd instead\n");
+ "--ssl is an insecure option, consider --ssl-reqd instead");
break;
case 'b': /* --ftp-pasv */
Curl_safefree(config->ftpport);
case 'z': /* --libcurl */
#ifdef CURL_DISABLE_LIBCURL_OPTION
warnf(global,
- "--libcurl option was disabled at build-time!\n");
+ "--libcurl option was disabled at build-time!");
return PARAM_OPTION_UNKNOWN;
#else
GetStr(&global->libcurl, nextarg);
GetStr(&config->mail_auth, nextarg);
break;
case 'J': /* --metalink */
- errorf(global, "--metalink is disabled\n");
+ errorf(global, "--metalink is disabled");
return PARAM_BAD_USE;
case '6': /* --sasl-authzid */
GetStr(&config->sasl_authzid, nextarg);
#ifdef CURLDEBUG
global->test_event_based = toggle;
#else
- warnf(global, "--test-event is ignored unless a debug build!\n");
+ warnf(global, "--test-event is ignored unless a debug build!");
#endif
break;
case 'M': /* --unix-socket */
break;
case '2':
/* SSL version 2 */
- warnf(global, "Ignores instruction to use SSLv2\n");
+ warnf(global, "Ignores instruction to use SSLv2");
break;
case '3':
/* SSL version 3 */
- warnf(global, "Ignores instruction to use SSLv3\n");
+ warnf(global, "Ignores instruction to use SSLv3");
break;
case '4':
/* IPv4 */
file = fopen(nextarg, "rb");
if(!file)
warnf(global, "Couldn't read data from file \"%s\", this makes "
- "an empty POST.\n", nextarg);
+ "an empty POST.", nextarg);
}
if((subletter == 'b') || /* --data-binary */
}
if(config->failonerror && config->failwithbody) {
errorf(config->global, "You must select either --fail or "
- "--fail-with-body, not both.\n");
+ "--fail-with-body, not both.");
return PARAM_BAD_USE;
}
break;
bool use_stdin = !strcmp(&nextarg[1], "-");
FILE *file = use_stdin?stdin:fopen(&nextarg[1], FOPEN_READTEXT);
if(!file)
- warnf(global, "Failed to open %s!\n", &nextarg[1]);
+ warnf(global, "Failed to open %s!", &nextarg[1]);
else {
err = file2memory(&string, &len, file);
if(!err && string) {
break;
case 'K': /* parse config file */
if(parseconfig(nextarg, global)) {
- errorf(global, "cannot read config from '%s'\n", nextarg);
+ errorf(global, "cannot read config from '%s'", nextarg);
return PARAM_READ_ERROR;
}
break;
if(toggle) { /* --no-manual shows no manual... */
#ifndef USE_MANUAL
warnf(global,
- "built-in manual was disabled at build-time!\n");
+ "built-in manual was disabled at build-time");
#endif
return PARAM_MANUAL_REQUESTED;
}
/* fill in the outfile */
if('o' == letter) {
if(!*nextarg) {
- warnf(global, "output file name has no length\n");
+ warnf(global, "output file name has no length");
return PARAM_BAD_USE;
}
GetStr(&url->outfile, nextarg);
char buffer[32];
curl_off_t off;
if(curlx_strtoofft(nextarg, NULL, 10, &off)) {
- warnf(global, "unsupported range point\n");
+ warnf(global, "unsupported range point");
return PARAM_BAD_USE;
}
warnf(global,
"A specified range MUST include at least one dash (-). "
- "Appending one for you!\n");
+ "Appending one for you!");
msnprintf(buffer, sizeof(buffer), "%" CURL_FORMAT_CURL_OFF_T "-", off);
Curl_safefree(config->range);
config->range = strdup(buffer);
warnf(global, "Invalid character is found in given range. "
"A specified range MUST have only digits in "
"\'start\'-\'stop\'. The server's response to this "
- "request is uncertain.\n");
+ "request is uncertain.");
break;
}
tmp_range++;
return PARAM_NO_MEM;
if(global->tracetype && (global->tracetype != TRACE_PLAIN))
warnf(global,
- "-v, --verbose overrides an earlier trace/verbose option\n");
+ "-v, --verbose overrides an earlier trace/verbose option");
global->tracetype = TRACE_PLAIN;
}
else
warnf(global,
"Illegal date format for -z, --time-cond (and not "
"a file name). Disabling time condition. "
- "See curl_getdate(3) for valid date syntax.\n");
+ "See curl_getdate(3) for valid date syntax.");
}
}
break;
result = PARAM_NO_MEM;
}
else {
- errorf(global, "missing URL before --next\n");
+ errorf(global, "missing URL before --next");
result = PARAM_BAD_USE;
}
}
const char *reason = param2text(result);
if(orig_opt && strcmp(":", orig_opt))
- helpf(stderr, "option %s: %s\n", orig_opt, reason);
+ helpf(stderr, "option %s: %s", orig_opt, reason);
else
- helpf(stderr, "%s\n", reason);
+ helpf(stderr, "%s", reason);
}
curlx_unicodefree(orig_opt);
return 0;
}
warnf(config->global, "You can only select one HTTP request method! "
- "You asked for both %s and %s.\n",
+ "You asked for both %s and %s.",
reqname[req], reqname[*store]);
return 1;
;
else if(curl_strequal(method, dflt[req])) {
notef(config->global, "Unnecessary use of -X or --request, %s is already "
- "inferred.\n", dflt[req]);
+ "inferred.", dflt[req]);
}
else if(curl_strequal(method, "head")) {
warnf(config->global,
"Setting custom HTTP method to HEAD with -X/--request may not work "
- "the way you want. Consider using -I/--head instead.\n");
+ "the way you want. Consider using -I/--head instead.");
}
}
config->first->global = config;
}
else {
- errorf(config, "error retrieving curl library information\n");
+ errorf(config, "error retrieving curl library information");
free(config->first);
}
}
else {
- errorf(config, "error initializing curl library\n");
+ errorf(config, "error initializing curl library");
free(config->first);
}
}
else {
- errorf(config, "error initializing curl\n");
+ errorf(config, "error initializing curl");
result = CURLE_FAILED_INIT;
}
va_list ap)
{
size_t width = (79 - strlen(prefix));
+ DEBUGASSERT(!strchr(fmt, '\n'));
if(!config->silent) {
size_t len;
char *ptr;
}
else {
fputs(ptr, stderr);
+ fputs("\n", stderr);
len = 0;
}
}
if(fmt) {
va_list ap;
va_start(ap, fmt);
+ DEBUGASSERT(!strchr(fmt, '\n'));
fputs("curl: ", errors); /* prefix it */
vfprintf(errors, fmt, ap);
va_end(ap);
+ fputs("\n", errors); /* newline it */
}
fprintf(errors, "curl: try 'curl --help' "
#ifdef USE_MANUAL
if((per->infd == -1) || fstat(per->infd, &fileinfo))
#endif
{
- helpf(stderr, "Can't open '%s'!\n", per->uploadfile);
+ helpf(stderr, "Can't open '%s'", per->uploadfile);
if(per->infd != -1) {
close(per->infd);
per->infd = STDIN_FILENO;
if(!result && config->xattr && outs->fopened && outs->stream) {
int rc = fwrite_xattr(curl, per->this_url, fileno(outs->stream));
if(rc)
- warnf(config->global, "Error setting extended attributes on '%s': %s\n",
+ warnf(config->global, "Error setting extended attributes on '%s': %s",
outs->filename, strerror(errno));
}
}
warnf(config->global, "Problem %s. "
"Will retry in %ld seconds. "
- "%ld retries left.\n",
+ "%ld retries left.",
m[retry], sleeptime/1000L, per->retry_numretries);
per->retry_numretries--;
int rc;
/* We have written data to an output file, we truncate file
*/
- if(!global->silent)
- fprintf(stderr, "Throwing away %" CURL_FORMAT_CURL_OFF_T " bytes\n",
- outs->bytes);
+ notef(config->global,
+ "Throwing away %" CURL_FORMAT_CURL_OFF_T " bytes",
+ outs->bytes);
fflush(outs->stream);
/* truncate file at the position where we started appending */
#ifdef HAVE_FTRUNCATE
fprintf(stderr, "curl: (%d) Failed writing body\n", result);
}
if(result && config->rm_partial) {
- notef(global, "Removing output file: %s\n", outs->filename);
+ notef(global, "Removing output file: %s", outs->filename);
unlink(outs->filename);
}
}
httpgetfields = state->httpgetfields = strdup(config->postfields);
Curl_safefree(config->postfields);
if(!httpgetfields) {
- errorf(global, "out of memory\n");
+ errorf(global, "out of memory");
result = CURLE_OUT_OF_MEMORY;
}
else if(SetHTTPrequest(config,
state->up = 0;
if(!warn_more_options) {
/* only show this once */
- warnf(config->global, "Got more output options than URLs\n");
+ warnf(config->global, "Got more output options than URLs");
warn_more_options = TRUE;
}
continue; /* next URL please */
if(urlnode->outfile && !state->outfiles) {
state->outfiles = strdup(urlnode->outfile);
if(!state->outfiles) {
- errorf(global, "out of memory\n");
+ errorf(global, "out of memory");
result = CURLE_OUT_OF_MEMORY;
break;
}
if(inglob) {
result = glob_next_url(&state->uploadfile, inglob);
if(result == CURLE_OUT_OF_MEMORY)
- errorf(global, "out of memory\n");
+ errorf(global, "out of memory");
}
else if(!state->up) {
state->uploadfile = strdup(infiles);
if(!state->uploadfile) {
- errorf(global, "out of memory\n");
+ errorf(global, "out of memory");
result = CURLE_OUT_OF_MEMORY;
}
}
FILE *file = fopen(config->etag_compare_file, FOPEN_READTEXT);
if(!file && !config->etag_save_file) {
errorf(global,
- "Failed to open %s\n", config->etag_compare_file);
+ "Failed to open %s", config->etag_compare_file);
result = CURLE_READ_ERROR;
break;
}
if(file)
fclose(file);
errorf(global,
- "Failed to allocate memory for custom etag header\n");
+ "Failed to allocate memory for custom etag header");
result = CURLE_OUT_OF_MEMORY;
break;
}
FILE *newfile = fopen(config->etag_save_file, "wb");
if(!newfile) {
warnf(global, "Failed creating file for saving etags: \"%s\". "
- "Skip this transfer\n", config->etag_save_file);
+ "Skip this transfer", config->etag_save_file);
Curl_safefree(state->outfiles);
glob_cleanup(state->urls);
return CURLE_OK;
newfile = fopen(config->headerfile, "ab");
if(!newfile) {
- errorf(global, "Failed to open %s\n", config->headerfile);
+ errorf(global, "Failed to open %s", config->headerfile);
result = CURLE_WRITE_ERROR;
break;
}
result = get_url_file_name(&per->outfile, per->this_url);
if(result) {
errorf(global, "Failed to extract a sensible file name"
- " from the URL to use for storage!\n");
+ " from the URL to use for storage!");
break;
}
if(!*per->outfile && !config->content_disposition) {
- errorf(global, "Remote file name has no length!\n");
+ errorf(global, "Remote file name has no length!");
result = CURLE_WRITE_ERROR;
break;
}
Curl_safefree(storefile);
if(result) {
/* bad globbing */
- warnf(global, "bad output glob!\n");
+ warnf(global, "bad output glob!");
break;
}
if(!*per->outfile) {
- warnf(global, "output glob produces empty string!\n");
+ warnf(global, "output glob produces empty string!");
result = CURLE_WRITE_ERROR;
break;
}
FILE *file = fopen(per->outfile, "ab");
#endif
if(!file) {
- errorf(global, "Can't open '%s'!\n", per->outfile);
+ errorf(global, "Can't open '%s'", per->outfile);
result = CURLE_WRITE_ERROR;
break;
}
warnf(global,
"Using --anyauth or --proxy-anyauth with upload from stdin"
" involves a big risk of it not working. Use a temporary"
- " file or a fixed auth type instead!\n");
+ " file or a fixed auth type instead!");
}
DEBUGASSERT(per->infdopen == FALSE);
if(!strcmp(per->uploadfile, ".")) {
if(curlx_nonblock((curl_socket_t)per->infd, TRUE) < 0)
warnf(global,
- "fcntl failed on fd=%d: %s\n", per->infd, strerror(errno));
+ "fcntl failed on fd=%d: %s", per->infd, strerror(errno));
}
}
if(uerr) {
result = urlerr_cvt(uerr);
errorf(global, "(%d) Could not parse the URL, "
- "failed to set query\n", result);
+ "failed to set query", result);
config->synthetic_error = TRUE;
}
else {
my_setopt_str(curl, CURLOPT_PROXY, config->proxy);
if(config->proxy && result) {
- errorf(global, "proxy support is disabled in this libcurl\n");
+ errorf(global, "proxy support is disabled in this libcurl");
config->synthetic_error = TRUE;
result = CURLE_NOT_BUILT_IN;
break;
switch(config->httpreq) {
case HTTPREQ_SIMPLEPOST:
if(config->resume_from) {
- errorf(global, "cannot mix --continue-at with --data\n");
+ errorf(global, "cannot mix --continue-at with --data");
result = CURLE_FAILED_INIT;
}
else {
curl_mime_free(config->mimepost);
config->mimepost = NULL;
if(config->resume_from) {
- errorf(global, "cannot mix --continue-at with --form\n");
+ errorf(global, "cannot mix --continue-at with --form");
result = CURLE_FAILED_INIT;
}
else {
my_setopt(curl, CURLOPT_HTTP09_ALLOWED,
config->http09_allowed ? 1L : 0L);
if(result) {
- errorf(global, "HTTP/0.9 is not supported in this build!\n");
+ errorf(global, "HTTP/0.9 is not supported in this build!");
return result;
}
if(config->capath) {
result = res_setopt_str(curl, CURLOPT_CAPATH, config->capath);
if(result == CURLE_NOT_BUILT_IN) {
- warnf(global, "ignoring %s, not supported by libcurl\n",
+ warnf(global, "ignoring %s, not supported by libcurl",
capath_from_env?
"SSL_CERT_DIR environment variable":"--capath");
}
if(result == CURLE_NOT_BUILT_IN) {
if(config->proxy_capath) {
warnf(global,
- "ignoring --proxy-capath, not supported by libcurl\n");
+ "ignoring --proxy-capath, not supported by libcurl");
}
}
else if(result)
if(result) {
warnf(global,
"skipped provided cookie, the cookie header "
- "would go over %u bytes\n", MAX_COOKIE_LINE);
+ "would go over %u bytes", MAX_COOKIE_LINE);
break;
}
}
if(result)
return result;
if(!added) {
- errorf(global, "no transfer performed\n");
+ errorf(global, "no transfer performed");
return CURLE_READ_ERROR;
}
for(per = transfers; per;) {
milliseconds */
long milli = tvdiff(tvnow(), start);
if(milli < global->ms_per_transfer) {
- notef(global, "Transfer took %ld ms, waits %ldms as set by --rate\n",
+ notef(global, "Transfer took %ld ms, waits %ldms as set by --rate",
milli, global->ms_per_transfer - milli);
/* The transfer took less time than wanted. Wait a little. */
tool_go_sleep(global->ms_per_transfer - milli);
/* Check we have a url */
if(!config->url_list || !config->url_list->url) {
- helpf(stderr, "(%d) no URL specified!\n", CURLE_FAILED_INIT);
+ helpf(stderr, "(%d) no URL specified", CURLE_FAILED_INIT);
return CURLE_FAILED_INIT;
}
if(!config->cacert) {
curl_free(env);
curl_easy_cleanup(curltls);
- errorf(global, "out of memory\n");
+ errorf(global, "out of memory");
return CURLE_OUT_OF_MEMORY;
}
}
if(!config->capath) {
curl_free(env);
curl_easy_cleanup(curltls);
- helpf(stderr, "out of memory\n");
+ errorf(global, "out of memory");
return CURLE_OUT_OF_MEMORY;
}
capath_from_env = true;
if(!config->cacert) {
curl_free(env);
curl_easy_cleanup(curltls);
- errorf(global, "out of memory\n");
+ errorf(global, "out of memory");
return CURLE_OUT_OF_MEMORY;
}
}
}
}
else
- errorf(global, "out of memory\n");
+ errorf(global, "out of memory");
}
}
if no protocols are allowed */
if(action == set)
protoset[0] = NULL;
- warnf(config->global, "unrecognized protocol '%s'\n", token);
+ warnf(config->global, "unrecognized protocol '%s'", token);
}
}
}
if(curl_strequal("multicwd", str))
return CURLFTPMETHOD_MULTICWD;
- warnf(config->global, "unrecognized ftp file method '%s', using default\n",
+ warnf(config->global, "unrecognized ftp file method '%s', using default",
str);
return CURLFTPMETHOD_MULTICWD;
if(curl_strequal("active", str))
return CURLFTPSSL_CCC_ACTIVE;
- warnf(config->global, "unrecognized ftp CCC method '%s', using default\n",
+ warnf(config->global, "unrecognized ftp CCC method '%s', using default",
str);
return CURLFTPSSL_CCC_PASSIVE;
if(curl_strequal("always", str))
return CURLGSSAPI_DELEGATION_FLAG;
- warnf(config->global, "unrecognized delegation method '%s', using none\n",
+ warnf(config->global, "unrecognized delegation method '%s', using none",
str);
return CURLGSSAPI_DELEGATION_NONE;
if(!config->useragent) {
config->useragent = my_useragent();
if(!config->useragent) {
- errorf(config->global, "out of memory\n");
+ errorf(config->global, "out of memory");
result = CURLE_OUT_OF_MEMORY;
}
}
break;
default:
warnf(operation->global, "%s:%d: warning: '%s' uses unquoted "
- "whitespace in the line that may cause side-effects!\n",
+ "whitespace in the line that may cause side-effects!",
filename, lineno, option);
}
}
res != PARAM_VERSION_INFO_REQUESTED &&
res != PARAM_ENGINES_REQUESTED) {
const char *reason = param2text(res);
- warnf(operation->global, "%s:%d: warning: '%s' %s\n",
+ warnf(operation->global, "%s:%d: warning: '%s' %s",
filename, lineno, option, reason);
}
}
#ifdef DEBUGBUILD
if(ret)
- warnf(config, "option %s returned error (%d)\n", name, (int)ret);
+ warnf(config, "option %s returned error (%d)", name, (int)ret);
#endif
nomem:
return ret;
projects / thirdparty / curl.git / commitdiff
