2 * cmdline.c - command-line parsing shared between many of the
12 * Some command-line parameters need to be saved up until after
13 * we've loaded the saved session which will form the basis of our
14 * eventual running configuration. For this we use the macro
15 * SAVEABLE, which notices if the `need_save' parameter is set and
16 * saves the parameter and value on a list.
18 * We also assign priorities to saved parameters, just to slightly
19 * ameliorate silly ordering problems. For example, if you specify
20 * a saved session to load, it will be loaded _before_ all your
21 * local modifications such as -L are evaluated; and if you specify
22 * a protocol and a port, the protocol is set up first so that the
23 * port can override its choice of port number.
25 * (In fact -load is not saved at all, since in at least Plink the
26 * processing of further command-line options depends on whether or
27 * not the loaded session contained a hostname. So it must be
28 * executed immediately.)
33 struct cmdline_saved_param {
36 struct cmdline_saved_param_set {
37 struct cmdline_saved_param *params;
42 * C guarantees this structure will be initialised to all zero at
43 * program start, which is exactly what we want.
45 static struct cmdline_saved_param_set saves[NPRIORITIES];
47 static void cmdline_save_param(const char *p, const char *value, int pri)
49 if (saves[pri].nsaved >= saves[pri].savesize) {
50 saves[pri].savesize = saves[pri].nsaved + 32;
51 saves[pri].params = sresize(saves[pri].params, saves[pri].savesize,
52 struct cmdline_saved_param);
54 saves[pri].params[saves[pri].nsaved].p = dupstr(p);
55 saves[pri].params[saves[pri].nsaved].value = dupstr(value);
59 static char *cmdline_password = NULL;
61 void cmdline_cleanup(void)
65 if (cmdline_password) {
66 smemclr(cmdline_password, strlen(cmdline_password));
67 sfree(cmdline_password);
68 cmdline_password = NULL;
71 for (pri = 0; pri < NPRIORITIES; pri++) {
72 sfree(saves[pri].params);
73 saves[pri].params = NULL;
74 saves[pri].savesize = 0;
75 saves[pri].nsaved = 0;
79 #define SAVEABLE(pri) do { \
80 if (need_save) { cmdline_save_param(p, value, pri); return ret; } \
84 * Similar interface to get_userpass_input(), except that here a -1
85 * return means that we aren't capable of processing the prompt and
86 * someone else should do it.
88 int cmdline_get_passwd_input(prompts_t *p, const unsigned char *in, int inlen)
90 static int tried_once = 0;
93 * We only handle prompts which don't echo (which we assume to be
94 * passwords), and (currently) we only cope with a password prompt
95 * that comes in a prompt-set on its own.
97 if (!cmdline_password || in || p->n_prompts != 1 || p->prompts[0]->echo) {
102 * If we've tried once, return utter failure (no more passwords left
108 prompt_set_result(p->prompts[0], cmdline_password);
109 smemclr(cmdline_password, strlen(cmdline_password));
110 sfree(cmdline_password);
111 cmdline_password = NULL;
117 * Here we have a flags word which describes the capabilities of
118 * the particular tool on whose behalf we're running. We will
119 * refuse certain command-line options if a particular tool
120 * inherently can't do anything sensible. For example, the file
121 * transfer tools (psftp, pscp) can't do a great deal with protocol
122 * selections (ever tried running scp over telnet?) or with port
123 * forwarding (even if it wasn't a hideously bad idea, they don't
124 * have the select() infrastructure to make them work).
126 int cmdline_tooltype = 0;
128 static int cmdline_check_unavailable(int flag, const char *p)
130 if (cmdline_tooltype & flag) {
131 cmdline_error("option \"%s\" not available in this tool", p);
137 #define UNAVAILABLE_IN(flag) do { \
138 if (cmdline_check_unavailable(flag, p)) return ret; \
142 * Process a standard command-line parameter. `p' is the parameter
143 * in question; `value' is the subsequent element of argv, which
144 * may or may not be required as an operand to the parameter.
145 * If `need_save' is 1, arguments which need to be saved as
146 * described at this top of this file are, for later execution;
147 * if 0, they are processed normally. (-1 is a special value used
148 * by pterm to count arguments for a preliminary pass through the
149 * argument list; it causes immediate return with an appropriate
150 * value with no action taken.)
151 * Return value is 2 if both arguments were used; 1 if only p was
152 * used; 0 if the parameter wasn't one we recognised; -2 if it
153 * should have been 2 but value was NULL.
156 #define RETURN(x) do { \
157 if ((x) == 2 && !value) return -2; \
159 if (need_save < 0) return x; \
162 int cmdline_process_param(const char *p, char *value,
163 int need_save, Conf *conf)
167 if (!strcmp(p, "-load")) {
169 /* This parameter must be processed immediately rather than being
171 do_defaults(value, conf);
172 loaded_session = TRUE;
173 cmdline_session_name = dupstr(value);
176 if (!strcmp(p, "-ssh")) {
178 UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
180 default_protocol = PROT_SSH;
182 conf_set_int(conf, CONF_protocol, default_protocol);
183 conf_set_int(conf, CONF_port, default_port);
186 if (!strcmp(p, "-telnet")) {
188 UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
190 default_protocol = PROT_TELNET;
192 conf_set_int(conf, CONF_protocol, default_protocol);
193 conf_set_int(conf, CONF_port, default_port);
196 if (!strcmp(p, "-rlogin")) {
198 UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
200 default_protocol = PROT_RLOGIN;
202 conf_set_int(conf, CONF_protocol, default_protocol);
203 conf_set_int(conf, CONF_port, default_port);
206 if (!strcmp(p, "-raw")) {
208 UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
210 default_protocol = PROT_RAW;
211 conf_set_int(conf, CONF_protocol, default_protocol);
213 if (!strcmp(p, "-serial")) {
215 /* Serial is not NONNETWORK in an odd sense of the word */
216 UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
218 default_protocol = PROT_SERIAL;
219 conf_set_int(conf, CONF_protocol, default_protocol);
220 /* The host parameter will already be loaded into CONF_host,
221 * so copy it across */
222 conf_set_str(conf, CONF_serline, conf_get_str(conf, CONF_host));
224 if (!strcmp(p, "-v")) {
226 flags |= FLAG_VERBOSE;
228 if (!strcmp(p, "-l")) {
230 UNAVAILABLE_IN(TOOLTYPE_NONNETWORK);
232 conf_set_str(conf, CONF_username, value);
234 if (!strcmp(p, "-loghost")) {
236 UNAVAILABLE_IN(TOOLTYPE_NONNETWORK);
238 conf_set_str(conf, CONF_loghost, value);
240 if (!strcmp(p, "-hostkey")) {
243 UNAVAILABLE_IN(TOOLTYPE_NONNETWORK);
246 if (!validate_manual_hostkey(dup)) {
247 cmdline_error("'%s' is not a valid format for a manual host "
248 "key specification", value);
252 conf_set_str_str(conf, CONF_ssh_manual_hostkeys, dup, "");
255 if ((!strcmp(p, "-L") || !strcmp(p, "-R") || !strcmp(p, "-D"))) {
256 char type, *q, *qq, *key, *val;
258 UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
260 if (strcmp(p, "-D")) {
262 * For -L or -R forwarding types:
264 * We expect _at least_ two colons in this string. The
265 * possible formats are `sourceport:desthost:destport',
266 * or `sourceip:sourceport:desthost:destport' if you're
267 * specifying a particular loopback address. We need to
268 * replace the one between source and dest with a \t;
269 * this means we must find the second-to-last colon in
272 * (This looks like a foolish way of doing it given the
273 * existence of strrchr, but it's more efficient than
274 * two strrchrs - not to mention that the second strrchr
275 * would require us to modify the input string!)
278 type = p[1]; /* 'L' or 'R' */
280 q = qq = host_strchr(value, ':');
282 char *qqq = host_strchr(qq+1, ':');
289 cmdline_error("-%c expects at least two colons in its"
294 key = dupprintf("%c%.*s", type, (int)(q - value), value);
298 * Dynamic port forwardings are entered under the same key
299 * as if they were local (because they occupy the same
300 * port space - a local and a dynamic forwarding on the
301 * same local port are mutually exclusive), with the
302 * special value "D" (which can be distinguished from
303 * anything in the ordinary -L case by containing no
306 key = dupprintf("L%s", value);
309 conf_set_str_str(conf, CONF_portfwd, key, val);
313 if ((!strcmp(p, "-nc"))) {
317 UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
320 portp = host_strchr(value, ':');
322 cmdline_error("-nc expects argument of form 'host:port'");
326 host = dupprintf("%.*s", (int)(portp - value), value);
327 conf_set_str(conf, CONF_ssh_nc_host, host);
328 conf_set_int(conf, CONF_ssh_nc_port, atoi(portp + 1));
331 if (!strcmp(p, "-m")) {
332 const char *filename;
339 UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
344 cmdlen = cmdsize = 0;
346 fp = fopen(filename, "r");
348 cmdline_error("unable to open command file \"%s\"", filename);
356 if (cmdlen >= cmdsize) {
357 cmdsize = cmdlen + 512;
358 command = sresize(command, cmdsize, char);
360 command[cmdlen++] = d;
363 conf_set_str(conf, CONF_remote_cmd, command);
364 conf_set_str(conf, CONF_remote_cmd2, "");
365 conf_set_int(conf, CONF_nopty, TRUE); /* command => no terminal */
368 if (!strcmp(p, "-P")) {
370 UNAVAILABLE_IN(TOOLTYPE_NONNETWORK);
371 SAVEABLE(1); /* lower priority than -ssh,-telnet */
372 conf_set_int(conf, CONF_port, atoi(value));
374 if (!strcmp(p, "-pw")) {
376 UNAVAILABLE_IN(TOOLTYPE_NONNETWORK);
378 /* We delay evaluating this until after the protocol is decided,
379 * so that we can warn if it's of no use with the selected protocol */
380 if (conf_get_int(conf, CONF_protocol) != PROT_SSH)
381 cmdline_error("the -pw option can only be used with the "
384 cmdline_password = dupstr(value);
385 /* Assuming that `value' is directly from argv, make a good faith
386 * attempt to trample it, to stop it showing up in `ps' output
387 * on Unix-like systems. Not guaranteed, of course. */
388 smemclr(value, strlen(value));
392 if (!strcmp(p, "-agent") || !strcmp(p, "-pagent") ||
393 !strcmp(p, "-pageant")) {
395 UNAVAILABLE_IN(TOOLTYPE_NONNETWORK);
397 conf_set_int(conf, CONF_tryagent, TRUE);
399 if (!strcmp(p, "-noagent") || !strcmp(p, "-nopagent") ||
400 !strcmp(p, "-nopageant")) {
402 UNAVAILABLE_IN(TOOLTYPE_NONNETWORK);
404 conf_set_int(conf, CONF_tryagent, FALSE);
407 if (!strcmp(p, "-A")) {
409 UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
411 conf_set_int(conf, CONF_agentfwd, 1);
413 if (!strcmp(p, "-a")) {
415 UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
417 conf_set_int(conf, CONF_agentfwd, 0);
420 if (!strcmp(p, "-X")) {
422 UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
424 conf_set_int(conf, CONF_x11_forward, 1);
426 if (!strcmp(p, "-x")) {
428 UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
430 conf_set_int(conf, CONF_x11_forward, 0);
433 if (!strcmp(p, "-t")) {
435 UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
436 SAVEABLE(1); /* lower priority than -m */
437 conf_set_int(conf, CONF_nopty, 0);
439 if (!strcmp(p, "-T")) {
441 UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
443 conf_set_int(conf, CONF_nopty, 1);
446 if (!strcmp(p, "-N")) {
448 UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
450 conf_set_int(conf, CONF_ssh_no_shell, 1);
453 if (!strcmp(p, "-C")) {
455 UNAVAILABLE_IN(TOOLTYPE_NONNETWORK);
457 conf_set_int(conf, CONF_compression, 1);
460 if (!strcmp(p, "-1")) {
462 UNAVAILABLE_IN(TOOLTYPE_NONNETWORK);
464 conf_set_int(conf, CONF_sshprot, 0); /* ssh protocol 1 only */
466 if (!strcmp(p, "-2")) {
468 UNAVAILABLE_IN(TOOLTYPE_NONNETWORK);
470 conf_set_int(conf, CONF_sshprot, 3); /* ssh protocol 2 only */
473 if (!strcmp(p, "-i")) {
476 UNAVAILABLE_IN(TOOLTYPE_NONNETWORK);
478 fn = filename_from_str(value);
479 conf_set_filename(conf, CONF_keyfile, fn);
483 if (!strcmp(p, "-4") || !strcmp(p, "-ipv4")) {
486 conf_set_int(conf, CONF_addressfamily, ADDRTYPE_IPV4);
488 if (!strcmp(p, "-6") || !strcmp(p, "-ipv6")) {
491 conf_set_int(conf, CONF_addressfamily, ADDRTYPE_IPV6);
493 if (!strcmp(p, "-sercfg")) {
496 UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
498 if (conf_get_int(conf, CONF_protocol) != PROT_SERIAL)
499 cmdline_error("the -sercfg option can only be used with the "
501 /* Value[0] contains one or more , separated values, like 19200,8,n,1,X */
503 while (nextitem[0] != '\0') {
505 char *end = strchr(nextitem, ',');
507 length = strlen(nextitem);
510 length = end - nextitem;
511 nextitem[length] = '\0';
518 conf_set_int(conf, CONF_serstopbits, 2 * (*nextitem-'0'));
526 conf_set_int(conf, CONF_serdatabits, *nextitem-'0');
530 conf_set_int(conf, CONF_serparity, SER_PAR_NONE);
533 conf_set_int(conf, CONF_serparity, SER_PAR_ODD);
536 conf_set_int(conf, CONF_serparity, SER_PAR_EVEN);
539 conf_set_int(conf, CONF_serparity, SER_PAR_MARK);
542 conf_set_int(conf, CONF_serparity, SER_PAR_SPACE);
546 conf_set_int(conf, CONF_serflow, SER_FLOW_NONE);
549 conf_set_int(conf, CONF_serflow, SER_FLOW_XONXOFF);
552 conf_set_int(conf, CONF_serflow, SER_FLOW_RTSCTS);
555 conf_set_int(conf, CONF_serflow, SER_FLOW_DSRDTR);
559 cmdline_error("Unrecognised suboption \"-sercfg %c\"",
562 } else if (length == 3 && !strncmp(nextitem,"1.5",3)) {
563 /* Messy special case */
564 conf_set_int(conf, CONF_serstopbits, 3);
566 int serspeed = atoi(nextitem);
568 conf_set_int(conf, CONF_serspeed, serspeed);
570 cmdline_error("Unrecognised suboption \"-sercfg %s\"",
574 nextitem += length + skip;
577 return ret; /* unrecognised */
580 void cmdline_run_saved(Conf *conf)
583 for (pri = 0; pri < NPRIORITIES; pri++) {
584 for (i = 0; i < saves[pri].nsaved; i++) {
585 cmdline_process_param(saves[pri].params[i].p,
586 saves[pri].params[i].value, 0, conf);
587 sfree(saves[pri].params[i].p);
588 sfree(saves[pri].params[i].value);
590 saves[pri].nsaved = 0;