cmdline.c

   1 #include <stdio.h>
   2 #include <assert.h>
   3 #include <stdlib.h>
   4 #include "putty.h"
   5
   6 /*
   7  * Some command-line parameters need to be saved up until after
   8  * we've loaded the saved session which will form the basis of our
   9  * eventual running configuration. For this we use the macro
  10  * SAVEABLE, which notices if the `need_save' parameter is set and
  11  * saves the parameter and value on a list.
  12  *
  13  * We also assign priorities to saved parameters, just to slightly
  14  * ameliorate silly ordering problems. For example, if you specify
  15  * a saved session to load, it will be loaded _before_ all your
  16  * local modifications such as -L are evaluated; and if you specify
  17  * a protocol and a port, the protocol is set up first so that the
  18  * port can override its choice of port number.
  19  */
  20
  21 #define NPRIORITIES 3
  22
  23 struct cmdline_saved_param {
  24     char *p, *value;
  25 };
  26 struct cmdline_saved_param_set {
  27     struct cmdline_saved_param *params;
  28     int nsaved, savesize;
  29 };
  30
  31 /*
  32  * C guarantees this structure will be initialised to all zero at
  33  * program start, which is exactly what we want.
  34  */
  35 static struct cmdline_saved_param_set saves[NPRIORITIES];
  36
  37 static void cmdline_save_param(char *p, char *value, int pri)
  38 {
  39     if (saves[pri].nsaved >= saves[pri].savesize) {
  40         saves[pri].savesize = saves[pri].nsaved + 32;
  41         saves[pri].params =
  42             srealloc(saves[pri].params,
  43                      saves[pri].savesize*sizeof(*saves[pri].params));
  44     }
  45     saves[pri].params[saves[pri].nsaved].p = p;
  46     saves[pri].params[saves[pri].nsaved].value = value;
  47     saves[pri].nsaved++;
  48 }
  49
  50 #define SAVEABLE(pri) do { \
  51     if (need_save) { cmdline_save_param(p, value, pri); return ret; } \
  52 } while (0)
  53
  54 char *cmdline_password = NULL;
  55
  56 static int cmdline_get_line(const char *prompt, char *str,
  57                             int maxlen, int is_pw)
  58 {
  59     static int tried_once = 0;
  60
  61     assert(is_pw && cmdline_password);
  62
  63     if (tried_once) {
  64         return 0;
  65     } else {
  66         strncpy(str, cmdline_password, maxlen);
  67         str[maxlen - 1] = '\0';
  68         tried_once = 1;
  69         return 1;
  70     }
  71 }
  72
  73 /*
  74  * Here we have a flags word which describes the capabilities of
  75  * the particular tool on whose behalf we're running. We will
  76  * refuse certain command-line options if a particular tool
  77  * inherently can't do anything sensible. For example, the file
  78  * transfer tools (psftp, pscp) can't do a great deal with protocol
  79  * selections (ever tried running scp over telnet?) or with port
  80  * forwarding (even if it wasn't a hideously bad idea, they don't
  81  * have the select() infrastructure to make them work).
  82  */
  83 int cmdline_tooltype = 0;
  84
  85 static int cmdline_check_unavailable(int flag, char *p)
  86 {
  87     if (cmdline_tooltype & flag) {
  88         cmdline_error("option \"%s\" not available in this tool", p);
  89         return 1;
  90     }
  91     return 0;
  92 }
  93
  94 #define UNAVAILABLE_IN(flag) do { \
  95     if (cmdline_check_unavailable(flag, p)) return ret; \
  96 } while (0)
  97
  98 /*
  99  * Process a standard command-line parameter. `p' is the parameter
 100  * in question; `value' is the subsequent element of argv, which
 101  * may or may not be required as an operand to the parameter.
 102  * Return value is 2 if both arguments were used; 1 if only p was
 103  * used; 0 if the parameter wasn't one we recognised; -2 if it
 104  * should have been 2 but value was NULL.
 105  */
 106
 107 #define RETURN(x) do { \
 108     if ((x) == 2 && !value) return -2; \
 109     ret = x; \
 110 } while (0)
 111
 112 int cmdline_process_param(char *p, char *value, int need_save)
 113 {
 114     int ret = 0;
 115
 116     if (!strcmp(p, "-load")) {
 117         RETURN(2);
 118         SAVEABLE(0);                   /* very high priority */
 119         do_defaults(value, &cfg);
 120         return 2;
 121     }
 122     if (!strcmp(p, "-ssh")) {
 123         RETURN(1);
 124         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER);
 125         SAVEABLE(1);
 126         default_protocol = cfg.protocol = PROT_SSH;
 127         default_port = cfg.port = 22;
 128         return 1;
 129     }
 130     if (!strcmp(p, "-telnet")) {
 131         RETURN(1);
 132         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER);
 133         SAVEABLE(1);
 134         default_protocol = cfg.protocol = PROT_TELNET;
 135         default_port = cfg.port = 23;
 136         return 1;
 137     }
 138     if (!strcmp(p, "-rlogin")) {
 139         RETURN(1);
 140         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER);
 141         SAVEABLE(1);
 142         default_protocol = cfg.protocol = PROT_RLOGIN;
 143         default_port = cfg.port = 513;
 144         return 1;
 145     }
 146     if (!strcmp(p, "-raw")) {
 147         RETURN(1);
 148         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER);
 149         SAVEABLE(1);
 150         default_protocol = cfg.protocol = PROT_RAW;
 151     }
 152     if (!strcmp(p, "-v")) {
 153         RETURN(1);
 154         flags |= FLAG_VERBOSE;
 155     }
 156     if (!strcmp(p, "-l")) {
 157         RETURN(2);
 158         SAVEABLE(1);
 159         strncpy(cfg.username, value, sizeof(cfg.username));
 160         cfg.username[sizeof(cfg.username) - 1] = '\0';
 161     }
 162     if ((!strcmp(p, "-L") || !strcmp(p, "-R"))) {
 163         char *fwd, *ptr, *q, *qq;
 164         int i=0;
 165         RETURN(2);
 166         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER);
 167         SAVEABLE(1);
 168         fwd = value;
 169         ptr = cfg.portfwd;
 170         /* if multiple forwards, find end of list */
 171         if (ptr[0]=='R' || ptr[0]=='L') {
 172             for (i = 0; i < sizeof(cfg.portfwd) - 2; i++)
 173                 if (ptr[i]=='\000' && ptr[i+1]=='\000')
 174                     break;
 175             ptr = ptr + i + 1;  /* point to next forward slot */
 176         }
 177         ptr[0] = p[1];  /* insert a 'L' or 'R' at the start */
 178         if (strlen(fwd) > sizeof(cfg.portfwd) - i - 2) {
 179             cmdline_error("out of space for port forwardings");
 180             return ret;
 181         }
 182         strncpy(ptr+1, fwd, sizeof(cfg.portfwd) - i);
 183         /*
 184          * We expect _at least_ two colons in this string. The
 185          * possible formats are `sourceport:desthost:destport', or
 186          * `sourceip:sourceport:desthost:destport' if you're
 187          * specifying a particular loopback address. We need to
 188          * replace the one between source and dest with a \t; this
 189          * means we must find the second-to-last colon in the
 190          * string.
 191          */
 192         q = qq = strchr(ptr, ':');
 193         while (qq) {
 194             char *qqq = strchr(qq+1, ':');
 195             if (qqq)
 196                 q = qq;
 197             qq = qqq;
 198         }
 199         if (q) *q = '\t';              /* replace second-last colon with \t */
 200         cfg.portfwd[sizeof(cfg.portfwd) - 1] = '\0';
 201         cfg.portfwd[sizeof(cfg.portfwd) - 2] = '\0';
 202         ptr[strlen(ptr)+1] = '\000';    /* append two '\000' */
 203     }
 204     if (!strcmp(p, "-m")) {
 205         char *filename, *command;
 206         int cmdlen, cmdsize;
 207         FILE *fp;
 208         int c, d;
 209
 210         RETURN(2);
 211         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER);
 212         SAVEABLE(1);
 213
 214         filename = value;
 215
 216         cmdlen = cmdsize = 0;
 217         command = NULL;
 218         fp = fopen(filename, "r");
 219         if (!fp) {
 220             cmdline_error("unable to open command "
 221                           "file \"%s\"", filename);
 222             return ret;
 223         }
 224         do {
 225             c = fgetc(fp);
 226             d = c;
 227             if (c == EOF)
 228                 d = 0;
 229             if (cmdlen >= cmdsize) {
 230                 cmdsize = cmdlen + 512;
 231                 command = srealloc(command, cmdsize);
 232             }
 233             command[cmdlen++] = d;
 234         } while (c != EOF);
 235         cfg.remote_cmd_ptr = command;
 236         cfg.remote_cmd_ptr2 = NULL;
 237         cfg.nopty = TRUE;      /* command => no terminal */
 238     }
 239     if (!strcmp(p, "-P")) {
 240         RETURN(2);
 241         SAVEABLE(2);                   /* lower priority than -ssh,-telnet */
 242         cfg.port = atoi(value);
 243     }
 244     if (!strcmp(p, "-pw")) {
 245         RETURN(2);
 246         cmdline_password = value;
 247         ssh_get_line = cmdline_get_line;
 248         ssh_getline_pw_only = TRUE;
 249     }
 250
 251     if (!strcmp(p, "-A")) {
 252         RETURN(1);
 253         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER);
 254         SAVEABLE(1);
 255         cfg.agentfwd = 1;
 256     }
 257     if (!strcmp(p, "-a")) {
 258         RETURN(1);
 259         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER);
 260         SAVEABLE(1);
 261         cfg.agentfwd = 0;
 262     }
 263
 264     if (!strcmp(p, "-X")) {
 265         RETURN(1);
 266         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER);
 267         SAVEABLE(1);
 268         cfg.x11_forward = 1;
 269     }
 270     if (!strcmp(p, "-x")) {
 271         RETURN(1);
 272         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER);
 273         SAVEABLE(1);
 274         cfg.x11_forward = 0;
 275     }
 276
 277     if (!strcmp(p, "-t")) {
 278         RETURN(1);
 279         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER);
 280         SAVEABLE(1);
 281         cfg.nopty = 0;
 282     }
 283     if (!strcmp(p, "-T")) {
 284         RETURN(1);
 285         UNAVAILABLE_IN(TOOLTYPE_FILETRANSFER);
 286         SAVEABLE(1);
 287         cfg.nopty = 1;
 288     }
 289
 290     if (!strcmp(p, "-C")) {
 291         RETURN(1);
 292         SAVEABLE(1);
 293         cfg.compression = 1;
 294     }
 295
 296     if (!strcmp(p, "-1")) {
 297         RETURN(1);
 298         SAVEABLE(1);
 299         cfg.sshprot = 0;               /* ssh protocol 1 only */
 300     }
 301     if (!strcmp(p, "-2")) {
 302         RETURN(1);
 303         SAVEABLE(1);
 304         cfg.sshprot = 3;               /* ssh protocol 2 only */
 305     }
 306
 307     if (!strcmp(p, "-i")) {
 308         RETURN(2);
 309         SAVEABLE(1);
 310         strncpy(cfg.keyfile, value, sizeof(cfg.keyfile));
 311         cfg.keyfile[sizeof(cfg.keyfile)-1] = '\0';
 312     }
 313
 314     return ret;                        /* unrecognised */
 315 }
 316
 317 void cmdline_run_saved(void)
 318 {
 319     int pri, i;
 320     for (pri = 0; pri < NPRIORITIES; pri++)
 321         for (i = 0; i < saves[pri].nsaved; i++)
 322             cmdline_process_param(saves[pri].params[i].p,
 323                                   saves[pri].params[i].value, 0);
 324 }