]> asedeno.scripts.mit.edu Git - PuTTY.git/blob - psftp.c
Fix a potential segfault
[PuTTY.git] / psftp.c
1 /*
2  * psftp.c: front end for PSFTP.
3  */
4
5 #include <windows.h>
6
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <stdarg.h>
10 #include <assert.h>
11
12 #define PUTTY_DO_GLOBALS
13 #include "putty.h"
14 #include "storage.h"
15 #include "ssh.h"
16 #include "sftp.h"
17 #include "int64.h"
18
19 /* ----------------------------------------------------------------------
20  * String handling routines.
21  */
22
23 char *dupstr(char *s) {
24     int len = strlen(s);
25     char *p = smalloc(len+1);
26     strcpy(p, s);
27     return p;
28 }
29
30 /* Allocate the concatenation of N strings. Terminate arg list with NULL. */
31 char *dupcat(char *s1, ...) {
32     int len;
33     char *p, *q, *sn;
34     va_list ap;
35
36     len = strlen(s1);
37     va_start(ap, s1);
38     while (1) {
39         sn = va_arg(ap, char *);
40         if (!sn)
41             break;
42         len += strlen(sn);
43     }
44     va_end(ap);
45
46     p = smalloc(len+1);
47     strcpy(p, s1);
48     q = p + strlen(p);
49
50     va_start(ap, s1);
51     while (1) {
52         sn = va_arg(ap, char *);
53         if (!sn)
54             break;
55         strcpy(q, sn);
56         q += strlen(q);
57     }
58     va_end(ap);
59
60     return p;
61 }
62
63 /* ----------------------------------------------------------------------
64  * sftp client state.
65  */
66
67 char *pwd, *homedir;
68
69 /* ----------------------------------------------------------------------
70  * Higher-level helper functions used in commands.
71  */
72
73 /*
74  * Attempt to canonify a pathname starting from the pwd. If
75  * canonification fails, at least fall back to returning a _valid_
76  * pathname (though it may be ugly, eg /home/simon/../foobar).
77  */
78 char *canonify(char *name) {
79     char *fullname, *canonname;
80
81     if (name[0] == '/') {
82         fullname = dupstr(name);
83     } else {
84         char *slash;
85         if (pwd[strlen(pwd)-1] == '/')
86             slash = "";
87         else
88             slash = "/";
89         fullname = dupcat(pwd, slash, name, NULL);
90     }
91
92     canonname = fxp_realpath(fullname);
93
94     if (canonname) {
95         sfree(fullname);
96         return canonname;
97     } else {
98         /*
99          * Attempt number 2. Some FXP_REALPATH implementations
100          * (glibc-based ones, in particular) require the _whole_
101          * path to point to something that exists, whereas others
102          * (BSD-based) only require all but the last component to
103          * exist. So if the first call failed, we should strip off
104          * everything from the last slash onwards and try again,
105          * then put the final component back on.
106          * 
107          * Special cases:
108          * 
109          *  - if the last component is "/." or "/..", then we don't
110          *    bother trying this because there's no way it can work.
111          * 
112          *  - if the thing actually ends with a "/", we remove it
113          *    before we start. Except if the string is "/" itself
114          *    (although I can't see why we'd have got here if so,
115          *    because surely "/" would have worked the first
116          *    time?), in which case we don't bother.
117          * 
118          *  - if there's no slash in the string at all, give up in
119          *    confusion (we expect at least one because of the way
120          *    we constructed the string).
121          */
122         
123         int i;
124         char *returnname;
125
126         i = strlen(fullname);
127         if (i > 2 && fullname[i-1] == '/')
128             fullname[--i] = '\0';      /* strip trailing / unless at pos 0 */
129         while (i > 0 && fullname[--i] != '/');
130
131         /*
132          * Give up on special cases.
133          */
134         if (fullname[i] != '/' ||      /* no slash at all */
135             !strcmp(fullname+i, "/.") ||   /* ends in /. */
136             !strcmp(fullname+i, "/..") ||   /* ends in /.. */
137             !strcmp(fullname, "/")) {
138             return fullname;
139         }
140
141         /*
142          * Now i points at the slash. Deal with the final special
143          * case i==0 (ie the whole path was "/nonexistentfile").
144          */
145         fullname[i] = '\0';            /* separate the string */
146         if (i == 0) {
147             canonname = fxp_realpath("/");
148         } else {
149             canonname = fxp_realpath(fullname);
150         }
151
152         if (!canonname)
153             return fullname;           /* even that failed; give up */
154
155         /*
156          * We have a canonical name for all but the last path
157          * component. Concatenate the last component and return.
158          */
159         returnname = dupcat(canonname,
160                             canonname[strlen(canonname)-1] == '/' ? "" : "/",
161                             fullname+i+1, NULL);
162         sfree(fullname);
163         sfree(canonname);
164         return returnname;
165     }
166 }
167
168 /* ----------------------------------------------------------------------
169  * Actual sftp commands.
170  */
171 struct sftp_command {
172     char **words;
173     int nwords, wordssize;
174     int (*obey)(struct sftp_command *);/* returns <0 to quit */
175 };
176
177 int sftp_cmd_null(struct sftp_command *cmd) {
178     return 0;
179 }
180
181 int sftp_cmd_unknown(struct sftp_command *cmd) {
182     printf("psftp: unknown command \"%s\"\n", cmd->words[0]);
183     return 0;
184 }
185
186 int sftp_cmd_quit(struct sftp_command *cmd) {
187     return -1;
188 }
189
190 /*
191  * List a directory. If no arguments are given, list pwd; otherwise
192  * list the directory given in words[1].
193  */
194 static int sftp_ls_compare(const void *av, const void *bv) {
195     const struct fxp_name *a = (const struct fxp_name *)av;
196     const struct fxp_name *b = (const struct fxp_name *)bv;
197     return strcmp(a->filename, b->filename);
198 }
199 int sftp_cmd_ls(struct sftp_command *cmd) {
200     struct fxp_handle *dirh;
201     struct fxp_names *names;
202     struct fxp_name *ournames;
203     int nnames, namesize;
204     char *dir, *cdir;
205     int i;
206
207     if (cmd->nwords < 2)
208         dir = ".";
209     else
210         dir = cmd->words[1];
211
212     cdir = canonify(dir);
213     if (!cdir) {
214         printf("%s: %s\n", dir, fxp_error());
215         return 0;
216     }
217
218     printf("Listing directory %s\n", cdir);
219
220     dirh = fxp_opendir(cdir);
221     if (dirh == NULL) {
222         printf("Unable to open %s: %s\n", dir, fxp_error());
223     } else {
224         nnames = namesize = 0;
225         ournames = NULL;
226
227         while (1) {
228
229             names = fxp_readdir(dirh);
230             if (names == NULL) {
231                 if (fxp_error_type() == SSH_FX_EOF)
232                     break;
233                 printf("Reading directory %s: %s\n", dir, fxp_error());
234                 break;
235             }
236             if (names->nnames == 0) {
237                 fxp_free_names(names);
238                 break;
239             }
240
241             if (nnames + names->nnames >= namesize) {
242                 namesize += names->nnames + 128;
243                 ournames = srealloc(ournames, namesize * sizeof(*ournames));
244             }
245
246             for (i = 0; i < names->nnames; i++)
247                 ournames[nnames++] = names->names[i];
248
249             names->nnames = 0;         /* prevent free_names */
250             fxp_free_names(names);
251         }
252         fxp_close(dirh);
253
254         /*
255          * Now we have our filenames. Sort them by actual file
256          * name, and then output the longname parts.
257          */
258         qsort(ournames, nnames, sizeof(*ournames), sftp_ls_compare);
259
260         /*
261          * And print them.
262          */
263         for (i = 0; i < nnames; i++)
264             printf("%s\n", ournames[i].longname);
265     }
266
267     sfree(cdir);
268
269     return 0;
270 }
271
272 /*
273  * Change directories. We do this by canonifying the new name, then
274  * trying to OPENDIR it. Only if that succeeds do we set the new pwd.
275  */
276 int sftp_cmd_cd(struct sftp_command *cmd) {
277     struct fxp_handle *dirh;
278     char *dir;
279
280     if (cmd->nwords < 2)
281         dir = dupstr(homedir);
282     else
283         dir = canonify(cmd->words[1]);
284
285     if (!dir) {
286         printf("%s: %s\n", dir, fxp_error());
287         return 0;
288     }
289
290     dirh = fxp_opendir(dir);
291     if (!dirh) {
292         printf("Directory %s: %s\n", dir, fxp_error());
293         sfree(dir);
294         return 0;
295     }
296
297     fxp_close(dirh);
298
299     sfree(pwd);
300     pwd = dir;
301     printf("Remote directory is now %s\n", pwd);
302
303     return 0;
304 }
305
306 /*
307  * Get a file and save it at the local end.
308  */
309 int sftp_cmd_get(struct sftp_command *cmd) {
310     struct fxp_handle *fh;
311     char *fname, *outfname;
312     uint64 offset;
313     FILE *fp;
314
315     if (cmd->nwords < 2) {
316         printf("get: expects a filename\n");
317         return 0;
318     }
319
320     fname = canonify(cmd->words[1]);
321     if (!fname) {
322         printf("%s: %s\n", cmd->words[1], fxp_error());
323         return 0;
324     }
325     outfname = (cmd->nwords == 2 ? cmd->words[1] : cmd->words[2]);
326
327     fh = fxp_open(fname, SSH_FXF_READ);
328     if (!fh) {
329         printf("%s: %s\n", fname, fxp_error());
330         sfree(fname);
331         return 0;
332     }
333     fp = fopen(outfname, "wb");
334     if (!fp) {
335         printf("local: unable to open %s\n", outfname);
336         fxp_close(fh);
337         sfree(fname);
338         return 0;
339     }
340
341     printf("remote:%s => local:%s\n", fname, outfname);
342
343     offset = uint64_make(0,0);
344
345     /*
346      * FIXME: we can use FXP_FSTAT here to get the file size, and
347      * thus put up a progress bar.
348      */
349     while (1) {
350         char buffer[4096];
351         int len;
352         int wpos, wlen;
353
354         len = fxp_read(fh, buffer, offset, sizeof(buffer));
355         if ((len == -1 && fxp_error_type() == SSH_FX_EOF) ||
356             len == 0)
357             break;
358         if (len == -1) {
359             printf("error while reading: %s\n", fxp_error());
360             break;
361         }
362         
363         wpos = 0;
364         while (wpos < len) {
365             wlen = fwrite(buffer, 1, len-wpos, fp);
366             if (wlen <= 0) {
367                 printf("error while writing local file\n");
368                 break;
369             }
370             wpos += wlen;
371         }
372         if (wpos < len)                /* we had an error */
373             break;
374         offset = uint64_add32(offset, len);
375     }
376
377     fclose(fp);
378     fxp_close(fh);
379     sfree(fname);
380
381     return 0;
382 }
383
384 /*
385  * Send a file and store it at the remote end.
386  */
387 int sftp_cmd_put(struct sftp_command *cmd) {
388     struct fxp_handle *fh;
389     char *fname, *origoutfname, *outfname;
390     uint64 offset;
391     FILE *fp;
392
393     if (cmd->nwords < 2) {
394         printf("put: expects a filename\n");
395         return 0;
396     }
397
398     fname = cmd->words[1];
399     origoutfname = (cmd->nwords == 2 ? cmd->words[1] : cmd->words[2]);
400     outfname = canonify(origoutfname);
401     if (!outfname) {
402         printf("%s: %s\n", origoutfname, fxp_error());
403         return 0;
404     }
405
406     fp = fopen(fname, "rb");
407     if (!fp) {
408         printf("local: unable to open %s\n", fname);
409         sfree(outfname);
410         return 0;
411     }
412     fh = fxp_open(outfname, SSH_FXF_WRITE | SSH_FXF_CREAT | SSH_FXF_TRUNC);
413     if (!fh) {
414         printf("%s: %s\n", outfname, fxp_error());
415         sfree(outfname);
416         return 0;
417     }
418
419     printf("local:%s => remote:%s\n", fname, outfname);
420
421     offset = uint64_make(0,0);
422
423     /*
424      * FIXME: we can use FXP_FSTAT here to get the file size, and
425      * thus put up a progress bar.
426      */
427     while (1) {
428         char buffer[4096];
429         int len;
430
431         len = fread(buffer, 1, sizeof(buffer), fp);
432         if (len == -1) {
433             printf("error while reading local file\n");
434             break;
435         } else if (len == 0) {
436             break;
437         }
438         if (!fxp_write(fh, buffer, offset, len)) {
439             printf("error while writing: %s\n", fxp_error());
440             break;
441         }
442         offset = uint64_add32(offset, len);
443     }
444
445     fxp_close(fh);
446     fclose(fp);
447     sfree(outfname);
448
449     return 0;
450 }
451
452 static struct sftp_cmd_lookup {
453     char *name;
454     int (*obey)(struct sftp_command *);
455 } sftp_lookup[] = {
456     /*
457      * List of sftp commands. This is binary-searched so it MUST be
458      * in ASCII order.
459      */
460     {"bye", sftp_cmd_quit},
461     {"cd", sftp_cmd_cd},
462     {"dir", sftp_cmd_ls},
463     {"exit", sftp_cmd_quit},
464     {"get", sftp_cmd_get},
465     {"ls", sftp_cmd_ls},
466     {"put", sftp_cmd_put},
467     {"quit", sftp_cmd_quit},
468 };
469
470 /* ----------------------------------------------------------------------
471  * Command line reading and parsing.
472  */
473 struct sftp_command *sftp_getcmd(void) {
474     char *line;
475     int linelen, linesize;
476     struct sftp_command *cmd;
477     char *p, *q, *r;
478     int quoting;
479
480     printf("psftp> ");
481     fflush(stdout);
482
483     cmd = smalloc(sizeof(struct sftp_command));
484     cmd->words = NULL;
485     cmd->nwords = 0;
486     cmd->wordssize = 0;
487
488     line = NULL;
489     linesize = linelen = 0;
490     while (1) {
491         int len;
492         char *ret;
493
494         linesize += 512;
495         line = srealloc(line, linesize);
496         ret = fgets(line+linelen, linesize-linelen, stdin);
497
498         if (!ret || (linelen == 0 && line[0] == '\0')) {
499             cmd->obey = sftp_cmd_quit;
500             printf("quit\n");
501             return cmd;                /* eof */
502         }
503         len = linelen + strlen(line+linelen);
504         linelen += len;
505         if (line[linelen-1] == '\n') {
506             linelen--;
507             line[linelen] = '\0';
508             break;
509         }
510     }
511
512     /*
513      * Parse the command line into words. The syntax is:
514      *  - double quotes are removed, but cause spaces within to be
515      *    treated as non-separating.
516      *  - a double-doublequote pair is a literal double quote, inside
517      *    _or_ outside quotes. Like this:
518      * 
519      *      firstword "second word" "this has ""quotes"" in" sodoes""this""
520      * 
521      * becomes
522      * 
523      *      >firstword<
524      *      >second word<
525      *      >this has "quotes" in<
526      *      >sodoes"this"<
527      */
528     p = line;
529     while (*p) {
530         /* skip whitespace */
531         while (*p && (*p == ' ' || *p == '\t')) p++;
532         /* mark start of word */
533         q = r = p;                     /* q sits at start, r writes word */
534         quoting = 0;
535         while (*p) {
536             if (!quoting && (*p == ' ' || *p == '\t'))
537                 break;                 /* reached end of word */
538             else if (*p == '"' && p[1] == '"')
539                 p+=2, *r++ = '"';      /* a literal quote */
540             else if (*p == '"')
541                 p++, quoting = !quoting;
542             else
543                 *r++ = *p++;
544         }
545         if (*p) p++;                           /* skip over the whitespace */
546         *r = '\0';
547         if (cmd->nwords >= cmd->wordssize) {
548             cmd->wordssize = cmd->nwords + 16;
549             cmd->words = srealloc(cmd->words, cmd->wordssize*sizeof(char *));
550         }
551         cmd->words[cmd->nwords++] = q;
552     }
553
554     /*
555      * Now parse the first word and assign a function.
556      */
557
558     if (cmd->nwords == 0)
559         cmd->obey = sftp_cmd_null;
560     else {
561         int i, j, k, cmp;
562
563         cmd->obey = sftp_cmd_unknown;
564
565         i = -1;
566         j = sizeof(sftp_lookup) / sizeof(*sftp_lookup);
567         while (j - i > 1) {
568             k = (j + i) / 2;
569             cmp = strcmp(cmd->words[0], sftp_lookup[k].name);
570             if (cmp < 0)
571                 j = k;
572             else if (cmp > 0)
573                 i = k;
574             else {
575                 cmd->obey = sftp_lookup[k].obey;
576                 break;
577             }
578         }
579     }
580
581     return cmd;
582 }
583
584 void do_sftp(void) {
585     /*
586      * Do protocol initialisation. 
587      */
588     if (!fxp_init()) {
589         fprintf(stderr,
590                 "Fatal: unable to initialise SFTP: %s\n",
591                 fxp_error());
592         return;
593     }
594
595     /*
596      * Find out where our home directory is.
597      */
598     homedir = fxp_realpath(".");
599     if (!homedir) {
600         fprintf(stderr,
601                 "Warning: failed to resolve home directory: %s\n",
602                 fxp_error());
603         homedir = dupstr(".");
604     } else {
605         printf("Remote working directory is %s\n", homedir);
606     }
607     pwd = dupstr(homedir);
608
609     /* ------------------------------------------------------------------
610      * Now we're ready to do Real Stuff.
611      */
612     while (1) {
613         struct sftp_command *cmd;
614         cmd = sftp_getcmd();
615         if (!cmd)
616             break;
617         if (cmd->obey(cmd) < 0)
618             break;
619     }
620 }
621
622 /* ----------------------------------------------------------------------
623  * Dirty bits: integration with PuTTY.
624  */
625
626 static int verbose = 0;
627
628 void verify_ssh_host_key(char *host, int port, char *keytype,
629                          char *keystr, char *fingerprint) {
630     int ret;
631
632     static const char absentmsg[] =
633         "The server's host key is not cached in the registry. You\n"
634         "have no guarantee that the server is the computer you\n"
635         "think it is.\n"
636         "The server's key fingerprint is:\n"
637         "%s\n"
638         "If you trust this host, enter \"y\" to add the key to\n"
639         "PuTTY's cache and carry on connecting.\n"
640         "If you do not trust this host, enter \"n\" to abandon the\n"
641         "connection.\n"
642         "Continue connecting? (y/n) ";
643
644     static const char wrongmsg[] =
645         "WARNING - POTENTIAL SECURITY BREACH!\n"
646         "The server's host key does not match the one PuTTY has\n"
647         "cached in the registry. This means that either the\n"
648         "server administrator has changed the host key, or you\n"
649         "have actually connected to another computer pretending\n"
650         "to be the server.\n"
651         "The new key fingerprint is:\n"
652         "%s\n"
653         "If you were expecting this change and trust the new key,\n"
654         "enter Yes to update PuTTY's cache and continue connecting.\n"
655         "If you want to carry on connecting but without updating\n"
656         "the cache, enter No.\n"
657         "If you want to abandon the connection completely, press\n"
658         "Return to cancel. Pressing Return is the ONLY guaranteed\n"
659         "safe choice.\n"
660         "Update cached key? (y/n, Return cancels connection) ";
661
662     static const char abandoned[] = "Connection abandoned.\n";
663
664     char line[32];
665
666     /*
667      * Verify the key against the registry.
668      */
669     ret = verify_host_key(host, port, keytype, keystr);
670
671     if (ret == 0)                      /* success - key matched OK */
672         return;
673     if (ret == 2) {                    /* key was different */
674         fprintf(stderr, wrongmsg, fingerprint);
675         if (fgets(line, sizeof(line), stdin) &&
676             line[0] != '\0' && line[0] != '\n') {
677             if (line[0] == 'y' || line[0] == 'Y')
678                 store_host_key(host, port, keytype, keystr);
679         } else {
680             fprintf(stderr, abandoned);
681             exit(0);
682         }
683     }
684     if (ret == 1) {                    /* key was absent */
685         fprintf(stderr, absentmsg, fingerprint);
686         if (fgets(line, sizeof(line), stdin) &&
687             (line[0] == 'y' || line[0] == 'Y'))
688             store_host_key(host, port, keytype, keystr);
689         else {
690             fprintf(stderr, abandoned);
691             exit(0);
692         }
693     }
694 }
695
696 /*
697  *  Print an error message and perform a fatal exit.
698  */
699 void fatalbox(char *fmt, ...)
700 {
701     char str[0x100]; /* Make the size big enough */
702     va_list ap;
703     va_start(ap, fmt);
704     strcpy(str, "Fatal:");
705     vsprintf(str+strlen(str), fmt, ap);
706     va_end(ap);
707     strcat(str, "\n");
708     fprintf(stderr, str);
709
710     exit(1);
711 }
712 void connection_fatal(char *fmt, ...)
713 {
714     char str[0x100]; /* Make the size big enough */
715     va_list ap;
716     va_start(ap, fmt);
717     strcpy(str, "Fatal:");
718     vsprintf(str+strlen(str), fmt, ap);
719     va_end(ap);
720     strcat(str, "\n");
721     fprintf(stderr, str);
722
723     exit(1);
724 }
725
726 void logevent(char *string) { }
727
728 void ldisc_send(char *buf, int len) {
729     /*
730      * This is only here because of the calls to ldisc_send(NULL,
731      * 0) in ssh.c. Nothing in PSFTP actually needs to use the
732      * ldisc as an ldisc. So if we get called with any real data, I
733      * want to know about it.
734      */
735     assert(len == 0);
736 }
737
738 /*
739  * Be told what socket we're supposed to be using.
740  */
741 static SOCKET sftp_ssh_socket;
742 char *do_select(SOCKET skt, int startup) {
743     if (startup)
744         sftp_ssh_socket = skt;
745     else
746         sftp_ssh_socket = INVALID_SOCKET;
747     return NULL;
748 }
749 extern int select_result(WPARAM, LPARAM);
750
751 /*
752  * Receive a block of data from the SSH link. Block until all data
753  * is available.
754  *
755  * To do this, we repeatedly call the SSH protocol module, with our
756  * own trap in from_backend() to catch the data that comes back. We
757  * do this until we have enough data.
758  */
759
760 static unsigned char *outptr;          /* where to put the data */
761 static unsigned outlen;                /* how much data required */
762 static unsigned char *pending = NULL;  /* any spare data */
763 static unsigned pendlen=0, pendsize=0; /* length and phys. size of buffer */
764 void from_backend(int is_stderr, char *data, int datalen) {
765     unsigned char *p = (unsigned char *)data;
766     unsigned len = (unsigned)datalen;
767
768     /*
769      * stderr data is just spouted to local stderr and otherwise
770      * ignored.
771      */
772     if (is_stderr) {
773         fwrite(data, 1, len, stderr);
774         return;
775     }
776
777     /*
778      * If this is before the real session begins, just return.
779      */
780     if (!outptr)
781         return;
782
783     if (outlen > 0) {
784         unsigned used = outlen;
785         if (used > len) used = len;
786         memcpy(outptr, p, used);
787         outptr += used; outlen -= used;
788         p += used; len -= used;
789     }
790
791     if (len > 0) {
792         if (pendsize < pendlen + len) {
793             pendsize = pendlen + len + 4096;
794             pending = (pending ? srealloc(pending, pendsize) :
795                        smalloc(pendsize));
796             if (!pending)
797                 fatalbox("Out of memory");
798         }
799         memcpy(pending+pendlen, p, len);
800         pendlen += len;
801     }
802 }
803 int sftp_recvdata(char *buf, int len) {
804     outptr = (unsigned char *)buf;
805     outlen = len;
806
807     /*
808      * See if the pending-input block contains some of what we
809      * need.
810      */
811     if (pendlen > 0) {
812         unsigned pendused = pendlen;
813         if (pendused > outlen)
814             pendused = outlen;
815         memcpy(outptr, pending, pendused);
816         memmove(pending, pending+pendused, pendlen-pendused);
817         outptr += pendused;
818         outlen -= pendused;
819         pendlen -= pendused;
820         if (pendlen == 0) {
821             pendsize = 0;
822             sfree(pending);
823             pending = NULL;
824         }
825         if (outlen == 0)
826             return 1;
827     }
828
829     while (outlen > 0) {
830         fd_set readfds;
831
832         FD_ZERO(&readfds);
833         FD_SET(sftp_ssh_socket, &readfds);
834         if (select(1, &readfds, NULL, NULL, NULL) < 0)
835             return 0;                  /* doom */
836         select_result((WPARAM)sftp_ssh_socket, (LPARAM)FD_READ);
837     }
838
839     return 1;
840 }
841 int sftp_senddata(char *buf, int len) {
842     back->send((unsigned char *)buf, len);
843     return 1;
844 }
845
846 /*
847  * Loop through the ssh connection and authentication process.
848  */
849 static void ssh_sftp_init(void) {
850     if (sftp_ssh_socket == INVALID_SOCKET)
851         return;
852     while (!back->sendok()) {
853         fd_set readfds;
854         FD_ZERO(&readfds);
855         FD_SET(sftp_ssh_socket, &readfds);
856         if (select(1, &readfds, NULL, NULL, NULL) < 0)
857             return;                    /* doom */
858         select_result((WPARAM)sftp_ssh_socket, (LPARAM)FD_READ);
859     }
860 }
861
862 static char *password = NULL;
863 static int get_password(const char *prompt, char *str, int maxlen)
864 {
865     HANDLE hin, hout;
866     DWORD savemode, i;
867
868     if (password) {
869         static int tried_once = 0;
870
871         if (tried_once) {
872             return 0;
873         } else {
874             strncpy(str, password, maxlen);
875             str[maxlen-1] = '\0';
876             tried_once = 1;
877             return 1;
878         }
879     }
880
881     hin = GetStdHandle(STD_INPUT_HANDLE);
882     hout = GetStdHandle(STD_OUTPUT_HANDLE);
883     if (hin == INVALID_HANDLE_VALUE || hout == INVALID_HANDLE_VALUE) {
884         fprintf(stderr, "Cannot get standard input/output handles\n");
885         exit(1);
886     }
887
888     GetConsoleMode(hin, &savemode);
889     SetConsoleMode(hin, (savemode & (~ENABLE_ECHO_INPUT)) |
890                    ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT);
891
892     WriteFile(hout, prompt, strlen(prompt), &i, NULL);
893     ReadFile(hin, str, maxlen-1, &i, NULL);
894
895     SetConsoleMode(hin, savemode);
896
897     if ((int)i > maxlen) i = maxlen-1; else i = i - 2;
898     str[i] = '\0';
899
900     WriteFile(hout, "\r\n", 2, &i, NULL);
901
902     return 1;
903 }
904
905 /*
906  *  Initialize the Win$ock driver.
907  */
908 static void init_winsock(void)
909 {
910     WORD winsock_ver;
911     WSADATA wsadata;
912
913     winsock_ver = MAKEWORD(1, 1);
914     if (WSAStartup(winsock_ver, &wsadata)) {
915         fprintf(stderr, "Unable to initialise WinSock");
916         exit(1);
917     }
918     if (LOBYTE(wsadata.wVersion) != 1 ||
919         HIBYTE(wsadata.wVersion) != 1) {
920         fprintf(stderr, "WinSock version is incompatible with 1.1");
921         exit(1);
922     }
923 }
924
925 /*
926  *  Short description of parameters.
927  */
928 static void usage(void)
929 {
930     printf("PuTTY Secure File Transfer (SFTP) client\n");
931     printf("%s\n", ver);
932     printf("Usage: psftp [options] user@host\n");
933     printf("Options:\n");
934     printf("  -v        show verbose messages\n");
935     printf("  -P port   connect to specified port\n");
936     printf("  -pw passw login with specified password\n");
937     exit(1);
938 }
939
940 /*
941  * Main program. Parse arguments etc.
942  */
943 int main(int argc, char *argv[])
944 {
945     int i;
946     int portnumber = 0;
947     char *user, *host, *userhost, *realhost;
948     char *err;
949
950     flags = FLAG_STDERR;
951     ssh_get_password = &get_password;
952     init_winsock();
953     sk_init();
954
955     userhost = user = NULL;
956
957     for (i = 1; i < argc; i++) {
958         if (argv[i][0] != '-') {
959             if (userhost)
960                 usage();
961             else
962                 userhost = dupstr(argv[i]);
963         } else if (strcmp(argv[i], "-v") == 0) {
964             verbose = 1, flags |= FLAG_VERBOSE;
965         } else if (strcmp(argv[i], "-h") == 0 ||
966                    strcmp(argv[i], "-?") == 0) {
967             usage();
968         } else if (strcmp(argv[i], "-l") == 0 && i+1 < argc) {
969             user = argv[++i];
970         } else if (strcmp(argv[i], "-P") == 0 && i+1 < argc) {
971             portnumber = atoi(argv[++i]);
972         } else if (strcmp(argv[i], "-pw") == 0 && i+1 < argc) {
973             password = argv[++i];
974         } else if (strcmp(argv[i], "--") == 0) {
975             i++;
976             break;
977         } else {
978             usage();
979         }
980     }
981     argc -= i;
982     argv += i;
983     back = NULL;
984
985     if (argc > 0 || !userhost)
986         usage();
987
988     /* Separate host and username */
989     host = userhost;
990     host = strrchr(host, '@');
991     if (host == NULL) {
992         host = userhost;
993     } else {
994         *host++ = '\0';
995         if (user) {
996             printf("psftp: multiple usernames specified; using \"%s\"\n", user);
997         } else
998             user = userhost;
999     }
1000
1001     /* Try to load settings for this host */
1002     do_defaults(host, &cfg);
1003     if (cfg.host[0] == '\0') {
1004         /* No settings for this host; use defaults */
1005         do_defaults(NULL, &cfg);
1006         strncpy(cfg.host, host, sizeof(cfg.host)-1);
1007         cfg.host[sizeof(cfg.host)-1] = '\0';
1008         cfg.port = 22;
1009     }
1010
1011     /* Set username */
1012     if (user != NULL && user[0] != '\0') {
1013         strncpy(cfg.username, user, sizeof(cfg.username)-1);
1014         cfg.username[sizeof(cfg.username)-1] = '\0';
1015     }
1016     if (!cfg.username[0]) {
1017         printf("login as: ");
1018         if (!fgets(cfg.username, sizeof(cfg.username), stdin)) {
1019             fprintf(stderr, "psftp: aborting\n");
1020             exit(1);
1021         } else {
1022             int len = strlen(cfg.username);
1023             if (cfg.username[len-1] == '\n')
1024                 cfg.username[len-1] = '\0';
1025         }
1026     }
1027
1028     if (cfg.protocol != PROT_SSH)
1029         cfg.port = 22;
1030
1031     if (portnumber)
1032         cfg.port = portnumber;
1033
1034     /* SFTP uses SSH2 by default always */
1035     cfg.sshprot = 2;
1036
1037     /* Set up subsystem name. FIXME: fudge for SSH1. */
1038     strcpy(cfg.remote_cmd, "sftp");
1039     cfg.ssh_subsys = TRUE;
1040     cfg.nopty = TRUE;
1041
1042     back = &ssh_backend;
1043
1044     err = back->init(cfg.host, cfg.port, &realhost);
1045     if (err != NULL) {
1046         fprintf(stderr, "ssh_init: %s", err);
1047         return 1;
1048     }
1049     ssh_sftp_init();
1050     if (verbose && realhost != NULL)
1051         printf("Connected to %s\n", realhost);
1052
1053     do_sftp();
1054
1055     if (back != NULL && back->socket() != NULL) {
1056         char ch;
1057         back->special(TS_EOF);
1058         sftp_recvdata(&ch, 1);
1059     }
1060     WSACleanup();
1061     random_save_seed();
1062
1063     return 0;
1064 }