Context Navigation

tool_getparam.c@ 389

Last change on this file since 389 was 389, checked in by coas-nagasima, 5 years ago
ビルドが通るよう更新
Property svn:eol-style set to `native` Property svn:mime-type set to `text/x-csrc;charset=UTF-8`
File size: 69.4 KB

Line
1	/***************************************************************************
2	* _ _ ____ _
3	* Project ___\| \| \| \| _ \\| \|
4	* / __\| \| \| \| \|_) \| \|
5	* \| (__\| \|_\| \| _ <\| \|___
6	* \___\|\___/\|_\| \_\_____\|
7	*
8	* Copyright (C) 1998 - 2017, Daniel Stenberg, <daniel@haxx.se>, et al.
9	*
10	* This software is licensed as described in the file COPYING, which
11	* you should have received as part of this distribution. The terms
12	* are also available at https://curl.haxx.se/docs/copyright.html.
13	*
14	* You may opt to use, copy, modify, merge, publish, distribute and/or sell
15	* copies of the Software, and permit persons to whom the Software is
16	* furnished to do so, under the terms of the COPYING file.
17	*
18	* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19	* KIND, either express or implied.
20	*
21	***************************************************************************/
22	#include "tool_setup.h"
23
24	#include "strcase.h"
25
26	#define ENABLE_CURLX_PRINTF
27	/* use our own printf() functions */
28	#include "curlx.h"
29
30	#include "tool_binmode.h"
31	#include "tool_cfgable.h"
32	#include "tool_cb_prg.h"
33	#include "tool_convert.h"
34	#include "tool_formparse.h"
35	#include "tool_getparam.h"
36	#include "tool_helpers.h"
37	#include "tool_libinfo.h"
38	#include "tool_metalink.h"
39	#include "tool_msgs.h"
40	#include "tool_paramhlp.h"
41	#include "tool_parsecfg.h"
42
43	#include "memdebug.h" /* keep this as LAST include */
44
45	#ifdef MSDOS
46	# define USE_WATT32
47	#endif
48
49	#define GetStr(str,val) do { \
50	if(*(str)) { \
51	free(*(str)); \
52	*(str) = NULL; \
53	} \
54	if((val)) { \
55	*(str) = strdup((val)); \
56	if(!(*(str))) \
57	return PARAM_NO_MEM; \
58	} \
59	} WHILE_FALSE
60
61	struct LongShort {
62	const char letter; / short name option */
63	const char lname; / long name option */
64	enum {
65	ARG_NONE, /* stand-alone but not a boolean */
66	ARG_BOOL, /* accepts a --no-[name] prefix */
67	ARG_STRING /* requires an argument */
68	} desc;
69	};
70
71	static const struct LongShort aliases[]= {
72	/* 'letter' strings with more than one character have no short option to
73	mention. */
74	{"*@", "url", ARG_STRING},
75	{"*4", "dns-ipv4-addr", ARG_STRING},
76	{"*6", "dns-ipv6-addr", ARG_STRING},
77	{"*a", "random-file", ARG_STRING},
78	{"*b", "egd-file", ARG_STRING},
79	{"*B", "oauth2-bearer", ARG_STRING},
80	{"*c", "connect-timeout", ARG_STRING},
81	{"*d", "ciphers", ARG_STRING},
82	{"*D", "dns-interface", ARG_STRING},
83	{"*e", "disable-epsv", ARG_BOOL},
84	{"*E", "epsv", ARG_BOOL},
85	/* 'epsv' made like this to make --no-epsv and --epsv to work
86	although --disable-epsv is the documented option */
87	{"*F", "dns-servers", ARG_STRING},
88	{"*g", "trace", ARG_STRING},
89	{"*G", "npn", ARG_BOOL},
90	{"*h", "trace-ascii", ARG_STRING},
91	{"*H", "alpn", ARG_BOOL},
92	{"*i", "limit-rate", ARG_STRING},
93	{"*j", "compressed", ARG_BOOL},
94	{"*J", "tr-encoding", ARG_BOOL},
95	{"*k", "digest", ARG_BOOL},
96	{"*l", "negotiate", ARG_BOOL},
97	{"*m", "ntlm", ARG_BOOL},
98	{"*M", "ntlm-wb", ARG_BOOL},
99	{"*n", "basic", ARG_BOOL},
100	{"*o", "anyauth", ARG_BOOL},
101	#ifdef USE_WATT32
102	{"*p", "wdebug", ARG_BOOL},
103	#endif
104	{"*q", "ftp-create-dirs", ARG_BOOL},
105	{"*r", "create-dirs", ARG_BOOL},
106	{"*s", "max-redirs", ARG_STRING},
107	{"*t", "proxy-ntlm", ARG_BOOL},
108	{"*u", "crlf", ARG_BOOL},
109	{"*v", "stderr", ARG_STRING},
110	{"*w", "interface", ARG_STRING},
111	{"*x", "krb", ARG_STRING},
112	{"*x", "krb4", ARG_STRING},
113	/* 'krb4' is the previous name */
114	{"*y", "max-filesize", ARG_STRING},
115	{"*z", "disable-eprt", ARG_BOOL},
116	{"*Z", "eprt", ARG_BOOL},
117	/* 'eprt' made like this to make --no-eprt and --eprt to work
118	although --disable-eprt is the documented option */
119	{"*~", "xattr", ARG_BOOL},
120	{"$a", "ftp-ssl", ARG_BOOL},
121	/* 'ftp-ssl' deprecated name since 7.20.0 */
122	{"$a", "ssl", ARG_BOOL},
123	/* 'ssl' new option name in 7.20.0, previously this was ftp-ssl */
124	{"$b", "ftp-pasv", ARG_BOOL},
125	{"$c", "socks5", ARG_STRING},
126	{"$d", "tcp-nodelay", ARG_BOOL},
127	{"$e", "proxy-digest", ARG_BOOL},
128	{"$f", "proxy-basic", ARG_BOOL},
129	{"$g", "retry", ARG_STRING},
130	{"$V", "retry-connrefused", ARG_BOOL},
131	{"$h", "retry-delay", ARG_STRING},
132	{"$i", "retry-max-time", ARG_STRING},
133	{"$k", "proxy-negotiate", ARG_BOOL},
134	{"$m", "ftp-account", ARG_STRING},
135	{"$n", "proxy-anyauth", ARG_BOOL},
136	{"$o", "trace-time", ARG_BOOL},
137	{"$p", "ignore-content-length", ARG_BOOL},
138	{"$q", "ftp-skip-pasv-ip", ARG_BOOL},
139	{"$r", "ftp-method", ARG_STRING},
140	{"$s", "local-port", ARG_STRING},
141	{"$t", "socks4", ARG_STRING},
142	{"$T", "socks4a", ARG_STRING},
143	{"$u", "ftp-alternative-to-user", ARG_STRING},
144	{"$v", "ftp-ssl-reqd", ARG_BOOL},
145	/* 'ftp-ssl-reqd' deprecated name since 7.20.0 */
146	{"$v", "ssl-reqd", ARG_BOOL},
147	/* 'ssl-reqd' new in 7.20.0, previously this was ftp-ssl-reqd */
148	{"$w", "sessionid", ARG_BOOL},
149	/* 'sessionid' listed as --no-sessionid in the help */
150	{"$x", "ftp-ssl-control", ARG_BOOL},
151	{"$y", "ftp-ssl-ccc", ARG_BOOL},
152	{"$j", "ftp-ssl-ccc-mode", ARG_STRING},
153	{"$z", "libcurl", ARG_STRING},
154	{"$#", "raw", ARG_BOOL},
155	{"$0", "post301", ARG_BOOL},
156	{"$1", "keepalive", ARG_BOOL},
157	/* 'keepalive' listed as --no-keepalive in the help */
158	{"$2", "socks5-hostname", ARG_STRING},
159	{"$3", "keepalive-time", ARG_STRING},
160	{"$4", "post302", ARG_BOOL},
161	{"$5", "noproxy", ARG_STRING},
162	{"$7", "socks5-gssapi-nec", ARG_BOOL},
163	{"$8", "proxy1.0", ARG_STRING},
164	{"$9", "tftp-blksize", ARG_STRING},
165	{"$A", "mail-from", ARG_STRING},
166	{"$B", "mail-rcpt", ARG_STRING},
167	{"$C", "ftp-pret", ARG_BOOL},
168	{"$D", "proto", ARG_STRING},
169	{"$E", "proto-redir", ARG_STRING},
170	{"$F", "resolve", ARG_STRING},
171	{"$G", "delegation", ARG_STRING},
172	{"$H", "mail-auth", ARG_STRING},
173	{"$I", "post303", ARG_BOOL},
174	{"$J", "metalink", ARG_BOOL},
175	{"$K", "sasl-ir", ARG_BOOL},
176	{"$L", "test-event", ARG_BOOL},
177	{"$M", "unix-socket", ARG_STRING},
178	{"$N", "path-as-is", ARG_BOOL},
179	{"$O", "socks5-gssapi-service", ARG_STRING},
180	/* 'socks5-gssapi-service' merged with'proxy-service-name' and
181	deprecated since 7.49.0 */
182	{"$O", "proxy-service-name", ARG_STRING},
183	{"$P", "service-name", ARG_STRING},
184	{"$Q", "proto-default", ARG_STRING},
185	{"$R", "expect100-timeout", ARG_STRING},
186	{"$S", "tftp-no-options", ARG_BOOL},
187	{"$U", "connect-to", ARG_STRING},
188	{"$W", "abstract-unix-socket", ARG_STRING},
189	{"$X", "tls-max", ARG_STRING},
190	{"$Y", "suppress-connect-headers", ARG_BOOL},
191	{"$Z", "compressed-ssh", ARG_BOOL},
192	{"0", "http1.0", ARG_NONE},
193	{"01", "http1.1", ARG_NONE},
194	{"02", "http2", ARG_NONE},
195	{"03", "http2-prior-knowledge", ARG_NONE},
196	{"1", "tlsv1", ARG_NONE},
197	{"10", "tlsv1.0", ARG_NONE},
198	{"11", "tlsv1.1", ARG_NONE},
199	{"12", "tlsv1.2", ARG_NONE},
200	{"13", "tlsv1.3", ARG_NONE},
201	{"2", "sslv2", ARG_NONE},
202	{"3", "sslv3", ARG_NONE},
203	{"4", "ipv4", ARG_NONE},
204	{"6", "ipv6", ARG_NONE},
205	{"a", "append", ARG_BOOL},
206	{"A", "user-agent", ARG_STRING},
207	{"b", "cookie", ARG_STRING},
208	{"B", "use-ascii", ARG_BOOL},
209	{"c", "cookie-jar", ARG_STRING},
210	{"C", "continue-at", ARG_STRING},
211	{"d", "data", ARG_STRING},
212	{"dr", "data-raw", ARG_STRING},
213	{"da", "data-ascii", ARG_STRING},
214	{"db", "data-binary", ARG_STRING},
215	{"de", "data-urlencode", ARG_STRING},
216	{"D", "dump-header", ARG_STRING},
217	{"e", "referer", ARG_STRING},
218	{"E", "cert", ARG_STRING},
219	{"Ea", "cacert", ARG_STRING},
220	{"Eb", "cert-type", ARG_STRING},
221	{"Ec", "key", ARG_STRING},
222	{"Ed", "key-type", ARG_STRING},
223	{"Ee", "pass", ARG_STRING},
224	{"Ef", "engine", ARG_STRING},
225	{"Eg", "capath", ARG_STRING},
226	{"Eh", "pubkey", ARG_STRING},
227	{"Ei", "hostpubmd5", ARG_STRING},
228	{"Ej", "crlfile", ARG_STRING},
229	{"Ek", "tlsuser", ARG_STRING},
230	{"El", "tlspassword", ARG_STRING},
231	{"Em", "tlsauthtype", ARG_STRING},
232	{"En", "ssl-allow-beast", ARG_BOOL},
233	{"Eo", "login-options", ARG_STRING},
234	{"Ep", "pinnedpubkey", ARG_STRING},
235	{"Eq", "cert-status", ARG_BOOL},
236	{"Er", "false-start", ARG_BOOL},
237	{"Es", "ssl-no-revoke", ARG_BOOL},
238	{"Et", "tcp-fastopen", ARG_BOOL},
239	{"Eu", "proxy-tlsuser", ARG_STRING},
240	{"Ev", "proxy-tlspassword", ARG_STRING},
241	{"Ew", "proxy-tlsauthtype", ARG_STRING},
242	{"Ex", "proxy-cert", ARG_STRING},
243	{"Ey", "proxy-cert-type", ARG_STRING},
244	{"Ez", "proxy-key", ARG_STRING},
245	{"E0", "proxy-key-type", ARG_STRING},
246	{"E1", "proxy-pass", ARG_STRING},
247	{"E2", "proxy-ciphers", ARG_STRING},
248	{"E3", "proxy-crlfile", ARG_STRING},
249	{"E4", "proxy-ssl-allow-beast", ARG_BOOL},
250	{"E5", "login-options", ARG_STRING},
251	{"E6", "proxy-cacert", ARG_STRING},
252	{"E7", "proxy-capath", ARG_STRING},
253	{"E8", "proxy-insecure", ARG_BOOL},
254	{"E9", "proxy-tlsv1", ARG_NONE},
255	{"EA", "socks5-basic", ARG_BOOL},
256	{"EB", "socks5-gssapi", ARG_BOOL},
257	{"f", "fail", ARG_BOOL},
258	{"fa", "fail-early", ARG_BOOL},
259	{"F", "form", ARG_STRING},
260	{"Fs", "form-string", ARG_STRING},
261	{"g", "globoff", ARG_BOOL},
262	{"G", "get", ARG_NONE},
263	{"Ga", "request-target", ARG_STRING},
264	{"h", "help", ARG_BOOL},
265	{"H", "header", ARG_STRING},
266	{"Hp", "proxy-header", ARG_STRING},
267	{"i", "include", ARG_BOOL},
268	{"I", "head", ARG_BOOL},
269	{"j", "junk-session-cookies", ARG_BOOL},
270	{"J", "remote-header-name", ARG_BOOL},
271	{"k", "insecure", ARG_BOOL},
272	{"K", "config", ARG_STRING},
273	{"l", "list-only", ARG_BOOL},
274	{"L", "location", ARG_BOOL},
275	{"Lt", "location-trusted", ARG_BOOL},
276	{"m", "max-time", ARG_STRING},
277	{"M", "manual", ARG_BOOL},
278	{"n", "netrc", ARG_BOOL},
279	{"no", "netrc-optional", ARG_BOOL},
280	{"ne", "netrc-file", ARG_STRING},
281	{"N", "buffer", ARG_BOOL},
282	/* 'buffer' listed as --no-buffer in the help */
283	{"o", "output", ARG_STRING},
284	{"O", "remote-name", ARG_NONE},
285	{"Oa", "remote-name-all", ARG_BOOL},
286	{"p", "proxytunnel", ARG_BOOL},
287	{"P", "ftp-port", ARG_STRING},
288	{"q", "disable", ARG_BOOL},
289	{"Q", "quote", ARG_STRING},
290	{"r", "range", ARG_STRING},
291	{"R", "remote-time", ARG_BOOL},
292	{"s", "silent", ARG_BOOL},
293	{"S", "show-error", ARG_BOOL},
294	{"t", "telnet-option", ARG_STRING},
295	{"T", "upload-file", ARG_STRING},
296	{"u", "user", ARG_STRING},
297	{"U", "proxy-user", ARG_STRING},
298	{"v", "verbose", ARG_BOOL},
299	{"V", "version", ARG_BOOL},
300	{"w", "write-out", ARG_STRING},
301	{"x", "proxy", ARG_STRING},
302	{"xa", "preproxy", ARG_STRING},
303	{"X", "request", ARG_STRING},
304	{"Y", "speed-limit", ARG_STRING},
305	{"y", "speed-time", ARG_STRING},
306	{"z", "time-cond", ARG_STRING},
307	{"#", "progress-bar", ARG_BOOL},
308	{":", "next", ARG_NONE},
309	};
310
311	/* Split the argument of -E to 'certname' and 'passphrase' separated by colon.
312	* We allow ':' and '\' to be escaped by '\' so that we can use certificate
313	* nicknames containing ':'. See <https://sourceforge.net/p/curl/bugs/1196/>
314	* for details. */
315	#ifndef UNITTESTS
316	static
317	#endif
318	void parse_cert_parameter(const char *cert_parameter,
319	char **certname,
320	char **passphrase)
321	{
322	size_t param_length = strlen(cert_parameter);
323	size_t span;
324	const char *param_place = NULL;
325	char *certname_place = NULL;
326	*certname = NULL;
327	*passphrase = NULL;
328
329	/* most trivial assumption: cert_parameter is empty */
330	if(param_length == 0)
331	return;
332
333	/* next less trivial: cert_parameter starts 'pkcs11:' and thus
334	* looks like a RFC7512 PKCS#11 URI which can be used as-is.
335	* Also if cert_parameter contains no colon nor backslash, this
336	* means no passphrase was given and no characters escaped */
337	if(!strncmp(cert_parameter, "pkcs11:", 7) \|\|
338	!strpbrk(cert_parameter, ":\\")) {
339	*certname = strdup(cert_parameter);
340	return;
341	}
342	/* deal with escaped chars; find unescaped colon if it exists */
343	certname_place = malloc(param_length + 1);
344	if(!certname_place)
345	return;
346
347	*certname = certname_place;
348	param_place = cert_parameter;
349	while(*param_place) {
350	span = strcspn(param_place, ":\\");
351	strncpy(certname_place, param_place, span);
352	param_place += span;
353	certname_place += span;
354	/* we just ate all the non-special chars. now we're on either a special
355	* char or the end of the string. */
356	switch(*param_place) {
357	case '\0':
358	break;
359	case '\\':
360	param_place++;
361	switch(*param_place) {
362	case '\0':
363	*certname_place++ = '\\';
364	break;
365	case '\\':
366	*certname_place++ = '\\';
367	param_place++;
368	break;
369	case ':':
370	*certname_place++ = ':';
371	param_place++;
372	break;
373	default:
374	*certname_place++ = '\\';
375	certname_place++ = param_place;
376	param_place++;
377	break;
378	}
379	break;
380	case ':':
381	/* Since we live in a world of weirdness and confusion, the win32
382	dudes can use : when using drive letters and thus c:\file:password
383	needs to work. In order not to break compatibility, we still use : as
384	separator, but we try to detect when it is used for a file name! On
385	windows. */
386	#ifdef WIN32
387	if(param_place &&
388	(param_place == &cert_parameter[1]) &&
389	(cert_parameter[2] == '\\' \|\| cert_parameter[2] == '/') &&
390	(ISALPHA(cert_parameter[0])) ) {
391	/* colon in the second column, followed by a backslash, and the
392	first character is an alphabetic letter:
393
394	this is a drive letter colon */
395	*certname_place++ = ':';
396	param_place++;
397	break;
398	}
399	#endif
400	/* escaped colons and Windows drive letter colons were handled
401	* above; if we're still here, this is a separating colon */
402	param_place++;
403	if(strlen(param_place) > 0) {
404	*passphrase = strdup(param_place);
405	}
406	goto done;
407	}
408	}
409	done:
410	*certname_place = '\0';
411	}
412
413	static void
414	GetFileAndPassword(char nextarg, char file, char *password)
415	{
416	char certname, passphrase;
417	parse_cert_parameter(nextarg, &certname, &passphrase);
418	Curl_safefree(*file);
419	*file = certname;
420	if(passphrase) {
421	Curl_safefree(*password);
422	*password = passphrase;
423	}
424	cleanarg(nextarg);
425	}
426
427	ParameterError getparameter(const char flag, / f or -long-flag */
428	char nextarg, / NULL if unset */
429	bool usedarg, / set to TRUE if the arg
430	has been used */
431	struct GlobalConfig *global,
432	struct OperationConfig *config)
433	{
434	char letter;
435	char subletter = '\0'; /* subletters can only occur on long options */
436	int rc;
437	const char *parse = NULL;
438	unsigned int j;
439	time_t now;
440	int hit = -1;
441	bool longopt = FALSE;
442	bool singleopt = FALSE; /* when true means '-o foo' used '-ofoo' */
443	ParameterError err;
444	bool toggle = TRUE; /* how to switch boolean options, on or off. Controlled
445	by using --OPTION or --no-OPTION */
446
447	usedarg = FALSE; / default is that we don't use the arg */
448
449	if(('-' != flag[0]) \|\|
450	(('-' == flag[0]) && ('-' == flag[1]))) {
451	/* this should be a long name */
452	const char *word = ('-' == flag[0]) ? flag + 2 : flag;
453	size_t fnam = strlen(word);
454	int numhits = 0;
455
456	if(!strncmp(word, "no-", 3)) {
457	/* disable this option but ignore the "no-" part when looking for it */
458	word += 3;
459	toggle = FALSE;
460	}
461
462	for(j = 0; j < sizeof(aliases)/sizeof(aliases[0]); j++) {
463	if(curl_strnequal(aliases[j].lname, word, fnam)) {
464	longopt = TRUE;
465	numhits++;
466	if(curl_strequal(aliases[j].lname, word)) {
467	parse = aliases[j].letter;
468	hit = j;
469	numhits = 1; /* a single unique hit */
470	break;
471	}
472	parse = aliases[j].letter;
473	hit = j;
474	}
475	}
476	if(numhits > 1) {
477	/* this is at least the second match! */
478	return PARAM_OPTION_AMBIGUOUS;
479	}
480	if(hit < 0) {
481	return PARAM_OPTION_UNKNOWN;
482	}
483	}
484	else {
485	flag++; /* prefixed with one dash, pass it */
486	hit = -1;
487	parse = flag;
488	}
489
490	do {
491	/* we can loop here if we have multiple single-letters */
492
493	if(!longopt) {
494	letter = (char)*parse;
495	subletter = '\0';
496	}
497	else {
498	letter = parse[0];
499	subletter = parse[1];
500	}
501
502	if(hit < 0) {
503	for(j = 0; j < sizeof(aliases)/sizeof(aliases[0]); j++) {
504	if(letter == aliases[j].letter[0]) {
505	hit = j;
506	break;
507	}
508	}
509	if(hit < 0) {
510	return PARAM_OPTION_UNKNOWN;
511	}
512	}
513
514	if(aliases[hit].desc == ARG_STRING) {
515	/* this option requires an extra parameter */
516	if(!longopt && parse[1]) {
517	nextarg = (char )&parse[1]; / this is the actual extra parameter */
518	singleopt = TRUE; /* don't loop anymore after this */
519	}
520	else if(!nextarg)
521	return PARAM_REQUIRES_PARAMETER;
522	else
523	usedarg = TRUE; / mark it as used */
524	}
525	else if((aliases[hit].desc == ARG_NONE) && !toggle)
526	return PARAM_NO_PREFIX;
527
528	switch(letter) {
529	case '': / options without a short option */
530	switch(subletter) {
531	case '4': /* --dns-ipv4-addr */
532	/* addr in dot notation */
533	GetStr(&config->dns_ipv4_addr, nextarg);
534	break;
535	case '6': /* --dns-ipv6-addr */
536	/* addr in dot notation */
537	GetStr(&config->dns_ipv6_addr, nextarg);
538	break;
539	case 'a': /* random-file */
540	GetStr(&config->random_file, nextarg);
541	break;
542	case 'b': /* egd-file */
543	GetStr(&config->egd_file, nextarg);
544	break;
545	case 'B': /* OAuth 2.0 bearer token */
546	GetStr(&config->oauth_bearer, nextarg);
547	break;
548	case 'c': /* connect-timeout */
549	err = str2udouble(&config->connecttimeout, nextarg,
550	LONG_MAX/1000);
551	if(err)
552	return err;
553	break;
554	case 'd': /* ciphers */
555	GetStr(&config->cipher_list, nextarg);
556	break;
557	case 'D': /* --dns-interface */
558	/* interface name */
559	GetStr(&config->dns_interface, nextarg);
560	break;
561	case 'e': /* --disable-epsv */
562	config->disable_epsv = toggle;
563	break;
564	case 'E': /* --epsv */
565	config->disable_epsv = (!toggle)?TRUE:FALSE;
566	break;
567	case 'F': /* --dns-servers */
568	/* IP addrs of DNS servers */
569	GetStr(&config->dns_servers, nextarg);
570	break;
571	case 'g': /* --trace */
572	GetStr(&global->trace_dump, nextarg);
573	if(global->tracetype && (global->tracetype != TRACE_BIN))
574	warnf(global, "--trace overrides an earlier trace/verbose option\n");
575	global->tracetype = TRACE_BIN;
576	break;
577	case 'G': /* --npn */
578	config->nonpn = (!toggle)?TRUE:FALSE;
579	break;
580	case 'h': /* --trace-ascii */
581	GetStr(&global->trace_dump, nextarg);
582	if(global->tracetype && (global->tracetype != TRACE_ASCII))
583	warnf(global,
584	"--trace-ascii overrides an earlier trace/verbose option\n");
585	global->tracetype = TRACE_ASCII;
586	break;
587	case 'H': /* --alpn */
588	config->noalpn = (!toggle)?TRUE:FALSE;
589	break;
590	case 'i': /* --limit-rate */
591	{
592	/* We support G, M, K too */
593	char *unit;
594	curl_off_t value;
595	if(curlx_strtoofft(nextarg, &unit, 0, &value)) {
596	warnf(global, "unsupported rate\n");
597	return PARAM_BAD_USE;
598	}
599
600	if(!*unit)
601	unit = (char *)"b";
602	else if(strlen(unit) > 1)
603	unit = (char )"w"; / unsupported */
604
605	switch(*unit) {
606	case 'G':
607	case 'g':
608	value = 10241024*1024;
609	break;
610	case 'M':
611	case 'm':
612	value = 10241024;
613	break;
614	case 'K':
615	case 'k':
616	value *= 1024;
617	break;
618	case 'b':
619	case 'B':
620	/* for plain bytes, leave as-is */
621	break;
622	default:
623	warnf(global, "unsupported rate unit. Use G, M, K or B!\n");
624	return PARAM_BAD_USE;
625	}
626	config->recvpersecond = value;
627	config->sendpersecond = value;
628	}
629	break;
630
631	case 'j': /* --compressed */
632	if(toggle && !(curlinfo->features & CURL_VERSION_LIBZ))
633	return PARAM_LIBCURL_DOESNT_SUPPORT;
634	config->encoding = toggle;
635	break;
636
637	case 'J': /* --tr-encoding */
638	config->tr_encoding = toggle;
639	break;
640
641	case 'k': /* --digest */
642	if(toggle)
643	config->authtype \|= CURLAUTH_DIGEST;
644	else
645	config->authtype &= ~CURLAUTH_DIGEST;
646	break;
647
648	case 'l': /* --negotiate */
649	if(toggle) {
650	if(curlinfo->features & CURL_VERSION_SPNEGO)
651	config->authtype \|= CURLAUTH_NEGOTIATE;
652	else
653	return PARAM_LIBCURL_DOESNT_SUPPORT;
654	}
655	else
656	config->authtype &= ~CURLAUTH_NEGOTIATE;
657	break;
658
659	case 'm': /* --ntlm */
660	if(toggle) {
661	if(curlinfo->features & CURL_VERSION_NTLM)
662	config->authtype \|= CURLAUTH_NTLM;
663	else
664	return PARAM_LIBCURL_DOESNT_SUPPORT;
665	}
666	else
667	config->authtype &= ~CURLAUTH_NTLM;
668	break;
669
670	case 'M': /* --ntlm-wb */
671	if(toggle) {
672	if(curlinfo->features & CURL_VERSION_NTLM_WB)
673	config->authtype \|= CURLAUTH_NTLM_WB;
674	else
675	return PARAM_LIBCURL_DOESNT_SUPPORT;
676	}
677	else
678	config->authtype &= ~CURLAUTH_NTLM_WB;
679	break;
680
681	case 'n': /* --basic for completeness */
682	if(toggle)
683	config->authtype \|= CURLAUTH_BASIC;
684	else
685	config->authtype &= ~CURLAUTH_BASIC;
686	break;
687
688	case 'o': /* --anyauth, let libcurl pick it */
689	if(toggle)
690	config->authtype = CURLAUTH_ANY;
691	/* --no-anyauth simply doesn't touch it */
692	break;
693
694	#ifdef USE_WATT32
695	case 'p': /* --wdebug */
696	dbug_init();
697	break;
698	#endif
699	case 'q': /* --ftp-create-dirs */
700	config->ftp_create_dirs = toggle;
701	break;
702
703	case 'r': /* --create-dirs */
704	config->create_dirs = toggle;
705	break;
706
707	case 's': /* --max-redirs */
708	/* specified max no of redirects (http(s)), this accepts -1 as a
709	special condition */
710	err = str2num(&config->maxredirs, nextarg);
711	if(err)
712	return err;
713	if(config->maxredirs < -1)
714	return PARAM_BAD_NUMERIC;
715	break;
716
717	case 't': /* --proxy-ntlm */
718	if(curlinfo->features & CURL_VERSION_NTLM)
719	config->proxyntlm = toggle;
720	else
721	return PARAM_LIBCURL_DOESNT_SUPPORT;
722	break;
723
724	case 'u': /* --crlf */
725	/* LF -> CRLF conversion? */
726	config->crlf = toggle;
727	break;
728
729	case 'v': /* --stderr */
730	if(strcmp(nextarg, "-")) {
731	FILE *newfile = fopen(nextarg, FOPEN_WRITETEXT);
732	if(!newfile)
733	warnf(global, "Failed to open %s!\n", nextarg);
734	else {
735	if(global->errors_fopened)
736	fclose(global->errors);
737	global->errors = newfile;
738	global->errors_fopened = TRUE;
739	}
740	}
741	else
742	global->errors = stdout;
743	break;
744	case 'w': /* --interface */
745	/* interface */
746	GetStr(&config->iface, nextarg);
747	break;
748	case 'x': /* --krb */
749	/* kerberos level string */
750	if(curlinfo->features & CURL_VERSION_KERBEROS4)
751	GetStr(&config->krblevel, nextarg);
752	else
753	return PARAM_LIBCURL_DOESNT_SUPPORT;
754	break;
755	case 'y': /* --max-filesize */
756	err = str2offset(&config->max_filesize, nextarg);
757	if(err)
758	return err;
759	break;
760	case 'z': /* --disable-eprt */
761	config->disable_eprt = toggle;
762	break;
763	case 'Z': /* --eprt */
764	config->disable_eprt = (!toggle)?TRUE:FALSE;
765	break;
766	case '~': /* --xattr */
767	config->xattr = toggle;
768	break;
769	case '@': /* the URL! */
770	{
771	struct getout *url;
772
773	if(!config->url_get)
774	config->url_get = config->url_list;
775
776	if(config->url_get) {
777	/* there's a node here, if it already is filled-in continue to find
778	an "empty" node */
779	while(config->url_get && (config->url_get->flags & GETOUT_URL))
780	config->url_get = config->url_get->next;
781	}
782
783	/* now there might or might not be an available node to fill in! */
784
785	if(config->url_get)
786	/* existing node */
787	url = config->url_get;
788	else
789	/* there was no free node, create one! */
790	config->url_get = url = new_getout(config);
791
792	if(!url)
793	return PARAM_NO_MEM;
794
795	/* fill in the URL */
796	GetStr(&url->url, nextarg);
797	url->flags \|= GETOUT_URL;
798	}
799	}
800	break;
801	case '$': /* more options without a short option */
802	switch(subletter) {
803	case 'a': /* --ssl */
804	if(toggle && !(curlinfo->features & CURL_VERSION_SSL))
805	return PARAM_LIBCURL_DOESNT_SUPPORT;
806	config->ftp_ssl = toggle;
807	break;
808	case 'b': /* --ftp-pasv */
809	Curl_safefree(config->ftpport);
810	break;
811	case 'c': /* --socks5 specifies a socks5 proxy to use, and resolves
812	the name locally and passes on the resolved address */
813	GetStr(&config->proxy, nextarg);
814	config->proxyver = CURLPROXY_SOCKS5;
815	break;
816	case 't': /* --socks4 specifies a socks4 proxy to use */
817	GetStr(&config->proxy, nextarg);
818	config->proxyver = CURLPROXY_SOCKS4;
819	break;
820	case 'T': /* --socks4a specifies a socks4a proxy to use */
821	GetStr(&config->proxy, nextarg);
822	config->proxyver = CURLPROXY_SOCKS4A;
823	break;
824	case '2': /* --socks5-hostname specifies a socks5 proxy and enables name
825	resolving with the proxy */
826	GetStr(&config->proxy, nextarg);
827	config->proxyver = CURLPROXY_SOCKS5_HOSTNAME;
828	break;
829	case 'd': /* --tcp-nodelay option */
830	config->tcp_nodelay = toggle;
831	break;
832	case 'e': /* --proxy-digest */
833	config->proxydigest = toggle;
834	break;
835	case 'f': /* --proxy-basic */
836	config->proxybasic = toggle;
837	break;
838	case 'g': /* --retry */
839	err = str2unum(&config->req_retry, nextarg);
840	if(err)
841	return err;
842	break;
843	case 'V': /* --retry-connrefused */
844	config->retry_connrefused = toggle;
845	break;
846	case 'h': /* --retry-delay */
847	err = str2unum(&config->retry_delay, nextarg);
848	if(err)
849	return err;
850	break;
851	case 'i': /* --retry-max-time */
852	err = str2unum(&config->retry_maxtime, nextarg);
853	if(err)
854	return err;
855	break;
856
857	case 'k': /* --proxy-negotiate */
858	if(curlinfo->features & CURL_VERSION_SPNEGO)
859	config->proxynegotiate = toggle;
860	else
861	return PARAM_LIBCURL_DOESNT_SUPPORT;
862	break;
863
864	case 'm': /* --ftp-account */
865	GetStr(&config->ftp_account, nextarg);
866	break;
867	case 'n': /* --proxy-anyauth */
868	config->proxyanyauth = toggle;
869	break;
870	case 'o': /* --trace-time */
871	global->tracetime = toggle;
872	break;
873	case 'p': /* --ignore-content-length */
874	config->ignorecl = toggle;
875	break;
876	case 'q': /* --ftp-skip-pasv-ip */
877	config->ftp_skip_ip = toggle;
878	break;
879	case 'r': /* --ftp-method (undocumented at this point) */
880	config->ftp_filemethod = ftpfilemethod(config, nextarg);
881	break;
882	case 's': /* --local-port */
883	rc = sscanf(nextarg, "%d - %d",
884	&config->localport,
885	&config->localportrange);
886	if(!rc)
887	return PARAM_BAD_USE;
888	if(rc == 1)
889	config->localportrange = 1; /* default number of ports to try */
890	else {
891	config->localportrange -= config->localport;
892	if(config->localportrange < 1) {
893	warnf(global, "bad range input\n");
894	return PARAM_BAD_USE;
895	}
896	}
897	break;
898	case 'u': /* --ftp-alternative-to-user */
899	GetStr(&config->ftp_alternative_to_user, nextarg);
900	break;
901	case 'v': /* --ssl-reqd */
902	if(toggle && !(curlinfo->features & CURL_VERSION_SSL))
903	return PARAM_LIBCURL_DOESNT_SUPPORT;
904	config->ftp_ssl_reqd = toggle;
905	break;
906	case 'w': /* --no-sessionid */
907	config->disable_sessionid = (!toggle)?TRUE:FALSE;
908	break;
909	case 'x': /* --ftp-ssl-control */
910	if(toggle && !(curlinfo->features & CURL_VERSION_SSL))
911	return PARAM_LIBCURL_DOESNT_SUPPORT;
912	config->ftp_ssl_control = toggle;
913	break;
914	case 'y': /* --ftp-ssl-ccc */
915	config->ftp_ssl_ccc = toggle;
916	if(!config->ftp_ssl_ccc_mode)
917	config->ftp_ssl_ccc_mode = CURLFTPSSL_CCC_PASSIVE;
918	break;
919	case 'j': /* --ftp-ssl-ccc-mode */
920	config->ftp_ssl_ccc = TRUE;
921	config->ftp_ssl_ccc_mode = ftpcccmethod(config, nextarg);
922	break;
923	case 'z': /* --libcurl */
924	#ifdef CURL_DISABLE_LIBCURL_OPTION
925	warnf(global,
926	"--libcurl option was disabled at build-time!\n");
927	return PARAM_OPTION_UNKNOWN;
928	#else
929	GetStr(&global->libcurl, nextarg);
930	break;
931	#endif
932	case '#': /* --raw */
933	config->raw = toggle;
934	break;
935	case '0': /* --post301 */
936	config->post301 = toggle;
937	break;
938	case '1': /* --no-keepalive */
939	config->nokeepalive = (!toggle)?TRUE:FALSE;
940	break;
941	case '3': /* --keepalive-time */
942	err = str2unum(&config->alivetime, nextarg);
943	if(err)
944	return err;
945	break;
946	case '4': /* --post302 */
947	config->post302 = toggle;
948	break;
949	case 'I': /* --post303 */
950	config->post303 = toggle;
951	break;
952	case '5': /* --noproxy */
953	/* This specifies the noproxy list */
954	GetStr(&config->noproxy, nextarg);
955	break;
956	case '7': /* --socks5-gssapi-nec*/
957	config->socks5_gssapi_nec = toggle;
958	break;
959	case '8': /* --proxy1.0 */
960	/* http 1.0 proxy */
961	GetStr(&config->proxy, nextarg);
962	config->proxyver = CURLPROXY_HTTP_1_0;
963	break;
964	case '9': /* --tftp-blksize */
965	err = str2unum(&config->tftp_blksize, nextarg);
966	if(err)
967	return err;
968	break;
969	case 'A': /* --mail-from */
970	GetStr(&config->mail_from, nextarg);
971	break;
972	case 'B': /* --mail-rcpt */
973	/* append receiver to a list */
974	err = add2list(&config->mail_rcpt, nextarg);
975	if(err)
976	return err;
977	break;
978	case 'C': /* --ftp-pret */
979	config->ftp_pret = toggle;
980	break;
981	case 'D': /* --proto */
982	config->proto_present = TRUE;
983	if(proto2num(config, &config->proto, nextarg))
984	return PARAM_BAD_USE;
985	break;
986	case 'E': /* --proto-redir */
987	config->proto_redir_present = TRUE;
988	if(proto2num(config, &config->proto_redir, nextarg))
989	return PARAM_BAD_USE;
990	break;
991	case 'F': /* --resolve */
992	err = add2list(&config->resolve, nextarg);
993	if(err)
994	return err;
995	break;
996	case 'G': /* --delegation LEVEL */
997	config->gssapi_delegation = delegation(config, nextarg);
998	break;
999	case 'H': /* --mail-auth */
1000	GetStr(&config->mail_auth, nextarg);
1001	break;
1002	case 'J': /* --metalink */
1003	{
1004	#ifdef USE_METALINK
1005	int mlmaj, mlmin, mlpatch;
1006	metalink_get_version(&mlmaj, &mlmin, &mlpatch);
1007	if((mlmaj10000)+(mlmin100) + mlpatch < CURL_REQ_LIBMETALINK_VERS) {
1008	warnf(global,
1009	"--metalink option cannot be used because the version of "
1010	"the linked libmetalink library is too old. "
1011	"Required: %d.%d.%d, found %d.%d.%d\n",
1012	CURL_REQ_LIBMETALINK_MAJOR,
1013	CURL_REQ_LIBMETALINK_MINOR,
1014	CURL_REQ_LIBMETALINK_PATCH,
1015	mlmaj, mlmin, mlpatch);
1016	return PARAM_BAD_USE;
1017	}
1018	else
1019	config->use_metalink = toggle;
1020	#else
1021	warnf(global, "--metalink option is ignored because the binary is "
1022	"built without the Metalink support.\n");
1023	#endif
1024	break;
1025	}
1026	case 'K': /* --sasl-ir */
1027	config->sasl_ir = toggle;
1028	break;
1029	case 'L': /* --test-event */
1030	#ifdef CURLDEBUG
1031	config->test_event_based = toggle;
1032	#else
1033	warnf(global, "--test-event is ignored unless a debug build!\n");
1034	#endif
1035	break;
1036	case 'M': /* --unix-socket */
1037	config->abstract_unix_socket = FALSE;
1038	GetStr(&config->unix_socket_path, nextarg);
1039	break;
1040	case 'N': /* --path-as-is */
1041	config->path_as_is = toggle;
1042	break;
1043	case 'O': /* --proxy-service-name */
1044	GetStr(&config->proxy_service_name, nextarg);
1045	break;
1046	case 'P': /* --service-name */
1047	GetStr(&config->service_name, nextarg);
1048	break;
1049	case 'Q': /* --proto-default */
1050	GetStr(&config->proto_default, nextarg);
1051	err = check_protocol(config->proto_default);
1052	if(err)
1053	return err;
1054	break;
1055	case 'R': /* --expect100-timeout */
1056	err = str2udouble(&config->expect100timeout, nextarg, LONG_MAX/1000);
1057	if(err)
1058	return err;
1059	break;
1060	case 'S': /* --tftp-no-options */
1061	config->tftp_no_options = toggle;
1062	break;
1063	case 'U': /* --connect-to */
1064	err = add2list(&config->connect_to, nextarg);
1065	if(err)
1066	return err;
1067	break;
1068	case 'W': /* --abstract-unix-socket */
1069	config->abstract_unix_socket = TRUE;
1070	GetStr(&config->unix_socket_path, nextarg);
1071	break;
1072	case 'X': /* --tls-max */
1073	err = str2tls_max(&config->ssl_version_max, nextarg);
1074	if(err)
1075	return err;
1076	break;
1077	case 'Y': /* --suppress-connect-headers */
1078	config->suppress_connect_headers = toggle;
1079	break;
1080	case 'Z': /* --compressed-ssh */
1081	config->ssh_compression = toggle;
1082	break;
1083	}
1084	break;
1085	case '#': /* --progress-bar */
1086	if(toggle)
1087	global->progressmode = CURL_PROGRESS_BAR;
1088	else
1089	global->progressmode = CURL_PROGRESS_STATS;
1090	break;
1091	case ':': /* --next */
1092	return PARAM_NEXT_OPERATION;
1093	case '0': /* --http* options */
1094	switch(subletter) {
1095	case '\0':
1096	/* HTTP version 1.0 */
1097	config->httpversion = CURL_HTTP_VERSION_1_0;
1098	break;
1099	case '1':
1100	/* HTTP version 1.1 */
1101	config->httpversion = CURL_HTTP_VERSION_1_1;
1102	break;
1103	case '2':
1104	/* HTTP version 2.0 */
1105	config->httpversion = CURL_HTTP_VERSION_2_0;
1106	break;
1107	case '3':
1108	/* HTTP version 2.0 over clean TCP*/
1109	config->httpversion = CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE;
1110	break;
1111	}
1112	break;
1113	case '1': /* --tlsv1* options */
1114	switch(subletter) {
1115	case '\0':
1116	/* TLS version 1.x */
1117	config->ssl_version = CURL_SSLVERSION_TLSv1;
1118	break;
1119	case '0':
1120	/* TLS version 1.0 */
1121	config->ssl_version = CURL_SSLVERSION_TLSv1_0;
1122	break;
1123	case '1':
1124	/* TLS version 1.1 */
1125	config->ssl_version = CURL_SSLVERSION_TLSv1_1;
1126	break;
1127	case '2':
1128	/* TLS version 1.2 */
1129	config->ssl_version = CURL_SSLVERSION_TLSv1_2;
1130	break;
1131	case '3':
1132	/* TLS version 1.3 */
1133	config->ssl_version = CURL_SSLVERSION_TLSv1_3;
1134	break;
1135	}
1136	break;
1137	case '2':
1138	/* SSL version 2 */
1139	config->ssl_version = CURL_SSLVERSION_SSLv2;
1140	break;
1141	case '3':
1142	/* SSL version 3 */
1143	config->ssl_version = CURL_SSLVERSION_SSLv3;
1144	break;
1145	case '4':
1146	/* IPv4 */
1147	config->ip_version = 4;
1148	break;
1149	case '6':
1150	/* IPv6 */
1151	config->ip_version = 6;
1152	break;
1153	case 'a':
1154	/* This makes the FTP sessions use APPE instead of STOR */
1155	config->ftp_append = toggle;
1156	break;
1157	case 'A':
1158	/* This specifies the User-Agent name */
1159	GetStr(&config->useragent, nextarg);
1160	break;
1161	case 'b': /* cookie string coming up: */
1162	if(nextarg[0] == '@') {
1163	nextarg++;
1164	}
1165	else if(strchr(nextarg, '=')) {
1166	/* A cookie string must have a =-letter */
1167	GetStr(&config->cookie, nextarg);
1168	break;
1169	}
1170	/* We have a cookie file to read from! */
1171	GetStr(&config->cookiefile, nextarg);
1172	break;
1173	case 'B':
1174	/* use ASCII/text when transferring */
1175	config->use_ascii = toggle;
1176	break;
1177	case 'c':
1178	/* get the file name to dump all cookies in */
1179	GetStr(&config->cookiejar, nextarg);
1180	break;
1181	case 'C':
1182	/* This makes us continue an ftp transfer at given position */
1183	if(strcmp(nextarg, "-")) {
1184	err = str2offset(&config->resume_from, nextarg);
1185	if(err)
1186	return err;
1187	config->resume_from_current = FALSE;
1188	}
1189	else {
1190	config->resume_from_current = TRUE;
1191	config->resume_from = 0;
1192	}
1193	config->use_resume = TRUE;
1194	break;
1195	case 'd':
1196	/* postfield data */
1197	{
1198	char *postdata = NULL;
1199	FILE *file;
1200	size_t size = 0;
1201	bool raw_mode = (subletter == 'r');
1202
1203	if(subletter == 'e') { /* --data-urlencode*/
1204	/* [name]=[content], we encode the content part only
1205	* [name]@[file name]
1206	*
1207	* Case 2: we first load the file using that name and then encode
1208	* the content.
1209	*/
1210	const char *p = strchr(nextarg, '=');
1211	size_t nlen;
1212	char is_file;
1213	if(!p)
1214	/* there was no '=' letter, check for a '@' instead */
1215	p = strchr(nextarg, '@');
1216	if(p) {
1217	nlen = p - nextarg; /* length of the name part */
1218	is_file = p++; / pass the separator */
1219	}
1220	else {
1221	/* neither @ nor =, so no name and it isn't a file */
1222	nlen = is_file = 0;
1223	p = nextarg;
1224	}
1225	if('@' == is_file) {
1226	/* a '@' letter, it means that a file name or - (stdin) follows */
1227	if(!strcmp("-", p)) {
1228	file = stdin;
1229	set_binmode(stdin);
1230	}
1231	else {
1232	file = fopen(p, "rb");
1233	if(!file)
1234	warnf(global,
1235	"Couldn't read data from file \"%s\", this makes "
1236	"an empty POST.\n", nextarg);
1237	}
1238
1239	err = file2memory(&postdata, &size, file);
1240
1241	if(file && (file != stdin))
1242	fclose(file);
1243	if(err)
1244	return err;
1245	}
1246	else {
1247	GetStr(&postdata, p);
1248	if(postdata)
1249	size = strlen(postdata);
1250	}
1251
1252	if(!postdata) {
1253	/* no data from the file, point to a zero byte string to make this
1254	get sent as a POST anyway */
1255	postdata = strdup("");
1256	if(!postdata)
1257	return PARAM_NO_MEM;
1258	size = 0;
1259	}
1260	else {
1261	char *enc = curl_easy_escape(config->easy, postdata, (int)size);
1262	Curl_safefree(postdata); /* no matter if it worked or not */
1263	if(enc) {
1264	/* now make a string with the name from above and append the
1265	encoded string */
1266	size_t outlen = nlen + strlen(enc) + 2;
1267	char *n = malloc(outlen);
1268	if(!n) {
1269	curl_free(enc);
1270	return PARAM_NO_MEM;
1271	}
1272	if(nlen > 0) { /* only append '=' if we have a name */
1273	snprintf(n, outlen, "%.*s=%s", nlen, nextarg, enc);
1274	size = outlen-1;
1275	}
1276	else {
1277	strcpy(n, enc);
1278	size = outlen-2; /* since no '=' was inserted */
1279	}
1280	curl_free(enc);
1281	postdata = n;
1282	}
1283	else
1284	return PARAM_NO_MEM;
1285	}
1286	}
1287	else if('@' == *nextarg && !raw_mode) {
1288	/* the data begins with a '@' letter, it means that a file name
1289	or - (stdin) follows */
1290	nextarg++; /* pass the @ */
1291
1292	if(!strcmp("-", nextarg)) {
1293	file = stdin;
1294	if(subletter == 'b') /* forced data-binary */
1295	set_binmode(stdin);
1296	}
1297	else {
1298	file = fopen(nextarg, "rb");
1299	if(!file)
1300	warnf(global, "Couldn't read data from file \"%s\", this makes "
1301	"an empty POST.\n", nextarg);
1302	}
1303
1304	if(subletter == 'b')
1305	/* forced binary */
1306	err = file2memory(&postdata, &size, file);
1307	else {
1308	err = file2string(&postdata, file);
1309	if(postdata)
1310	size = strlen(postdata);
1311	}
1312
1313	if(file && (file != stdin))
1314	fclose(file);
1315	if(err)
1316	return err;
1317
1318	if(!postdata) {
1319	/* no data from the file, point to a zero byte string to make this
1320	get sent as a POST anyway */
1321	postdata = strdup("");
1322	if(!postdata)
1323	return PARAM_NO_MEM;
1324	}
1325	}
1326	else {
1327	GetStr(&postdata, nextarg);
1328	if(postdata)
1329	size = strlen(postdata);
1330	}
1331
1332	#ifdef CURL_DOES_CONVERSIONS
1333	if(subletter != 'b') {
1334	/* NOT forced binary, convert to ASCII */
1335	if(convert_to_network(postdata, strlen(postdata))) {
1336	Curl_safefree(postdata);
1337	return PARAM_NO_MEM;
1338	}
1339	}
1340	#endif
1341
1342	if(config->postfields) {
1343	/* we already have a string, we append this one with a separating
1344	&-letter */
1345	char *oldpost = config->postfields;
1346	curl_off_t oldlen = config->postfieldsize;
1347	curl_off_t newlen = oldlen + curlx_uztoso(size) + 2;
1348	config->postfields = malloc((size_t)newlen);
1349	if(!config->postfields) {
1350	Curl_safefree(oldpost);
1351	Curl_safefree(postdata);
1352	return PARAM_NO_MEM;
1353	}
1354	memcpy(config->postfields, oldpost, (size_t)oldlen);
1355	/* use byte value 0x26 for '&' to accommodate non-ASCII platforms */
1356	config->postfields[oldlen] = '\x26';
1357	memcpy(&config->postfields[oldlen + 1], postdata, size);
1358	config->postfields[oldlen + 1 + size] = '\0';
1359	Curl_safefree(oldpost);
1360	Curl_safefree(postdata);
1361	config->postfieldsize += size + 1;
1362	}
1363	else {
1364	config->postfields = postdata;
1365	config->postfieldsize = curlx_uztoso(size);
1366	}
1367	}
1368	/*
1369	We can't set the request type here, as this data might be used in
1370	a simple GET if -G is used. Already or soon.
1371
1372	if(SetHTTPrequest(HTTPREQ_SIMPLEPOST, &config->httpreq)) {
1373	Curl_safefree(postdata);
1374	return PARAM_BAD_USE;
1375	}
1376	*/
1377	break;
1378	case 'D':
1379	/* dump-header to given file name */
1380	GetStr(&config->headerfile, nextarg);
1381	break;
1382	case 'e':
1383	{
1384	char *ptr = strstr(nextarg, ";auto");
1385	if(ptr) {
1386	/* Automatic referer requested, this may be combined with a
1387	set initial one */
1388	config->autoreferer = TRUE;
1389	ptr = 0; / zero terminate here */
1390	}
1391	else
1392	config->autoreferer = FALSE;
1393	GetStr(&config->referer, nextarg);
1394	}
1395	break;
1396	case 'E':
1397	switch(subletter) {
1398	case '\0': /* certificate file */
1399	GetFileAndPassword(nextarg, &config->cert, &config->key_passwd);
1400	break;
1401	case 'a': /* CA info PEM file */
1402	/* CA info PEM file */
1403	GetStr(&config->cacert, nextarg);
1404	break;
1405	case 'b': /* cert file type */
1406	GetStr(&config->cert_type, nextarg);
1407	break;
1408	case 'c': /* private key file */
1409	GetStr(&config->key, nextarg);
1410	break;
1411	case 'd': /* private key file type */
1412	GetStr(&config->key_type, nextarg);
1413	break;
1414	case 'e': /* private key passphrase */
1415	GetStr(&config->key_passwd, nextarg);
1416	cleanarg(nextarg);
1417	break;
1418	case 'f': /* crypto engine */
1419	GetStr(&config->engine, nextarg);
1420	if(config->engine && curl_strequal(config->engine, "list"))
1421	return PARAM_ENGINES_REQUESTED;
1422	break;
1423	case 'g': /* CA info PEM file */
1424	/* CA cert directory */
1425	GetStr(&config->capath, nextarg);
1426	break;
1427	case 'h': /* --pubkey public key file */
1428	GetStr(&config->pubkey, nextarg);
1429	break;
1430	case 'i': /* --hostpubmd5 md5 of the host public key */
1431	GetStr(&config->hostpubmd5, nextarg);
1432	if(!config->hostpubmd5 \|\| strlen(config->hostpubmd5) != 32)
1433	return PARAM_BAD_USE;
1434	break;
1435	case 'j': /* CRL info PEM file */
1436	/* CRL file */
1437	GetStr(&config->crlfile, nextarg);
1438	break;
1439	case 'k': /* TLS username */
1440	if(curlinfo->features & CURL_VERSION_TLSAUTH_SRP)
1441	GetStr(&config->tls_username, nextarg);
1442	else
1443	return PARAM_LIBCURL_DOESNT_SUPPORT;
1444	break;
1445	case 'l': /* TLS password */
1446	if(curlinfo->features & CURL_VERSION_TLSAUTH_SRP)
1447	GetStr(&config->tls_password, nextarg);
1448	else
1449	return PARAM_LIBCURL_DOESNT_SUPPORT;
1450	break;
1451	case 'm': /* TLS authentication type */
1452	if(curlinfo->features & CURL_VERSION_TLSAUTH_SRP) {
1453	GetStr(&config->tls_authtype, nextarg);
1454	if(!curl_strequal(config->tls_authtype, "SRP"))
1455	return PARAM_LIBCURL_DOESNT_SUPPORT; /* only support TLS-SRP */
1456	}
1457	else
1458	return PARAM_LIBCURL_DOESNT_SUPPORT;
1459	break;
1460	case 'n': /* no empty SSL fragments, --ssl-allow-beast */
1461	if(curlinfo->features & CURL_VERSION_SSL)
1462	config->ssl_allow_beast = toggle;
1463	break;
1464
1465	case 'o': /* --login-options */
1466	GetStr(&config->login_options, nextarg);
1467	break;
1468
1469	case 'p': /* Pinned public key DER file */
1470	/* Pinned public key DER file */
1471	GetStr(&config->pinnedpubkey, nextarg);
1472	break;
1473
1474	case 'q': /* --cert-status */
1475	config->verifystatus = TRUE;
1476	break;
1477
1478	case 'r': /* --false-start */
1479	config->falsestart = TRUE;
1480	break;
1481
1482	case 's': /* --ssl-no-revoke */
1483	if(curlinfo->features & CURL_VERSION_SSL)
1484	config->ssl_no_revoke = TRUE;
1485	break;
1486
1487	case 't': /* --tcp-fastopen */
1488	config->tcp_fastopen = TRUE;
1489	break;
1490
1491	case 'u': /* TLS username for proxy */
1492	if(curlinfo->features & CURL_VERSION_TLSAUTH_SRP)
1493	GetStr(&config->proxy_tls_username, nextarg);
1494	else
1495	return PARAM_LIBCURL_DOESNT_SUPPORT;
1496	break;
1497
1498	case 'v': /* TLS password for proxy */
1499	if(curlinfo->features & CURL_VERSION_TLSAUTH_SRP)
1500	GetStr(&config->proxy_tls_password, nextarg);
1501	else
1502	return PARAM_LIBCURL_DOESNT_SUPPORT;
1503	break;
1504
1505	case 'w': /* TLS authentication type for proxy */
1506	if(curlinfo->features & CURL_VERSION_TLSAUTH_SRP) {
1507	GetStr(&config->proxy_tls_authtype, nextarg);
1508	if(!curl_strequal(config->proxy_tls_authtype, "SRP"))
1509	return PARAM_LIBCURL_DOESNT_SUPPORT; /* only support TLS-SRP */
1510	}
1511	else
1512	return PARAM_LIBCURL_DOESNT_SUPPORT;
1513	break;
1514
1515	case 'x': /* certificate file for proxy */
1516	GetFileAndPassword(nextarg, &config->proxy_cert,
1517	&config->proxy_key_passwd);
1518	break;
1519
1520	case 'y': /* cert file type for proxy */
1521	GetStr(&config->proxy_cert_type, nextarg);
1522	break;
1523
1524	case 'z': /* private key file for proxy */
1525	GetStr(&config->proxy_key, nextarg);
1526	break;
1527
1528	case '0': /* private key file type for proxy */
1529	GetStr(&config->proxy_key_type, nextarg);
1530	break;
1531
1532	case '1': /* private key passphrase for proxy */
1533	GetStr(&config->proxy_key_passwd, nextarg);
1534	cleanarg(nextarg);
1535	break;
1536
1537	case '2': /* ciphers for proxy */
1538	GetStr(&config->proxy_cipher_list, nextarg);
1539	break;
1540
1541	case '3': /* CRL info PEM file for proxy */
1542	/* CRL file */
1543	GetStr(&config->proxy_crlfile, nextarg);
1544	break;
1545
1546	case '4': /* no empty SSL fragments for proxy */
1547	if(curlinfo->features & CURL_VERSION_SSL)
1548	config->proxy_ssl_allow_beast = toggle;
1549	break;
1550
1551	case '5': /* --login-options */
1552	GetStr(&config->login_options, nextarg);
1553	break;
1554
1555	case '6': /* CA info PEM file for proxy */
1556	/* CA info PEM file */
1557	GetStr(&config->proxy_cacert, nextarg);
1558	break;
1559
1560	case '7': /* CA info PEM file for proxy */
1561	/* CA cert directory */
1562	GetStr(&config->proxy_capath, nextarg);
1563	break;
1564
1565	case '8': /* allow insecure SSL connects for proxy */
1566	config->proxy_insecure_ok = toggle;
1567	break;
1568
1569	case '9': /* --proxy-tlsv1 */
1570	/* TLS version 1 for proxy */
1571	config->proxy_ssl_version = CURL_SSLVERSION_TLSv1;
1572	break;
1573
1574	case 'A':
1575	/* --socks5-basic */
1576	if(toggle)
1577	config->socks5_auth \|= CURLAUTH_BASIC;
1578	else
1579	config->socks5_auth &= ~CURLAUTH_BASIC;
1580	break;
1581
1582	case 'B':
1583	/* --socks5-gssapi */
1584	if(toggle)
1585	config->socks5_auth \|= CURLAUTH_GSSAPI;
1586	else
1587	config->socks5_auth &= ~CURLAUTH_GSSAPI;
1588	break;
1589
1590	default: /* unknown flag */
1591	return PARAM_OPTION_UNKNOWN;
1592	}
1593	break;
1594	case 'f':
1595	switch(subletter) {
1596	case 'a': /* --fail-early */
1597	global->fail_early = toggle;
1598	break;
1599	default:
1600	/* fail hard on errors */
1601	config->failonerror = toggle;
1602	}
1603	break;
1604	case 'F':
1605	/* "form data" simulation, this is a little advanced so lets do our best
1606	to sort this out slowly and carefully */
1607	if(formparse(config,
1608	nextarg,
1609	&config->mimepost,
1610	&config->mimecurrent,
1611	(subletter == 's')?TRUE:FALSE)) /* 's' is literal string */
1612	return PARAM_BAD_USE;
1613	if(SetHTTPrequest(config, HTTPREQ_MIMEPOST, &config->httpreq))
1614	return PARAM_BAD_USE;
1615	break;
1616
1617	case 'g': /* g disables URLglobbing */
1618	config->globoff = toggle;
1619	break;
1620
1621	case 'G': /* HTTP GET */
1622	if(subletter == 'a') { /* --request-target */
1623	GetStr(&config->request_target, nextarg);
1624	}
1625	else
1626	config->use_httpget = TRUE;
1627	break;
1628
1629	case 'h': /* h for help */
1630	if(toggle) {
1631	return PARAM_HELP_REQUESTED;
1632	}
1633	/* we now actually support --no-help too! */
1634	break;
1635	case 'H':
1636	/* A custom header to append to a list */
1637	if(nextarg[0] == '@') {
1638	/* read many headers from a file or stdin */
1639	char *string;
1640	size_t len;
1641	bool use_stdin = !strcmp(&nextarg[1], "-");
1642	FILE *file = use_stdin?stdin:fopen(&nextarg[1], FOPEN_READTEXT);
1643	if(!file)
1644	warnf(global, "Failed to open %s!\n", &nextarg[1]);
1645	else {
1646	err = file2memory(&string, &len, file);
1647	if(!err) {
1648	/* Allow strtok() here since this isn't used threaded */
1649	/* !checksrc! disable BANNEDFUNC 2 */
1650	char *h = strtok(string, "\r\n");
1651	while(h) {
1652	if(subletter == 'p') /* --proxy-header */
1653	err = add2list(&config->proxyheaders, h);
1654	else
1655	err = add2list(&config->headers, h);
1656	if(err)
1657	break;
1658	h = strtok(NULL, "\r\n");
1659	}
1660	free(string);
1661	}
1662	if(!use_stdin)
1663	fclose(file);
1664	if(err)
1665	return err;
1666	}
1667	}
1668	else {
1669	if(subletter == 'p') /* --proxy-header */
1670	err = add2list(&config->proxyheaders, nextarg);
1671	else
1672	err = add2list(&config->headers, nextarg);
1673	if(err)
1674	return err;
1675	}
1676	break;
1677	case 'i':
1678	config->include_headers = toggle; /* include the headers as well in the
1679	general output stream */
1680	break;
1681	case 'j':
1682	config->cookiesession = toggle;
1683	break;
1684	case 'I':
1685	/*
1686	* no_body will imply include_headers later on
1687	*/
1688	config->no_body = toggle;
1689	if(SetHTTPrequest(config,
1690	(config->no_body)?HTTPREQ_HEAD:HTTPREQ_GET,
1691	&config->httpreq))
1692	return PARAM_BAD_USE;
1693	break;
1694	case 'J': /* --remote-header-name */
1695	if(config->include_headers) {
1696	warnf(global,
1697	"--include and --remote-header-name cannot be combined.\n");
1698	return PARAM_BAD_USE;
1699	}
1700	config->content_disposition = toggle;
1701	break;
1702	case 'k': /* allow insecure SSL connects */
1703	config->insecure_ok = toggle;
1704	break;
1705	case 'K': /* parse config file */
1706	if(parseconfig(nextarg, global))
1707	warnf(global, "error trying read config from the '%s' file\n",
1708	nextarg);
1709	break;
1710	case 'l':
1711	config->dirlistonly = toggle; /* only list the names of the FTP dir */
1712	break;
1713	case 'L':
1714	config->followlocation = toggle; /* Follow Location: HTTP headers */
1715	switch(subletter) {
1716	case 't':
1717	/* Continue to send authentication (user+password) when following
1718	* locations, even when hostname changed */
1719	config->unrestricted_auth = toggle;
1720	break;
1721	}
1722	break;
1723	case 'm':
1724	/* specified max time */
1725	err = str2udouble(&config->timeout, nextarg, LONG_MAX/1000);
1726	if(err)
1727	return err;
1728	break;
1729	case 'M': /* M for manual, huge help */
1730	if(toggle) { /* --no-manual shows no manual... */
1731	#ifdef USE_MANUAL
1732	return PARAM_MANUAL_REQUESTED;
1733	#else
1734	warnf(global,
1735	"built-in manual was disabled at build-time!\n");
1736	return PARAM_OPTION_UNKNOWN;
1737	#endif
1738	}
1739	break;
1740	case 'n':
1741	switch(subletter) {
1742	case 'o': /* CA info PEM file */
1743	/* use .netrc or URL */
1744	config->netrc_opt = toggle;
1745	break;
1746	case 'e': /* netrc-file */
1747	GetStr(&config->netrc_file, nextarg);
1748	break;
1749	default:
1750	/* pick info from .netrc, if this is used for http, curl will
1751	automatically enfore user+password with the request */
1752	config->netrc = toggle;
1753	break;
1754	}
1755	break;
1756	case 'N':
1757	/* disable the output I/O buffering. note that the option is called
1758	--buffer but is mostly used in the negative form: --no-buffer */
1759	if(longopt)
1760	config->nobuffer = (!toggle)?TRUE:FALSE;
1761	else
1762	config->nobuffer = toggle;
1763	break;
1764	case 'O': /* --remote-name */
1765	if(subletter == 'a') { /* --remote-name-all */
1766	config->default_node_flags = toggle?GETOUT_USEREMOTE:0;
1767	break;
1768	}
1769	/* fall-through! */
1770	case 'o': /* --output */
1771	/* output file */
1772	{
1773	struct getout *url;
1774	if(!config->url_out)
1775	config->url_out = config->url_list;
1776	if(config->url_out) {
1777	/* there's a node here, if it already is filled-in continue to find
1778	an "empty" node */
1779	while(config->url_out && (config->url_out->flags & GETOUT_OUTFILE))
1780	config->url_out = config->url_out->next;
1781	}
1782
1783	/* now there might or might not be an available node to fill in! */
1784
1785	if(config->url_out)
1786	/* existing node */
1787	url = config->url_out;
1788	else
1789	/* there was no free node, create one! */
1790	config->url_out = url = new_getout(config);
1791
1792	if(!url)
1793	return PARAM_NO_MEM;
1794
1795	/* fill in the outfile */
1796	if('o' == letter) {
1797	GetStr(&url->outfile, nextarg);
1798	url->flags &= ~GETOUT_USEREMOTE; /* switch off */
1799	}
1800	else {
1801	url->outfile = NULL; /* leave it */
1802	if(toggle)
1803	url->flags \|= GETOUT_USEREMOTE; /* switch on */
1804	else
1805	url->flags &= ~GETOUT_USEREMOTE; /* switch off */
1806	}
1807	url->flags \|= GETOUT_OUTFILE;
1808	}
1809	break;
1810	case 'P':
1811	/* This makes the FTP sessions use PORT instead of PASV */
1812	/* use <eth0> or <192.168.10.10> style addresses. Anything except
1813	this will make us try to get the "default" address.
1814	NOTE: this is a changed behaviour since the released 4.1!
1815	*/
1816	GetStr(&config->ftpport, nextarg);
1817	break;
1818	case 'p':
1819	/* proxy tunnel for non-http protocols */
1820	config->proxytunnel = toggle;
1821	break;
1822
1823	case 'q': /* if used first, already taken care of, we do it like
1824	this so we don't cause an error! */
1825	break;
1826	case 'Q':
1827	/* QUOTE command to send to FTP server */
1828	switch(nextarg[0]) {
1829	case '-':
1830	/* prefixed with a dash makes it a POST TRANSFER one */
1831	nextarg++;
1832	err = add2list(&config->postquote, nextarg);
1833	break;
1834	case '+':
1835	/* prefixed with a plus makes it a just-before-transfer one */
1836	nextarg++;
1837	err = add2list(&config->prequote, nextarg);
1838	break;
1839	default:
1840	err = add2list(&config->quote, nextarg);
1841	break;
1842	}
1843	if(err)
1844	return err;
1845	break;
1846	case 'r':
1847	/* Specifying a range WITHOUT A DASH will create an illegal HTTP range
1848	(and won't actually be range by definition). The man page previously
1849	claimed that to be a good way, why this code is added to work-around
1850	it. */
1851	if(ISDIGIT(*nextarg) && !strchr(nextarg, '-')) {
1852	char buffer[32];
1853	curl_off_t off;
1854	if(curlx_strtoofft(nextarg, NULL, 10, &off)) {
1855	warnf(global, "unsupported range point\n");
1856	return PARAM_BAD_USE;
1857	}
1858	warnf(global,
1859	"A specified range MUST include at least one dash (-). "
1860	"Appending one for you!\n");
1861	snprintf(buffer, sizeof(buffer), "%" CURL_FORMAT_CURL_OFF_T "-", off);
1862	Curl_safefree(config->range);
1863	config->range = strdup(buffer);
1864	if(!config->range)
1865	return PARAM_NO_MEM;
1866	}
1867	{
1868	/* byte range requested */
1869	char *tmp_range;
1870	tmp_range = nextarg;
1871	while(*tmp_range != '\0') {
1872	if(!ISDIGIT(tmp_range) && tmp_range != '-' && *tmp_range != ',') {
1873	warnf(global, "Invalid character is found in given range. "
1874	"A specified range MUST have only digits in "
1875	"\'start\'-\'stop\'. The server's response to this "
1876	"request is uncertain.\n");
1877	break;
1878	}
1879	tmp_range++;
1880	}
1881	/* byte range requested */
1882	GetStr(&config->range, nextarg);
1883	}
1884	break;
1885	case 'R':
1886	/* use remote file's time */
1887	config->remote_time = toggle;
1888	break;
1889	case 's':
1890	/* don't show progress meter, don't show errors : */
1891	if(toggle)
1892	global->mute = global->noprogress = TRUE;
1893	else
1894	global->mute = global->noprogress = FALSE;
1895	if(global->showerror < 0)
1896	/* if still on the default value, set showerror to the reverse of
1897	toggle. This is to allow -S and -s to be used in an independent
1898	order but still have the same effect. */
1899	global->showerror = (!toggle)?TRUE:FALSE; /* toggle off */
1900	break;
1901	case 'S':
1902	/* show errors */
1903	global->showerror = toggle?1:0; /* toggle on if used with -s */
1904	break;
1905	case 't':
1906	/* Telnet options */
1907	err = add2list(&config->telnet_options, nextarg);
1908	if(err)
1909	return err;
1910	break;
1911	case 'T':
1912	/* we are uploading */
1913	{
1914	struct getout *url;
1915	if(!config->url_ul)
1916	config->url_ul = config->url_list;
1917	if(config->url_ul) {
1918	/* there's a node here, if it already is filled-in continue to find
1919	an "empty" node */
1920	while(config->url_ul && (config->url_ul->flags & GETOUT_UPLOAD))
1921	config->url_ul = config->url_ul->next;
1922	}
1923
1924	/* now there might or might not be an available node to fill in! */
1925
1926	if(config->url_ul)
1927	/* existing node */
1928	url = config->url_ul;
1929	else
1930	/* there was no free node, create one! */
1931	config->url_ul = url = new_getout(config);
1932
1933	if(!url)
1934	return PARAM_NO_MEM;
1935
1936	url->flags \|= GETOUT_UPLOAD; /* mark -T used */
1937	if(!*nextarg)
1938	url->flags \|= GETOUT_NOUPLOAD;
1939	else {
1940	/* "-" equals stdin, but keep the string around for now */
1941	GetStr(&url->infile, nextarg);
1942	}
1943	}
1944	break;
1945	case 'u':
1946	/* user:password */
1947	GetStr(&config->userpwd, nextarg);
1948	cleanarg(nextarg);
1949	break;
1950	case 'U':
1951	/* Proxy user:password */
1952	GetStr(&config->proxyuserpwd, nextarg);
1953	cleanarg(nextarg);
1954	break;
1955	case 'v':
1956	if(toggle) {
1957	/* the '%' thing here will cause the trace get sent to stderr */
1958	Curl_safefree(global->trace_dump);
1959	global->trace_dump = strdup("%");
1960	if(!global->trace_dump)
1961	return PARAM_NO_MEM;
1962	if(global->tracetype && (global->tracetype != TRACE_PLAIN))
1963	warnf(global,
1964	"-v, --verbose overrides an earlier trace/verbose option\n");
1965	global->tracetype = TRACE_PLAIN;
1966	}
1967	else
1968	/* verbose is disabled here */
1969	global->tracetype = TRACE_NONE;
1970	break;
1971	case 'V':
1972	if(toggle) /* --no-version yields no output! */
1973	return PARAM_VERSION_INFO_REQUESTED;
1974	break;
1975
1976	case 'w':
1977	/* get the output string */
1978	if('@' == *nextarg) {
1979	/* the data begins with a '@' letter, it means that a file name
1980	or - (stdin) follows */
1981	FILE *file;
1982	const char *fname;
1983	nextarg++; /* pass the @ */
1984	if(!strcmp("-", nextarg)) {
1985	fname = "<stdin>";
1986	file = stdin;
1987	}
1988	else {
1989	fname = nextarg;
1990	file = fopen(nextarg, FOPEN_READTEXT);
1991	}
1992	err = file2string(&config->writeout, file);
1993	if(file && (file != stdin))
1994	fclose(file);
1995	if(err)
1996	return err;
1997	if(!config->writeout)
1998	warnf(global, "Failed to read %s", fname);
1999	}
2000	else
2001	GetStr(&config->writeout, nextarg);
2002	break;
2003	case 'x':
2004	switch(subletter) {
2005	case 'a': /* --preproxy */
2006	GetStr(&config->preproxy, nextarg);
2007	break;
2008	default:
2009	/* --proxy */
2010	GetStr(&config->proxy, nextarg);
2011	config->proxyver = CURLPROXY_HTTP;
2012	break;
2013	}
2014	break;
2015	case 'X':
2016	/* set custom request */
2017	GetStr(&config->customrequest, nextarg);
2018	break;
2019	case 'y':
2020	/* low speed time */
2021	err = str2unum(&config->low_speed_time, nextarg);
2022	if(err)
2023	return err;
2024	if(!config->low_speed_limit)
2025	config->low_speed_limit = 1;
2026	break;
2027	case 'Y':
2028	/* low speed limit */
2029	err = str2unum(&config->low_speed_limit, nextarg);
2030	if(err)
2031	return err;
2032	if(!config->low_speed_time)
2033	config->low_speed_time = 30;
2034	break;
2035	case 'z': /* time condition coming up */
2036	switch(*nextarg) {
2037	case '+':
2038	nextarg++;
2039	/* FALLTHROUGH */
2040	default:
2041	/* If-Modified-Since: (section 14.28 in RFC2068) */
2042	config->timecond = CURL_TIMECOND_IFMODSINCE;
2043	break;
2044	case '-':
2045	/* If-Unmodified-Since: (section 14.24 in RFC2068) */
2046	config->timecond = CURL_TIMECOND_IFUNMODSINCE;
2047	nextarg++;
2048	break;
2049	case '=':
2050	/* Last-Modified: (section 14.29 in RFC2068) */
2051	config->timecond = CURL_TIMECOND_LASTMOD;
2052	nextarg++;
2053	break;
2054	}
2055	now = time(NULL);
2056	config->condtime = curl_getdate(nextarg, &now);
2057	if(-1 == (int)config->condtime) {
2058	/* now let's see if it is a file name to get the time from instead! */
2059	struct_stat statbuf;
2060	if(-1 == stat(nextarg, &statbuf)) {
2061	/* failed, remove time condition */
2062	config->timecond = CURL_TIMECOND_NONE;
2063	warnf(global,
2064	"Illegal date format for -z, --time-cond (and not "
2065	"a file name). Disabling time condition. "
2066	"See curl_getdate(3) for valid date syntax.\n");
2067	}
2068	else {
2069	/* pull the time out from the file */
2070	config->condtime = statbuf.st_mtime;
2071	}
2072	}
2073	break;
2074	default: /* unknown flag */
2075	return PARAM_OPTION_UNKNOWN;
2076	}
2077	hit = -1;
2078
2079	} while(!longopt && !singleopt && ++parse && !usedarg);
2080
2081	return PARAM_OK;
2082	}
2083
2084	ParameterError parse_args(struct GlobalConfig *config, int argc,
2085	argv_item_t argv[])
2086	{
2087	int i;
2088	bool stillflags;
2089	char *orig_opt = NULL;
2090	ParameterError result = PARAM_OK;
2091	struct OperationConfig *operation = config->first;
2092
2093	for(i = 1, stillflags = TRUE; i < argc && !result; i++) {
2094	orig_opt = argv[i];
2095
2096	if(stillflags && ('-' == argv[i][0])) {
2097	char *nextarg;
2098	bool passarg;
2099	char *flag = argv[i];
2100
2101	if(!strcmp("--", argv[i]))
2102	/* This indicates the end of the flags and thus enables the
2103	following (URL) argument to start with -. */
2104	stillflags = FALSE;
2105	else {
2106	nextarg = (i < (argc - 1)) ? argv[i + 1] : NULL;
2107
2108	result = getparameter(flag, nextarg, &passarg, config, operation);
2109	if(result == PARAM_NEXT_OPERATION) {
2110	/* Reset result as PARAM_NEXT_OPERATION is only used here and not
2111	returned from this function */
2112	result = PARAM_OK;
2113
2114	if(operation->url_list && operation->url_list->url) {
2115	/* Allocate the next config */
2116	operation->next = malloc(sizeof(struct OperationConfig));
2117	if(operation->next) {
2118	/* Initialise the newly created config */
2119	config_init(operation->next);
2120
2121	/* Copy the easy handle */
2122	operation->next->easy = config->easy;
2123
2124	/* Set the global config pointer */
2125	operation->next->global = config;
2126
2127	/* Update the last operation pointer */
2128	config->last = operation->next;
2129
2130	/* Move onto the new config */
2131	operation->next->prev = operation;
2132	operation = operation->next;
2133	}
2134	else
2135	result = PARAM_NO_MEM;
2136	}
2137	}
2138	else if(!result && passarg)
2139	i++; /* we're supposed to skip this */
2140	}
2141	}
2142	else {
2143	bool used;
2144
2145	/* Just add the URL please */
2146	result = getparameter((char *)"--url", argv[i], &used, config,
2147	operation);
2148	}
2149	}
2150
2151	if(result && result != PARAM_HELP_REQUESTED &&
2152	result != PARAM_MANUAL_REQUESTED &&
2153	result != PARAM_VERSION_INFO_REQUESTED &&
2154	result != PARAM_ENGINES_REQUESTED) {
2155	const char *reason = param2text(result);
2156
2157	if(orig_opt && strcmp(":", orig_opt))
2158	helpf(config->errors, "option %s: %s\n", orig_opt, reason);
2159	else
2160	helpf(config->errors, "%s\n", reason);
2161	}
2162
2163	return result;
2164	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: azure_iot_hub/trunk/curl-7.57.0/src/tool_getparam.c@ 389

Download in other formats: