git.distorted.org.uk Git - u/mdw/putty/blob - cmdline.c

   1 /*
   2  * cmdline.c - command-line parsing shared between many of the
   3  * PuTTY applications
   4  */
   5
   6 #include <stdio.h>
   7 #include <assert.h>
   8 #include <stdlib.h>
   9 #include "putty.h"
  10
  11 /*
  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.
  17  *
  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.
  24  *
  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.)
  29  */
  30
  31 #define NPRIORITIES 2
  32
  33 struct cmdline_saved_param {
  34     char *p, *value;
  35 };
  36 struct cmdline_saved_param_set {
  37     struct cmdline_saved_param *params;
  38     int nsaved, savesize;
  39 };
  40
  41 /*
  42  * C guarantees this structure will be initialised to all zero at
  43  * program start, which is exactly what we want.
  44  */
  45 static struct cmdline_saved_param_set saves[NPRIORITIES];
  46
  47 static void cmdline_save_param(char *p, char *value, int pri)
  48 {
  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);
  53     }
  54     saves[pri].params[saves[pri].nsaved].p = p;
  55     saves[pri].params[saves[pri].nsaved].value = value;
  56     saves[pri].nsaved++;
  57 }
  58
  59 static char *cmdline_password = NULL;
  60
  61 void cmdline_cleanup(void)
  62 {
  63     int pri;
  64
  65     if (cmdline_password) {
  66         memset(cmdline_password, 0, strlen(cmdline_password));
  67         sfree(cmdline_password);
  68         cmdline_password = NULL;
  69     }
  70
  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;
  76     }
  77 }
  78
  79 #define SAVEABLE(pri) do { \
  80     if (need_save) { cmdline_save_param(p, value, pri); return ret; } \
  81 } while (0)
  82
  83 /*
  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.
  87  */
  88 int cmdline_get_passwd_input(prompts_t *p, unsigned char *in, int inlen) {
  89
  90     static int tried_once = 0;
  91
  92     /*
  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.
  96      */
  97     if (!cmdline_password || in || p->n_prompts != 1 || p->prompts[0]->echo) {
  98         return -1;
  99     }
 100
 101     /*
 102      * If we've tried once, return utter failure (no more passwords left
 103      * to try).
 104      */
 105     if (tried_once)
 106         return 0;
 107
 108     strncpy(p->prompts[0]->result, cmdline_password,
 109             p->prompts[0]->result_len);
 110     p->prompts[0]->result[p->prompts[0]->result_len-1] = '\0';
 111     memset(cmdline_password, 0, strlen(cmdline_password));
 112     sfree(cmdline_password);
 113     cmdline_password = NULL;
 114     tried_once = 1;
 115     return 1;
 116
 117 }
 118
 119 /*
 120  * Here we have a flags word which describes the capabilities of
 121  * the particular tool on whose behalf we're running. We will
 122  * refuse certain command-line options if a particular tool
 123  * inherently can't do anything sensible. For example, the file
 124  * transfer tools (psftp, pscp) can't do a great deal with protocol
 125  * selections (ever tried running scp over telnet?) or with port
 126  * forwarding (even if it wasn't a hideously bad idea, they don't
 127  * have the select() infrastructure to make them work).
 128  */
 129 int cmdline_tooltype = 0;
 130
 131 static int cmdline_check_unavailable(int flag, char *p)
 132 {
 133     if (cmdline_tooltype & flag) {
 134         cmdline_error("option \"%s\" not available in this tool", p);
 135         return 1;
 136     }
 137     return 0;
 138 }
 139
 140 #define UNAVAILABLE_IN(flag) do { \
 141     if (cmdline_check_unavailable(flag, p)) return ret; \
 142 } while (0)
 143
 144 /*
 145  * Process a standard command-line parameter. `p' is the parameter
 146  * in question; `value' is the subsequent element of argv, which
 147  * may or may not be required as an operand to the parameter.
 148  * If `need_save' is 1, arguments which need to be saved as
 149  * described at this top of this file are, for later execution;
 150  * if 0, they are processed normally. (-1 is a special value used
 151  * by pterm to count arguments for a preliminary pass through the
 152  * argument list; it causes immediate return with an appropriate
 153  * value with no action taken.)
 154  * Return value is 2 if both arguments were used; 1 if only p was
 155  * used; 0 if the parameter wasn't one we recognised; -2 if it
 156  * should have been 2 but value was NULL.
 157  */
 158
 159 #define RETURN(x) do { \
 160     if ((x) == 2 && !value) return -2; \
 161     ret = x; \
 162     if (need_save < 0) return x; \
 163 } while (0)
 164
 165 int cmdline_process_param(char *p, char *value, int need_save, Conf *conf)
 166 {
 167     int ret = 0;
 168
 169     if (!strcmp(p, "-load")) {
 170         RETURN(2);
 171         /* This parameter must be processed immediately rather than being
 172          * saved. */
 173         do_defaults(value, conf);
 174         loaded_session = TRUE;
 175         cmdline_session_name = dupstr(value);
 176         return 2;
 177     }
 178     if (!strcmp(p, "-ssh")) {
 179         RETURN(1);
 180         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
 181         SAVEABLE(0);
 182         default_protocol = PROT_SSH;
 183         default_port = 22;
 184         conf_set_int(conf, CONF_protocol, default_protocol);
 185         conf_set_int(conf, CONF_port, default_port);
 186         return 1;
 187     }
 188     if (!strcmp(p, "-telnet")) {
 189         RETURN(1);
 190         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
 191         SAVEABLE(0);
 192         default_protocol = PROT_TELNET;
 193         default_port = 23;
 194         conf_set_int(conf, CONF_protocol, default_protocol);
 195         conf_set_int(conf, CONF_port, default_port);
 196         return 1;
 197     }
 198     if (!strcmp(p, "-rlogin")) {
 199         RETURN(1);
 200         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
 201         SAVEABLE(0);
 202         default_protocol = PROT_RLOGIN;
 203         default_port = 513;
 204         conf_set_int(conf, CONF_protocol, default_protocol);
 205         conf_set_int(conf, CONF_port, default_port);
 206         return 1;
 207     }
 208     if (!strcmp(p, "-raw")) {
 209         RETURN(1);
 210         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
 211         SAVEABLE(0);
 212         default_protocol = PROT_RAW;
 213         conf_set_int(conf, CONF_protocol, default_protocol);
 214     }
 215     if (!strcmp(p, "-serial")) {
 216         RETURN(1);
 217         /* Serial is not NONNETWORK in an odd sense of the word */
 218         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
 219         SAVEABLE(0);
 220         default_protocol = PROT_SERIAL;
 221         conf_set_int(conf, CONF_protocol, default_protocol);
 222         /* The host parameter will already be loaded into CONF_host,
 223          * so copy it across */
 224         conf_set_str(conf, CONF_serline, conf_get_str(conf, CONF_host));
 225     }
 226     if (!strcmp(p, "-v")) {
 227         RETURN(1);
 228         flags |= FLAG_VERBOSE;
 229     }
 230     if (!strcmp(p, "-l")) {
 231         RETURN(2);
 232         UNAVAILABLE_IN(TOOLTYPE_NONNETWORK);
 233         SAVEABLE(0);
 234         conf_set_str(conf, CONF_username, value);
 235     }
 236     if (!strcmp(p, "-loghost")) {
 237         RETURN(2);
 238         UNAVAILABLE_IN(TOOLTYPE_NONNETWORK);
 239         SAVEABLE(0);
 240         conf_set_str(conf, CONF_loghost, value);
 241     }
 242     if ((!strcmp(p, "-L") || !strcmp(p, "-R") || !strcmp(p, "-D"))) {
 243         char type, *q, *qq, *key, *val;
 244         RETURN(2);
 245         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
 246         SAVEABLE(0);
 247         if (strcmp(p, "-D")) {
 248             /*
 249              * For -L or -R forwarding types:
 250              *
 251              * We expect _at least_ two colons in this string. The
 252              * possible formats are `sourceport:desthost:destport',
 253              * or `sourceip:sourceport:desthost:destport' if you're
 254              * specifying a particular loopback address. We need to
 255              * replace the one between source and dest with a \t;
 256              * this means we must find the second-to-last colon in
 257              * the string.
 258              *
 259              * (This looks like a foolish way of doing it given the
 260              * existence of strrchr, but it's more efficient than
 261              * two strrchrs - not to mention that the second strrchr
 262              * would require us to modify the input string!)
 263              */
 264
 265             type = p[1];               /* 'L' or 'R' */
 266
 267             q = qq = strchr(value, ':');
 268             while (qq) {
 269                 char *qqq = strchr(qq+1, ':');
 270                 if (qqq)
 271                     q = qq;
 272                 qq = qqq;
 273             }
 274
 275             if (!q) {
 276                 cmdline_error("-%c expects at least two colons in its"
 277                               " argument", type);
 278                 return ret;
 279             }
 280
 281             key = dupprintf("%c%.*s", type, q - value, value);
 282             val = dupstr(q+1);
 283         } else {
 284             /*
 285              * Dynamic port forwardings are entered under the same key
 286              * as if they were local (because they occupy the same
 287              * port space - a local and a dynamic forwarding on the
 288              * same local port are mutually exclusive), with the
 289              * special value "D" (which can be distinguished from
 290              * anything in the ordinary -L case by containing no
 291              * colon).
 292              */
 293             key = dupprintf("L%s", value);
 294             val = dupstr("D");
 295         }
 296         conf_set_str_str(conf, CONF_portfwd, key, val);
 297         sfree(key);
 298         sfree(val);
 299     }
 300     if ((!strcmp(p, "-nc"))) {
 301         char *host, *portp;
 302
 303         RETURN(2);
 304         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
 305         SAVEABLE(0);
 306
 307         portp = strchr(value, ':');
 308         if (!portp) {
 309             cmdline_error("-nc expects argument of form 'host:port'");
 310             return ret;
 311         }
 312
 313         host = dupprintf("%.*s", portp - value, value);
 314         conf_set_str(conf, CONF_ssh_nc_host, host);
 315         conf_set_int(conf, CONF_ssh_nc_port, atoi(portp + 1));
 316         sfree(host);
 317     }
 318     if (!strcmp(p, "-m")) {
 319         char *filename, *command;
 320         int cmdlen, cmdsize;
 321         FILE *fp;
 322         int c, d;
 323
 324         RETURN(2);
 325         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
 326         SAVEABLE(0);
 327
 328         filename = value;
 329
 330         cmdlen = cmdsize = 0;
 331         command = NULL;
 332         fp = fopen(filename, "r");
 333         if (!fp) {
 334             cmdline_error("unable to open command file \"%s\"", filename);
 335             return ret;
 336         }
 337         do {
 338             c = fgetc(fp);
 339             d = c;
 340             if (c == EOF)
 341                 d = 0;
 342             if (cmdlen >= cmdsize) {
 343                 cmdsize = cmdlen + 512;
 344                 command = sresize(command, cmdsize, char);
 345             }
 346             command[cmdlen++] = d;
 347         } while (c != EOF);
 348         fclose(fp);
 349         conf_set_str(conf, CONF_remote_cmd, command);
 350         conf_set_str(conf, CONF_remote_cmd2, "");
 351         conf_set_int(conf, CONF_nopty, TRUE);   /* command => no terminal */
 352         sfree(command);
 353     }
 354     if (!strcmp(p, "-P")) {
 355         RETURN(2);
 356         UNAVAILABLE_IN(TOOLTYPE_NONNETWORK);
 357         SAVEABLE(1);                   /* lower priority than -ssh,-telnet */
 358         conf_set_int(conf, CONF_port, atoi(value));
 359     }
 360     if (!strcmp(p, "-pw")) {
 361         RETURN(2);
 362         UNAVAILABLE_IN(TOOLTYPE_NONNETWORK);
 363         SAVEABLE(1);
 364         /* We delay evaluating this until after the protocol is decided,
 365          * so that we can warn if it's of no use with the selected protocol */
 366         if (conf_get_int(conf, CONF_protocol) != PROT_SSH)
 367             cmdline_error("the -pw option can only be used with the "
 368                           "SSH protocol");
 369         else {
 370             cmdline_password = dupstr(value);
 371             /* Assuming that `value' is directly from argv, make a good faith
 372              * attempt to trample it, to stop it showing up in `ps' output
 373              * on Unix-like systems. Not guaranteed, of course. */
 374             memset(value, 0, strlen(value));
 375         }
 376     }
 377
 378     if (!strcmp(p, "-agent") || !strcmp(p, "-pagent") ||
 379         !strcmp(p, "-pageant")) {
 380         RETURN(1);
 381         UNAVAILABLE_IN(TOOLTYPE_NONNETWORK);
 382         SAVEABLE(0);
 383         conf_set_int(conf, CONF_tryagent, TRUE);
 384     }
 385     if (!strcmp(p, "-noagent") || !strcmp(p, "-nopagent") ||
 386         !strcmp(p, "-nopageant")) {
 387         RETURN(1);
 388         UNAVAILABLE_IN(TOOLTYPE_NONNETWORK);
 389         SAVEABLE(0);
 390         conf_set_int(conf, CONF_tryagent, FALSE);
 391     }
 392
 393     if (!strcmp(p, "-A")) {
 394         RETURN(1);
 395         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
 396         SAVEABLE(0);
 397         conf_set_int(conf, CONF_agentfwd, 1);
 398     }
 399     if (!strcmp(p, "-a")) {
 400         RETURN(1);
 401         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
 402         SAVEABLE(0);
 403         conf_set_int(conf, CONF_agentfwd, 0);
 404     }
 405
 406     if (!strcmp(p, "-X")) {
 407         RETURN(1);
 408         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
 409         SAVEABLE(0);
 410         conf_set_int(conf, CONF_x11_forward, 1);
 411     }
 412     if (!strcmp(p, "-x")) {
 413         RETURN(1);
 414         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
 415         SAVEABLE(0);
 416         conf_set_int(conf, CONF_x11_forward, 0);
 417     }
 418
 419     if (!strcmp(p, "-t")) {
 420         RETURN(1);
 421         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
 422         SAVEABLE(1);    /* lower priority than -m */
 423         conf_set_int(conf, CONF_nopty, 0);
 424     }
 425     if (!strcmp(p, "-T")) {
 426         RETURN(1);
 427         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
 428         SAVEABLE(1);
 429         conf_set_int(conf, CONF_nopty, 1);
 430     }
 431
 432     if (!strcmp(p, "-N")) {
 433         RETURN(1);
 434         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
 435         SAVEABLE(0);
 436         conf_set_int(conf, CONF_ssh_no_shell, 1);
 437     }
 438
 439     if (!strcmp(p, "-C")) {
 440         RETURN(1);
 441         UNAVAILABLE_IN(TOOLTYPE_NONNETWORK);
 442         SAVEABLE(0);
 443         conf_set_int(conf, CONF_compression, 1);
 444     }
 445
 446     if (!strcmp(p, "-1")) {
 447         RETURN(1);
 448         UNAVAILABLE_IN(TOOLTYPE_NONNETWORK);
 449         SAVEABLE(0);
 450         conf_set_int(conf, CONF_sshprot, 0);   /* ssh protocol 1 only */
 451     }
 452     if (!strcmp(p, "-2")) {
 453         RETURN(1);
 454         UNAVAILABLE_IN(TOOLTYPE_NONNETWORK);
 455         SAVEABLE(0);
 456         conf_set_int(conf, CONF_sshprot, 3);   /* ssh protocol 2 only */
 457     }
 458
 459     if (!strcmp(p, "-i")) {
 460         Filename *fn;
 461         RETURN(2);
 462         UNAVAILABLE_IN(TOOLTYPE_NONNETWORK);
 463         SAVEABLE(0);
 464         fn = filename_from_str(value);
 465         conf_set_filename(conf, CONF_keyfile, fn);
 466         filename_free(fn);
 467     }
 468
 469     if (!strcmp(p, "-4") || !strcmp(p, "-ipv4")) {
 470         RETURN(1);
 471         SAVEABLE(1);
 472         conf_set_int(conf, CONF_addressfamily, ADDRTYPE_IPV4);
 473     }
 474     if (!strcmp(p, "-6") || !strcmp(p, "-ipv6")) {
 475         RETURN(1);
 476         SAVEABLE(1);
 477         conf_set_int(conf, CONF_addressfamily, ADDRTYPE_IPV6);
 478     }
 479     if (!strcmp(p, "-sercfg")) {
 480         char* nextitem;
 481         RETURN(2);
 482         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER | TOOLTYPE_NONNETWORK);
 483         SAVEABLE(1);
 484         if (conf_get_int(conf, CONF_protocol) != PROT_SERIAL)
 485             cmdline_error("the -sercfg option can only be used with the "
 486                           "serial protocol");
 487         /* Value[0] contains one or more , separated values, like 19200,8,n,1,X */
 488         nextitem = value;
 489         while (nextitem[0] != '\0') {
 490             int length, skip;
 491             char *end = strchr(nextitem, ',');
 492             if (!end) {
 493                 length = strlen(nextitem);
 494                 skip = 0;
 495             } else {
 496                 length = end - nextitem;
 497                 nextitem[length] = '\0';
 498                 skip = 1;
 499             }
 500             if (length == 1) {
 501                 switch (*nextitem) {
 502                   case '1':
 503                   case '2':
 504                     conf_set_int(conf, CONF_serstopbits, 2 * (*nextitem-'0'));
 505                     break;
 506
 507                   case '5':
 508                   case '6':
 509                   case '7':
 510                   case '8':
 511                   case '9':
 512                     conf_set_int(conf, CONF_serdatabits, *nextitem-'0');
 513                     break;
 514
 515                   case 'n':
 516                     conf_set_int(conf, CONF_serparity, SER_PAR_NONE);
 517                     break;
 518                   case 'o':
 519                     conf_set_int(conf, CONF_serparity, SER_PAR_ODD);
 520                     break;
 521                   case 'e':
 522                     conf_set_int(conf, CONF_serparity, SER_PAR_EVEN);
 523                     break;
 524                   case 'm':
 525                     conf_set_int(conf, CONF_serparity, SER_PAR_MARK);
 526                     break;
 527                   case 's':
 528                     conf_set_int(conf, CONF_serparity, SER_PAR_SPACE);
 529                     break;
 530
 531                   case 'N':
 532                     conf_set_int(conf, CONF_serflow, SER_FLOW_NONE);
 533                     break;
 534                   case 'X':
 535                     conf_set_int(conf, CONF_serflow, SER_FLOW_XONXOFF);
 536                     break;
 537                   case 'R':
 538                     conf_set_int(conf, CONF_serflow, SER_FLOW_RTSCTS);
 539                     break;
 540                   case 'D':
 541                     conf_set_int(conf, CONF_serflow, SER_FLOW_DSRDTR);
 542                     break;
 543
 544                   default:
 545                     cmdline_error("Unrecognised suboption \"-sercfg %c\"",
 546                                   *nextitem);
 547                 }
 548             } else if (length == 3 && !strncmp(nextitem,"1.5",3)) {
 549                 /* Messy special case */
 550                 conf_set_int(conf, CONF_serstopbits, 3);
 551             } else {
 552                 int serspeed = atoi(nextitem);
 553                 if (serspeed != 0) {
 554                     conf_set_int(conf, CONF_serspeed, serspeed);
 555                 } else {
 556                     cmdline_error("Unrecognised suboption \"-sercfg %s\"",
 557                                   nextitem);
 558                 }
 559             }
 560             nextitem += length + skip;
 561         }
 562     }
 563     return ret;                        /* unrecognised */
 564 }
 565
 566 void cmdline_run_saved(Conf *conf)
 567 {
 568     int pri, i;
 569     for (pri = 0; pri < NPRIORITIES; pri++)
 570         for (i = 0; i < saves[pri].nsaved; i++)
 571             cmdline_process_param(saves[pri].params[i].p,
 572                                   saves[pri].params[i].value, 0, conf);
 573 }