]> asedeno.scripts.mit.edu Git - PuTTY.git/blob - psftp.c
Implement the `close' command, which terminates an SFTP session but
[PuTTY.git] / psftp.c
1 /*
2  * psftp.c: (platform-independent) front end for PSFTP.
3  */
4
5 #include <stdio.h>
6 #include <stdlib.h>
7 #include <stdarg.h>
8 #include <assert.h>
9 #include <limits.h>
10
11 #define PUTTY_DO_GLOBALS
12 #include "putty.h"
13 #include "psftp.h"
14 #include "storage.h"
15 #include "ssh.h"
16 #include "sftp.h"
17 #include "int64.h"
18
19 /*
20  * Since SFTP is a request-response oriented protocol, it requires
21  * no buffer management: when we send data, we stop and wait for an
22  * acknowledgement _anyway_, and so we can't possibly overfill our
23  * send buffer.
24  */
25
26 static int psftp_connect(char *userhost, char *user, int portnumber);
27 static int do_sftp_init(void);
28 void do_sftp_cleanup();
29
30 /* ----------------------------------------------------------------------
31  * sftp client state.
32  */
33
34 char *pwd, *homedir;
35 static Backend *back;
36 static void *backhandle;
37 static Config cfg;
38
39 /* ----------------------------------------------------------------------
40  * Higher-level helper functions used in commands.
41  */
42
43 /*
44  * Determine whether a string is entirely composed of dots.
45  */
46 static int is_dots(char *str)
47 {
48     return str[strspn(str, ".")] == '\0';
49 }
50
51 /*
52  * Attempt to canonify a pathname starting from the pwd. If
53  * canonification fails, at least fall back to returning a _valid_
54  * pathname (though it may be ugly, eg /home/simon/../foobar).
55  */
56 char *canonify(char *name)
57 {
58     char *fullname, *canonname;
59     struct sftp_packet *pktin;
60     struct sftp_request *req, *rreq;
61
62     if (name[0] == '/') {
63         fullname = dupstr(name);
64     } else {
65         char *slash;
66         if (pwd[strlen(pwd) - 1] == '/')
67             slash = "";
68         else
69             slash = "/";
70         fullname = dupcat(pwd, slash, name, NULL);
71     }
72
73     sftp_register(req = fxp_realpath_send(fullname));
74     rreq = sftp_find_request(pktin = sftp_recv());
75     assert(rreq == req);
76     canonname = fxp_realpath_recv(pktin, rreq);
77
78     if (canonname) {
79         sfree(fullname);
80         return canonname;
81     } else {
82         /*
83          * Attempt number 2. Some FXP_REALPATH implementations
84          * (glibc-based ones, in particular) require the _whole_
85          * path to point to something that exists, whereas others
86          * (BSD-based) only require all but the last component to
87          * exist. So if the first call failed, we should strip off
88          * everything from the last slash onwards and try again,
89          * then put the final component back on.
90          * 
91          * Special cases:
92          * 
93          *  - if the last component is "/." or "/..", then we don't
94          *    bother trying this because there's no way it can work.
95          * 
96          *  - if the thing actually ends with a "/", we remove it
97          *    before we start. Except if the string is "/" itself
98          *    (although I can't see why we'd have got here if so,
99          *    because surely "/" would have worked the first
100          *    time?), in which case we don't bother.
101          * 
102          *  - if there's no slash in the string at all, give up in
103          *    confusion (we expect at least one because of the way
104          *    we constructed the string).
105          */
106
107         int i;
108         char *returnname;
109
110         i = strlen(fullname);
111         if (i > 2 && fullname[i - 1] == '/')
112             fullname[--i] = '\0';      /* strip trailing / unless at pos 0 */
113         while (i > 0 && fullname[--i] != '/');
114
115         /*
116          * Give up on special cases.
117          */
118         if (fullname[i] != '/' ||      /* no slash at all */
119             !strcmp(fullname + i, "/.") ||      /* ends in /. */
120             !strcmp(fullname + i, "/..") ||     /* ends in /.. */
121             !strcmp(fullname, "/")) {
122             return fullname;
123         }
124
125         /*
126          * Now i points at the slash. Deal with the final special
127          * case i==0 (ie the whole path was "/nonexistentfile").
128          */
129         fullname[i] = '\0';            /* separate the string */
130         if (i == 0) {
131             sftp_register(req = fxp_realpath_send("/"));
132         } else {
133             sftp_register(req = fxp_realpath_send(fullname));
134         }
135         rreq = sftp_find_request(pktin = sftp_recv());
136         assert(rreq == req);
137         canonname = fxp_realpath_recv(pktin, rreq);
138
139         if (!canonname)
140             return fullname;           /* even that failed; give up */
141
142         /*
143          * We have a canonical name for all but the last path
144          * component. Concatenate the last component and return.
145          */
146         returnname = dupcat(canonname,
147                             canonname[strlen(canonname) - 1] ==
148                             '/' ? "" : "/", fullname + i + 1, NULL);
149         sfree(fullname);
150         sfree(canonname);
151         return returnname;
152     }
153 }
154
155 /*
156  * Return a pointer to the portion of str that comes after the last
157  * slash (or backslash or colon, if `local' is TRUE).
158  */
159 static char *stripslashes(char *str, int local)
160 {
161     char *p;
162
163     if (local) {
164         p = strchr(str, ':');
165         if (p) str = p+1;
166     }
167
168     p = strrchr(str, '/');
169     if (p) str = p+1;
170
171     if (local) {
172         p = strrchr(str, '\\');
173         if (p) str = p+1;
174     }
175
176     return str;
177 }
178
179 /*
180  * qsort comparison routine for fxp_name structures. Sorts by real
181  * file name.
182  */
183 static int sftp_name_compare(const void *av, const void *bv)
184 {
185     const struct fxp_name *const *a = (const struct fxp_name *const *) av;
186     const struct fxp_name *const *b = (const struct fxp_name *const *) bv;
187     return strcmp((*a)->filename, (*b)->filename);
188 }
189
190 /*
191  * Likewise, but for a bare char *.
192  */
193 static int bare_name_compare(const void *av, const void *bv)
194 {
195     const char **a = (const char **) av;
196     const char **b = (const char **) bv;
197     return strcmp(*a, *b);
198 }
199
200 /* ----------------------------------------------------------------------
201  * The meat of the `get' and `put' commands.
202  */
203 int sftp_get_file(char *fname, char *outfname, int recurse, int restart,
204                   char *wildcard)
205 {
206     struct fxp_handle *fh;
207     struct sftp_packet *pktin;
208     struct sftp_request *req, *rreq;
209     struct fxp_xfer *xfer;
210     uint64 offset;
211     FILE *fp;
212     int ret;
213
214     /*
215      * In recursive mode, see if we're dealing with a directory.
216      * (If we're not in recursive mode, we need not even check: the
217      * subsequent FXP_OPEN will return a usable error message.)
218      */
219     if (wildcard || recurse) {
220         struct fxp_attrs attrs;
221         int result;
222
223         if (!wildcard) {
224             sftp_register(req = fxp_stat_send(fname));
225             rreq = sftp_find_request(pktin = sftp_recv());
226             assert(rreq == req);
227             result = fxp_stat_recv(pktin, rreq, &attrs);
228         } else
229             result = 0;                /* placate optimisers */
230
231         if (wildcard ||
232             (result &&
233              (attrs.flags & SSH_FILEXFER_ATTR_PERMISSIONS) &&
234              (attrs.permissions & 0040000))) {
235
236             struct fxp_handle *dirhandle;
237             int nnames, namesize;
238             struct fxp_name **ournames;
239             struct fxp_names *names;
240             int i;
241
242             /*
243              * First, attempt to create the destination directory,
244              * unless it already exists (or this is a wildcard
245              * run).
246              */
247             if (!wildcard &&
248                 file_type(outfname) != FILE_TYPE_DIRECTORY &&
249                 !create_directory(outfname)) {
250                 printf("%s: Cannot create directory\n", outfname);
251                 return 0;
252             }
253
254             /*
255              * Now get the list of filenames in the remote
256              * directory.
257              */
258             sftp_register(req = fxp_opendir_send(fname));
259             rreq = sftp_find_request(pktin = sftp_recv());
260             assert(rreq == req);
261             dirhandle = fxp_opendir_recv(pktin, rreq);
262
263             if (!dirhandle) {
264                 printf("%s: unable to open directory: %s\n",
265                        fname, fxp_error());
266                 return 0;
267             }
268             nnames = namesize = 0;
269             ournames = NULL;
270             while (1) {
271                 int i;
272
273                 sftp_register(req = fxp_readdir_send(dirhandle));
274                 rreq = sftp_find_request(pktin = sftp_recv());
275                 assert(rreq == req);
276                 names = fxp_readdir_recv(pktin, rreq);
277
278                 if (names == NULL) {
279                     if (fxp_error_type() == SSH_FX_EOF)
280                         break;
281                     printf("%s: reading directory: %s\n", fname, fxp_error());
282                     sfree(ournames);
283                     return 0;
284                 }
285                 if (names->nnames == 0) {
286                     fxp_free_names(names);
287                     break;
288                 }
289                 if (nnames + names->nnames >= namesize) {
290                     namesize += names->nnames + 128;
291                     ournames = sresize(ournames, namesize, struct fxp_name *);
292                 }
293                 for (i = 0; i < names->nnames; i++)
294                     if (!is_dots(names->names[i].filename) &&
295                         (!wildcard || wc_match(wildcard,
296                                                names->names[i].filename)))
297                         ournames[nnames++] = fxp_dup_name(&names->names[i]);
298                 fxp_free_names(names);
299             }
300             sftp_register(req = fxp_close_send(dirhandle));
301             rreq = sftp_find_request(pktin = sftp_recv());
302             assert(rreq == req);
303             fxp_close_recv(pktin, rreq);
304
305             /*
306              * A polite warning if nothing at all matched the
307              * wildcard.
308              */
309             if (wildcard && !nnames) {
310                 printf("%s: nothing matched\n", wildcard);
311             }
312
313             /*
314              * Sort the names into a clear order. This ought to
315              * make things more predictable when we're doing a
316              * reget of the same directory, just in case two
317              * readdirs on the same remote directory return a
318              * different order.
319              */
320             qsort(ournames, nnames, sizeof(*ournames), sftp_name_compare);
321
322             /*
323              * If we're in restart mode, find the last filename on
324              * this list that already exists. We may have to do a
325              * reget on _that_ file, but shouldn't have to do
326              * anything on the previous files.
327              * 
328              * If none of them exists, of course, we start at 0.
329              */
330             i = 0;
331             while (i < nnames) {
332                 char *nextoutfname;
333                 int ret;
334                 if (outfname)
335                     nextoutfname = dir_file_cat(outfname,
336                                                 ournames[i]->filename);
337                 else
338                     nextoutfname = dupstr(ournames[i]->filename);
339                 ret = (file_type(nextoutfname) == FILE_TYPE_NONEXISTENT);
340                 sfree(nextoutfname);
341                 if (ret)
342                     break;
343                 i++;
344             }
345             if (i > 0)
346                 i--;
347
348             /*
349              * Now we're ready to recurse. Starting at ournames[i]
350              * and continuing on to the end of the list, we
351              * construct a new source and target file name, and
352              * call sftp_get_file again.
353              */
354             for (; i < nnames; i++) {
355                 char *nextfname, *nextoutfname;
356                 int ret;
357                 
358                 nextfname = dupcat(fname, "/", ournames[i]->filename, NULL);
359                 if (outfname)
360                     nextoutfname = dir_file_cat(outfname,
361                                                 ournames[i]->filename);
362                 else
363                     nextoutfname = dupstr(ournames[i]->filename);
364                 ret = sftp_get_file(nextfname, nextoutfname,
365                                     recurse, restart, NULL);
366                 restart = FALSE;       /* after first partial file, do full */
367                 sfree(nextoutfname);
368                 sfree(nextfname);
369                 if (!ret) {
370                     for (i = 0; i < nnames; i++) {
371                         fxp_free_name(ournames[i]);
372                     }
373                     sfree(ournames);
374                     return 0;
375                 }
376             }
377
378             /*
379              * Done this recursion level. Free everything.
380              */
381             for (i = 0; i < nnames; i++) {
382                 fxp_free_name(ournames[i]);
383             }
384             sfree(ournames);
385
386             return 1;
387         }
388     }
389
390     sftp_register(req = fxp_open_send(fname, SSH_FXF_READ));
391     rreq = sftp_find_request(pktin = sftp_recv());
392     assert(rreq == req);
393     fh = fxp_open_recv(pktin, rreq);
394
395     if (!fh) {
396         printf("%s: %s\n", fname, fxp_error());
397         return 0;
398     }
399
400     if (restart) {
401         fp = fopen(outfname, "rb+");
402     } else {
403         fp = fopen(outfname, "wb");
404     }
405
406     if (!fp) {
407         printf("local: unable to open %s\n", outfname);
408
409         sftp_register(req = fxp_close_send(fh));
410         rreq = sftp_find_request(pktin = sftp_recv());
411         assert(rreq == req);
412         fxp_close_recv(pktin, rreq);
413
414         return 0;
415     }
416
417     if (restart) {
418         long posn;
419         fseek(fp, 0L, SEEK_END);
420         posn = ftell(fp);
421         printf("reget: restarting at file position %ld\n", posn);
422         offset = uint64_make(0, posn);
423     } else {
424         offset = uint64_make(0, 0);
425     }
426
427     printf("remote:%s => local:%s\n", fname, outfname);
428
429     /*
430      * FIXME: we can use FXP_FSTAT here to get the file size, and
431      * thus put up a progress bar.
432      */
433     ret = 1;
434     xfer = xfer_download_init(fh, offset);
435     while (!xfer_done(xfer)) {
436         void *vbuf;
437         int ret, len;
438         int wpos, wlen;
439
440         xfer_download_queue(xfer);
441         pktin = sftp_recv();
442         ret = xfer_download_gotpkt(xfer, pktin);
443
444         if (ret < 0) {
445             printf("error while reading: %s\n", fxp_error());
446             ret = 0;
447         }
448
449         while (xfer_download_data(xfer, &vbuf, &len)) {
450             unsigned char *buf = (unsigned char *)vbuf;
451
452             wpos = 0;
453             while (wpos < len) {
454                 wlen = fwrite(buf + wpos, 1, len - wpos, fp);
455                 if (wlen <= 0) {
456                     printf("error while writing local file\n");
457                     ret = 0;
458                     xfer_set_error(xfer);
459                 }
460                 wpos += wlen;
461             }
462             if (wpos < len) {          /* we had an error */
463                 ret = 0;
464                 xfer_set_error(xfer);
465             }
466
467             sfree(vbuf);
468         }
469     }
470
471     xfer_cleanup(xfer);
472
473     fclose(fp);
474
475     sftp_register(req = fxp_close_send(fh));
476     rreq = sftp_find_request(pktin = sftp_recv());
477     assert(rreq == req);
478     fxp_close_recv(pktin, rreq);
479
480     return ret;
481 }
482
483 int sftp_put_file(char *fname, char *outfname, int recurse, int restart,
484                   char *wildcard)
485 {
486     struct fxp_handle *fh;
487     struct fxp_xfer *xfer;
488     struct sftp_packet *pktin;
489     struct sftp_request *req, *rreq;
490     uint64 offset;
491     FILE *fp;
492     int ret, err, eof;
493
494     /*
495      * In recursive mode, see if we're dealing with a directory.
496      * (If we're not in recursive mode, we need not even check: the
497      * subsequent fopen will return an error message.)
498      */
499     if (wildcard || (recurse && file_type(fname) == FILE_TYPE_DIRECTORY)) {
500         struct fxp_attrs attrs;
501         int result;
502         int nnames, namesize;
503         char *name, **ournames;
504         DirHandle *dh;
505         int i;
506
507         if (!wildcard) {
508             /*
509              * First, attempt to create the destination directory,
510              * unless it already exists.
511              */
512             sftp_register(req = fxp_stat_send(outfname));
513             rreq = sftp_find_request(pktin = sftp_recv());
514             assert(rreq == req);
515             result = fxp_stat_recv(pktin, rreq, &attrs);
516             if (!result ||
517                 !(attrs.flags & SSH_FILEXFER_ATTR_PERMISSIONS) ||
518                 !(attrs.permissions & 0040000)) {
519                 sftp_register(req = fxp_mkdir_send(outfname));
520                 rreq = sftp_find_request(pktin = sftp_recv());
521                 assert(rreq == req);
522                 result = fxp_mkdir_recv(pktin, rreq);
523
524                 if (!result) {
525                     printf("%s: create directory: %s\n",
526                            outfname, fxp_error());
527                     return 0;
528                 }
529             }
530         }
531
532         /*
533          * Now get the list of filenames in the local directory.
534          */
535         nnames = namesize = 0;
536         ournames = NULL;
537         if (wildcard) {
538             WildcardMatcher *wcm;
539
540             wcm = begin_wildcard_matching(wildcard);
541             if (wcm) {
542                 while ((name = wildcard_get_filename(wcm)) != NULL) {
543                     if (nnames >= namesize) {
544                         namesize += 128;
545                         ournames = sresize(ournames, namesize, char *);
546                     }
547                     ournames[nnames++] = name;
548                 }
549                 finish_wildcard_matching(wcm);
550             }
551         } else {
552             dh = open_directory(fname);
553             if (!dh) {
554                 printf("%s: unable to open directory\n", fname);
555                 return 0;
556             }
557             while ((name = read_filename(dh)) != NULL) {
558                 if (nnames >= namesize) {
559                     namesize += 128;
560                     ournames = sresize(ournames, namesize, char *);
561                 }
562                 ournames[nnames++] = name;
563             }
564             close_directory(dh);
565         }
566
567         /*
568          * A polite warning if nothing at all matched the
569          * wildcard.
570          */
571         if (wildcard && !nnames) {
572             printf("%s: nothing matched\n", wildcard);
573         }
574
575         /*
576          * Sort the names into a clear order. This ought to make
577          * things more predictable when we're doing a reput of the
578          * same directory, just in case two readdirs on the same
579          * local directory return a different order.
580          */
581         qsort(ournames, nnames, sizeof(*ournames), bare_name_compare);
582
583         /*
584          * If we're in restart mode, find the last filename on this
585          * list that already exists. We may have to do a reput on
586          * _that_ file, but shouldn't have to do anything on the
587          * previous files.
588          *
589          * If none of them exists, of course, we start at 0.
590          */
591         i = 0;
592         while (i < nnames) {
593             char *nextoutfname;
594             nextoutfname = dupcat(outfname, "/", ournames[i], NULL);
595             sftp_register(req = fxp_stat_send(nextoutfname));
596             rreq = sftp_find_request(pktin = sftp_recv());
597             assert(rreq == req);
598             result = fxp_stat_recv(pktin, rreq, &attrs);
599             sfree(nextoutfname);
600             if (!result)
601                 break;
602             i++;
603         }
604         if (i > 0)
605             i--;
606
607         /*
608          * Now we're ready to recurse. Starting at ournames[i]
609          * and continuing on to the end of the list, we
610          * construct a new source and target file name, and
611          * call sftp_put_file again.
612          */
613         for (; i < nnames; i++) {
614             char *nextfname, *nextoutfname;
615             int ret;
616
617             if (fname)
618                 nextfname = dir_file_cat(fname, ournames[i]);
619             else
620                 nextfname = dupstr(ournames[i]);
621             nextoutfname = dupcat(outfname, "/", ournames[i], NULL);
622             ret = sftp_put_file(nextfname, nextoutfname,
623                                 recurse, restart, NULL);
624             restart = FALSE;           /* after first partial file, do full */
625             sfree(nextoutfname);
626             sfree(nextfname);
627             if (!ret) {
628                 for (i = 0; i < nnames; i++) {
629                     sfree(ournames[i]);
630                 }
631                 sfree(ournames);
632                 return 0;
633             }
634         }
635
636         /*
637          * Done this recursion level. Free everything.
638          */
639         for (i = 0; i < nnames; i++) {
640             sfree(ournames[i]);
641         }
642         sfree(ournames);
643
644         return 1;
645     }
646
647     fp = fopen(fname, "rb");
648     if (!fp) {
649         printf("local: unable to open %s\n", fname);
650         return 0;
651     }
652     if (restart) {
653         sftp_register(req = fxp_open_send(outfname, SSH_FXF_WRITE));
654     } else {
655         sftp_register(req = fxp_open_send(outfname, SSH_FXF_WRITE |
656                                           SSH_FXF_CREAT | SSH_FXF_TRUNC));
657     }
658     rreq = sftp_find_request(pktin = sftp_recv());
659     assert(rreq == req);
660     fh = fxp_open_recv(pktin, rreq);
661
662     if (!fh) {
663         printf("%s: %s\n", outfname, fxp_error());
664         return 0;
665     }
666
667     if (restart) {
668         char decbuf[30];
669         struct fxp_attrs attrs;
670         int ret;
671
672         sftp_register(req = fxp_fstat_send(fh));
673         rreq = sftp_find_request(pktin = sftp_recv());
674         assert(rreq == req);
675         ret = fxp_fstat_recv(pktin, rreq, &attrs);
676
677         if (!ret) {
678             printf("read size of %s: %s\n", outfname, fxp_error());
679             return 0;
680         }
681         if (!(attrs.flags & SSH_FILEXFER_ATTR_SIZE)) {
682             printf("read size of %s: size was not given\n", outfname);
683             return 0;
684         }
685         offset = attrs.size;
686         uint64_decimal(offset, decbuf);
687         printf("reput: restarting at file position %s\n", decbuf);
688         if (uint64_compare(offset, uint64_make(0, LONG_MAX)) > 0) {
689             printf("reput: remote file is larger than we can deal with\n");
690             return 0;
691         }
692         if (fseek(fp, offset.lo, SEEK_SET) != 0)
693             fseek(fp, 0, SEEK_END);    /* *shrug* */
694     } else {
695         offset = uint64_make(0, 0);
696     }
697
698     printf("local:%s => remote:%s\n", fname, outfname);
699
700     /*
701      * FIXME: we can use FXP_FSTAT here to get the file size, and
702      * thus put up a progress bar.
703      */
704     ret = 1;
705     xfer = xfer_upload_init(fh, offset);
706     err = eof = 0;
707     while ((!err && !eof) || !xfer_done(xfer)) {
708         char buffer[4096];
709         int len, ret;
710
711         while (xfer_upload_ready(xfer) && !err && !eof) {
712             len = fread(buffer, 1, sizeof(buffer), fp);
713             if (len == -1) {
714                 printf("error while reading local file\n");
715                 err = 1;
716             } else if (len == 0) {
717                 eof = 1;
718             } else {
719                 xfer_upload_data(xfer, buffer, len);
720             }
721         }
722
723         if (!xfer_done(xfer)) {
724             pktin = sftp_recv();
725             ret = xfer_upload_gotpkt(xfer, pktin);
726             if (!ret) {
727                 printf("error while writing: %s\n", fxp_error());
728                 err = 1;
729             }
730         }
731     }
732
733     xfer_cleanup(xfer);
734
735     sftp_register(req = fxp_close_send(fh));
736     rreq = sftp_find_request(pktin = sftp_recv());
737     assert(rreq == req);
738     fxp_close_recv(pktin, rreq);
739
740     fclose(fp);
741
742     return ret;
743 }
744
745 /* ----------------------------------------------------------------------
746  * Actual sftp commands.
747  */
748 struct sftp_command {
749     char **words;
750     int nwords, wordssize;
751     int (*obey) (struct sftp_command *);        /* returns <0 to quit */
752 };
753
754 int sftp_cmd_null(struct sftp_command *cmd)
755 {
756     return 1;                          /* success */
757 }
758
759 int sftp_cmd_unknown(struct sftp_command *cmd)
760 {
761     printf("psftp: unknown command \"%s\"\n", cmd->words[0]);
762     return 0;                          /* failure */
763 }
764
765 int sftp_cmd_quit(struct sftp_command *cmd)
766 {
767     return -1;
768 }
769
770 int sftp_cmd_close(struct sftp_command *cmd)
771 {
772     if (back == NULL) {
773         printf("psftp: not connected to a host; use \"open host.name\"\n");
774         return 0;
775     }
776
777     if (back != NULL && back->socket(backhandle) != NULL) {
778         char ch;
779         back->special(backhandle, TS_EOF);
780         sftp_recvdata(&ch, 1);
781     }
782     do_sftp_cleanup();
783
784     return 0;
785 }
786
787 /*
788  * List a directory. If no arguments are given, list pwd; otherwise
789  * list the directory given in words[1].
790  */
791 int sftp_cmd_ls(struct sftp_command *cmd)
792 {
793     struct fxp_handle *dirh;
794     struct fxp_names *names;
795     struct fxp_name **ournames;
796     int nnames, namesize;
797     char *dir, *cdir, *unwcdir, *wildcard;
798     struct sftp_packet *pktin;
799     struct sftp_request *req, *rreq;
800     int i;
801
802     if (back == NULL) {
803         printf("psftp: not connected to a host; use \"open host.name\"\n");
804         return 0;
805     }
806
807     if (cmd->nwords < 2)
808         dir = ".";
809     else
810         dir = cmd->words[1];
811
812     unwcdir = snewn(1 + strlen(dir), char);
813     if (wc_unescape(unwcdir, dir)) {
814         dir = unwcdir;
815         wildcard = NULL;
816     } else {
817         char *tmpdir;
818         int len, check;
819
820         wildcard = stripslashes(dir, 0);
821         unwcdir = dupstr(dir);
822         len = wildcard - dir;
823         unwcdir[len] = '\0';
824         if (len > 0 && unwcdir[len-1] == '/')
825             unwcdir[len-1] = '\0';
826         tmpdir = snewn(1 + len, char);
827         check = wc_unescape(tmpdir, unwcdir);
828         sfree(tmpdir);
829         if (!check) {
830             printf("Multiple-level wildcards are not supported\n");
831             sfree(unwcdir);
832             return 0;
833         }
834         dir = unwcdir;
835     }
836
837     cdir = canonify(dir);
838     if (!cdir) {
839         printf("%s: %s\n", dir, fxp_error());
840         sfree(unwcdir);
841         return 0;
842     }
843
844     printf("Listing directory %s\n", cdir);
845
846     sftp_register(req = fxp_opendir_send(cdir));
847     rreq = sftp_find_request(pktin = sftp_recv());
848     assert(rreq == req);
849     dirh = fxp_opendir_recv(pktin, rreq);
850
851     if (dirh == NULL) {
852         printf("Unable to open %s: %s\n", dir, fxp_error());
853     } else {
854         nnames = namesize = 0;
855         ournames = NULL;
856
857         while (1) {
858
859             sftp_register(req = fxp_readdir_send(dirh));
860             rreq = sftp_find_request(pktin = sftp_recv());
861             assert(rreq == req);
862             names = fxp_readdir_recv(pktin, rreq);
863
864             if (names == NULL) {
865                 if (fxp_error_type() == SSH_FX_EOF)
866                     break;
867                 printf("Reading directory %s: %s\n", dir, fxp_error());
868                 break;
869             }
870             if (names->nnames == 0) {
871                 fxp_free_names(names);
872                 break;
873             }
874
875             if (nnames + names->nnames >= namesize) {
876                 namesize += names->nnames + 128;
877                 ournames = sresize(ournames, namesize, struct fxp_name *);
878             }
879
880             for (i = 0; i < names->nnames; i++)
881                 if (!wildcard || wc_match(wildcard, names->names[i].filename))
882                     ournames[nnames++] = fxp_dup_name(&names->names[i]);
883
884             fxp_free_names(names);
885         }
886         sftp_register(req = fxp_close_send(dirh));
887         rreq = sftp_find_request(pktin = sftp_recv());
888         assert(rreq == req);
889         fxp_close_recv(pktin, rreq);
890
891         /*
892          * Now we have our filenames. Sort them by actual file
893          * name, and then output the longname parts.
894          */
895         qsort(ournames, nnames, sizeof(*ournames), sftp_name_compare);
896
897         /*
898          * And print them.
899          */
900         for (i = 0; i < nnames; i++) {
901             printf("%s\n", ournames[i]->longname);
902             fxp_free_name(ournames[i]);
903         }
904         sfree(ournames);
905     }
906
907     sfree(cdir);
908     sfree(unwcdir);
909
910     return 1;
911 }
912
913 /*
914  * Change directories. We do this by canonifying the new name, then
915  * trying to OPENDIR it. Only if that succeeds do we set the new pwd.
916  */
917 int sftp_cmd_cd(struct sftp_command *cmd)
918 {
919     struct fxp_handle *dirh;
920     struct sftp_packet *pktin;
921     struct sftp_request *req, *rreq;
922     char *dir;
923
924     if (back == NULL) {
925         printf("psftp: not connected to a host; use \"open host.name\"\n");
926         return 0;
927     }
928
929     if (cmd->nwords < 2)
930         dir = dupstr(homedir);
931     else
932         dir = canonify(cmd->words[1]);
933
934     if (!dir) {
935         printf("%s: %s\n", dir, fxp_error());
936         return 0;
937     }
938
939     sftp_register(req = fxp_opendir_send(dir));
940     rreq = sftp_find_request(pktin = sftp_recv());
941     assert(rreq == req);
942     dirh = fxp_opendir_recv(pktin, rreq);
943
944     if (!dirh) {
945         printf("Directory %s: %s\n", dir, fxp_error());
946         sfree(dir);
947         return 0;
948     }
949
950     sftp_register(req = fxp_close_send(dirh));
951     rreq = sftp_find_request(pktin = sftp_recv());
952     assert(rreq == req);
953     fxp_close_recv(pktin, rreq);
954
955     sfree(pwd);
956     pwd = dir;
957     printf("Remote directory is now %s\n", pwd);
958
959     return 1;
960 }
961
962 /*
963  * Print current directory. Easy as pie.
964  */
965 int sftp_cmd_pwd(struct sftp_command *cmd)
966 {
967     if (back == NULL) {
968         printf("psftp: not connected to a host; use \"open host.name\"\n");
969         return 0;
970     }
971
972     printf("Remote directory is %s\n", pwd);
973     return 1;
974 }
975
976 /*
977  * Get a file and save it at the local end. We have three very
978  * similar commands here. The basic one is `get'; `reget' differs
979  * in that it checks for the existence of the destination file and
980  * starts from where a previous aborted transfer left off; `mget'
981  * differs in that it interprets all its arguments as files to
982  * transfer (never as a different local name for a remote file) and
983  * can handle wildcards.
984  */
985 int sftp_general_get(struct sftp_command *cmd, int restart, int multiple)
986 {
987     char *fname, *unwcfname, *origfname, *outfname;
988     int i, ret;
989     int recurse = FALSE;
990
991     if (back == NULL) {
992         printf("psftp: not connected to a host; use \"open host.name\"\n");
993         return 0;
994     }
995
996     i = 1;
997     while (i < cmd->nwords && cmd->words[i][0] == '-') {
998         if (!strcmp(cmd->words[i], "--")) {
999             /* finish processing options */
1000             i++;
1001             break;
1002         } else if (!strcmp(cmd->words[i], "-r")) {
1003             recurse = TRUE;
1004         } else {
1005             printf("get: unrecognised option '%s'\n", cmd->words[i]);
1006             return 0;
1007         }
1008         i++;
1009     }
1010
1011     if (i >= cmd->nwords) {
1012         printf("get: expects a filename\n");
1013         return 0;
1014     }
1015
1016     do {
1017         unwcfname = NULL;
1018         origfname = cmd->words[i++];
1019
1020         if (multiple &&
1021             !wc_unescape(unwcfname = snewn(strlen(origfname)+1, char),
1022                          origfname)) {
1023             ret = sftp_get_file(pwd, NULL, recurse, restart, origfname);
1024         } else {
1025             fname = canonify(origfname);
1026             if (!fname) {
1027                 printf("%s: %s\n", origfname, fxp_error());
1028                 sfree(unwcfname);
1029                 return 0;
1030             }
1031
1032             if (!multiple && i < cmd->nwords)
1033                 outfname = cmd->words[i++];
1034             else
1035                 outfname = stripslashes(origfname, 0);
1036
1037             ret = sftp_get_file(fname, outfname, recurse, restart, NULL);
1038
1039             sfree(fname);
1040         }
1041         sfree(unwcfname);
1042         if (!ret)
1043             return ret;
1044
1045     } while (multiple && i < cmd->nwords);
1046
1047     return ret;
1048 }
1049 int sftp_cmd_get(struct sftp_command *cmd)
1050 {
1051     return sftp_general_get(cmd, 0, 0);
1052 }
1053 int sftp_cmd_mget(struct sftp_command *cmd)
1054 {
1055     return sftp_general_get(cmd, 0, 1);
1056 }
1057 int sftp_cmd_reget(struct sftp_command *cmd)
1058 {
1059     return sftp_general_get(cmd, 1, 0);
1060 }
1061
1062 /*
1063  * Send a file and store it at the remote end. We have three very
1064  * similar commands here. The basic one is `put'; `reput' differs
1065  * in that it checks for the existence of the destination file and
1066  * starts from where a previous aborted transfer left off; `mput'
1067  * differs in that it interprets all its arguments as files to
1068  * transfer (never as a different remote name for a local file) and
1069  * can handle wildcards.
1070  */
1071 int sftp_general_put(struct sftp_command *cmd, int restart, int multiple)
1072 {
1073     char *fname, *origoutfname, *outfname;
1074     int i, ret;
1075     int recurse = FALSE;
1076
1077     if (back == NULL) {
1078         printf("psftp: not connected to a host; use \"open host.name\"\n");
1079         return 0;
1080     }
1081
1082     i = 1;
1083     while (i < cmd->nwords && cmd->words[i][0] == '-') {
1084         if (!strcmp(cmd->words[i], "--")) {
1085             /* finish processing options */
1086             i++;
1087             break;
1088         } else if (!strcmp(cmd->words[i], "-r")) {
1089             recurse = TRUE;
1090         } else {
1091             printf("put: unrecognised option '%s'\n", cmd->words[i]);
1092             return 0;
1093         }
1094         i++;
1095     }
1096
1097     if (i >= cmd->nwords) {
1098         printf("put: expects a filename\n");
1099         return 0;
1100     }
1101
1102     do {
1103         fname = cmd->words[i++];
1104
1105         if (multiple && test_wildcard(fname, FALSE) == WCTYPE_WILDCARD) {
1106             ret = sftp_put_file(NULL, pwd, recurse, restart, fname);
1107         } else {
1108             if (!multiple && i < cmd->nwords)
1109                 origoutfname = cmd->words[i++];
1110             else
1111                 origoutfname = stripslashes(fname, 1);
1112
1113             outfname = canonify(origoutfname);
1114             if (!outfname) {
1115                 printf("%s: %s\n", origoutfname, fxp_error());
1116                 return 0;
1117             }
1118             ret = sftp_put_file(fname, outfname, recurse, restart, NULL);
1119             sfree(outfname);
1120         }
1121         if (!ret)
1122             return ret;
1123
1124     } while (multiple && i < cmd->nwords);
1125
1126     return ret;
1127 }
1128 int sftp_cmd_put(struct sftp_command *cmd)
1129 {
1130     return sftp_general_put(cmd, 0, 0);
1131 }
1132 int sftp_cmd_mput(struct sftp_command *cmd)
1133 {
1134     return sftp_general_put(cmd, 0, 1);
1135 }
1136 int sftp_cmd_reput(struct sftp_command *cmd)
1137 {
1138     return sftp_general_put(cmd, 1, 0);
1139 }
1140
1141 int sftp_cmd_mkdir(struct sftp_command *cmd)
1142 {
1143     char *dir;
1144     struct sftp_packet *pktin;
1145     struct sftp_request *req, *rreq;
1146     int result;
1147
1148     if (back == NULL) {
1149         printf("psftp: not connected to a host; use \"open host.name\"\n");
1150         return 0;
1151     }
1152
1153     if (cmd->nwords < 2) {
1154         printf("mkdir: expects a directory\n");
1155         return 0;
1156     }
1157
1158     dir = canonify(cmd->words[1]);
1159     if (!dir) {
1160         printf("%s: %s\n", dir, fxp_error());
1161         return 0;
1162     }
1163
1164     sftp_register(req = fxp_mkdir_send(dir));
1165     rreq = sftp_find_request(pktin = sftp_recv());
1166     assert(rreq == req);
1167     result = fxp_mkdir_recv(pktin, rreq);
1168
1169     if (!result) {
1170         printf("mkdir %s: %s\n", dir, fxp_error());
1171         sfree(dir);
1172         return 0;
1173     }
1174
1175     sfree(dir);
1176     return 1;
1177 }
1178
1179 int sftp_cmd_rmdir(struct sftp_command *cmd)
1180 {
1181     char *dir;
1182     struct sftp_packet *pktin;
1183     struct sftp_request *req, *rreq;
1184     int result;
1185
1186     if (back == NULL) {
1187         printf("psftp: not connected to a host; use \"open host.name\"\n");
1188         return 0;
1189     }
1190
1191     if (cmd->nwords < 2) {
1192         printf("rmdir: expects a directory\n");
1193         return 0;
1194     }
1195
1196     dir = canonify(cmd->words[1]);
1197     if (!dir) {
1198         printf("%s: %s\n", dir, fxp_error());
1199         return 0;
1200     }
1201
1202     sftp_register(req = fxp_rmdir_send(dir));
1203     rreq = sftp_find_request(pktin = sftp_recv());
1204     assert(rreq == req);
1205     result = fxp_rmdir_recv(pktin, rreq);
1206
1207     if (!result) {
1208         printf("rmdir %s: %s\n", dir, fxp_error());
1209         sfree(dir);
1210         return 0;
1211     }
1212
1213     sfree(dir);
1214     return 1;
1215 }
1216
1217 int sftp_cmd_rm(struct sftp_command *cmd)
1218 {
1219     char *fname;
1220     struct sftp_packet *pktin;
1221     struct sftp_request *req, *rreq;
1222     int result;
1223
1224     if (back == NULL) {
1225         printf("psftp: not connected to a host; use \"open host.name\"\n");
1226         return 0;
1227     }
1228
1229     if (cmd->nwords < 2) {
1230         printf("rm: expects a filename\n");
1231         return 0;
1232     }
1233
1234     fname = canonify(cmd->words[1]);
1235     if (!fname) {
1236         printf("%s: %s\n", fname, fxp_error());
1237         return 0;
1238     }
1239
1240     sftp_register(req = fxp_remove_send(fname));
1241     rreq = sftp_find_request(pktin = sftp_recv());
1242     assert(rreq == req);
1243     result = fxp_remove_recv(pktin, rreq);
1244
1245     if (!result) {
1246         printf("rm %s: %s\n", fname, fxp_error());
1247         sfree(fname);
1248         return 0;
1249     }
1250
1251     sfree(fname);
1252     return 1;
1253 }
1254
1255 int sftp_cmd_mv(struct sftp_command *cmd)
1256 {
1257     char *srcfname, *dstfname;
1258     struct sftp_packet *pktin;
1259     struct sftp_request *req, *rreq;
1260     int result;
1261
1262     if (back == NULL) {
1263         printf("psftp: not connected to a host; use \"open host.name\"\n");
1264         return 0;
1265     }
1266
1267     if (cmd->nwords < 3) {
1268         printf("mv: expects two filenames\n");
1269         return 0;
1270     }
1271     srcfname = canonify(cmd->words[1]);
1272     if (!srcfname) {
1273         printf("%s: %s\n", srcfname, fxp_error());
1274         return 0;
1275     }
1276
1277     dstfname = canonify(cmd->words[2]);
1278     if (!dstfname) {
1279         printf("%s: %s\n", dstfname, fxp_error());
1280         return 0;
1281     }
1282
1283     sftp_register(req = fxp_rename_send(srcfname, dstfname));
1284     rreq = sftp_find_request(pktin = sftp_recv());
1285     assert(rreq == req);
1286     result = fxp_rename_recv(pktin, rreq);
1287
1288     if (!result) {
1289         char const *error = fxp_error();
1290         struct fxp_attrs attrs;
1291
1292         /*
1293          * The move might have failed because dstfname pointed at a
1294          * directory. We check this possibility now: if dstfname
1295          * _is_ a directory, we re-attempt the move by appending
1296          * the basename of srcfname to dstfname.
1297          */
1298         sftp_register(req = fxp_stat_send(dstfname));
1299         rreq = sftp_find_request(pktin = sftp_recv());
1300         assert(rreq == req);
1301         result = fxp_stat_recv(pktin, rreq, &attrs);
1302
1303         if (result &&
1304             (attrs.flags & SSH_FILEXFER_ATTR_PERMISSIONS) &&
1305             (attrs.permissions & 0040000)) {
1306             char *p;
1307             char *newname, *newcanon;
1308             printf("(destination %s is a directory)\n", dstfname);
1309             p = srcfname + strlen(srcfname);
1310             while (p > srcfname && p[-1] != '/') p--;
1311             newname = dupcat(dstfname, "/", p, NULL);
1312             newcanon = canonify(newname);
1313             sfree(newname);
1314             if (newcanon) {
1315                 sfree(dstfname);
1316                 dstfname = newcanon;
1317
1318                 sftp_register(req = fxp_rename_send(srcfname, dstfname));
1319                 rreq = sftp_find_request(pktin = sftp_recv());
1320                 assert(rreq == req);
1321                 result = fxp_rename_recv(pktin, rreq);
1322
1323                 error = result ? NULL : fxp_error();
1324             }
1325         }
1326         if (error) {
1327             printf("mv %s %s: %s\n", srcfname, dstfname, error);
1328             sfree(srcfname);
1329             sfree(dstfname);
1330             return 0;
1331         }
1332     }
1333     printf("%s -> %s\n", srcfname, dstfname);
1334
1335     sfree(srcfname);
1336     sfree(dstfname);
1337     return 1;
1338 }
1339
1340 int sftp_cmd_chmod(struct sftp_command *cmd)
1341 {
1342     char *fname, *mode;
1343     int result;
1344     struct fxp_attrs attrs;
1345     unsigned attrs_clr, attrs_xor, oldperms, newperms;
1346     struct sftp_packet *pktin;
1347     struct sftp_request *req, *rreq;
1348
1349     if (back == NULL) {
1350         printf("psftp: not connected to a host; use \"open host.name\"\n");
1351         return 0;
1352     }
1353
1354     if (cmd->nwords < 3) {
1355         printf("chmod: expects a mode specifier and a filename\n");
1356         return 0;
1357     }
1358
1359     /*
1360      * Attempt to parse the mode specifier in cmd->words[1]. We
1361      * don't support the full horror of Unix chmod; instead we
1362      * support a much simpler syntax in which the user can either
1363      * specify an octal number, or a comma-separated sequence of
1364      * [ugoa]*[-+=][rwxst]+. (The initial [ugoa] sequence may
1365      * _only_ be omitted if the only attribute mentioned is t,
1366      * since all others require a user/group/other specification.
1367      * Additionally, the s attribute may not be specified for any
1368      * [ugoa] specifications other than exactly u or exactly g.
1369      */
1370     attrs_clr = attrs_xor = 0;
1371     mode = cmd->words[1];
1372     if (mode[0] >= '0' && mode[0] <= '9') {
1373         if (mode[strspn(mode, "01234567")]) {
1374             printf("chmod: numeric file modes should"
1375                    " contain digits 0-7 only\n");
1376             return 0;
1377         }
1378         attrs_clr = 07777;
1379         sscanf(mode, "%o", &attrs_xor);
1380         attrs_xor &= attrs_clr;
1381     } else {
1382         while (*mode) {
1383             char *modebegin = mode;
1384             unsigned subset, perms;
1385             int action;
1386
1387             subset = 0;
1388             while (*mode && *mode != ',' &&
1389                    *mode != '+' && *mode != '-' && *mode != '=') {
1390                 switch (*mode) {
1391                   case 'u': subset |= 04700; break; /* setuid, user perms */
1392                   case 'g': subset |= 02070; break; /* setgid, group perms */
1393                   case 'o': subset |= 00007; break; /* just other perms */
1394                   case 'a': subset |= 06777; break; /* all of the above */
1395                   default:
1396                     printf("chmod: file mode '%.*s' contains unrecognised"
1397                            " user/group/other specifier '%c'\n",
1398                            (int)strcspn(modebegin, ","), modebegin, *mode);
1399                     return 0;
1400                 }
1401                 mode++;
1402             }
1403             if (!*mode || *mode == ',') {
1404                 printf("chmod: file mode '%.*s' is incomplete\n",
1405                        (int)strcspn(modebegin, ","), modebegin);
1406                 return 0;
1407             }
1408             action = *mode++;
1409             if (!*mode || *mode == ',') {
1410                 printf("chmod: file mode '%.*s' is incomplete\n",
1411                        (int)strcspn(modebegin, ","), modebegin);
1412                 return 0;
1413             }
1414             perms = 0;
1415             while (*mode && *mode != ',') {
1416                 switch (*mode) {
1417                   case 'r': perms |= 00444; break;
1418                   case 'w': perms |= 00222; break;
1419                   case 'x': perms |= 00111; break;
1420                   case 't': perms |= 01000; subset |= 01000; break;
1421                   case 's':
1422                     if ((subset & 06777) != 04700 &&
1423                         (subset & 06777) != 02070) {
1424                         printf("chmod: file mode '%.*s': set[ug]id bit should"
1425                                " be used with exactly one of u or g only\n",
1426                                (int)strcspn(modebegin, ","), modebegin);
1427                         return 0;
1428                     }
1429                     perms |= 06000;
1430                     break;
1431                   default:
1432                     printf("chmod: file mode '%.*s' contains unrecognised"
1433                            " permission specifier '%c'\n",
1434                            (int)strcspn(modebegin, ","), modebegin, *mode);
1435                     return 0;
1436                 }
1437                 mode++;
1438             }
1439             if (!(subset & 06777) && (perms &~ subset)) {
1440                 printf("chmod: file mode '%.*s' contains no user/group/other"
1441                        " specifier and permissions other than 't' \n",
1442                        (int)strcspn(modebegin, ","), modebegin);
1443                 return 0;
1444             }
1445             perms &= subset;
1446             switch (action) {
1447               case '+':
1448                 attrs_clr |= perms;
1449                 attrs_xor |= perms;
1450                 break;
1451               case '-':
1452                 attrs_clr |= perms;
1453                 attrs_xor &= ~perms;
1454                 break;
1455               case '=':
1456                 attrs_clr |= subset;
1457                 attrs_xor |= perms;
1458                 break;
1459             }
1460             if (*mode) mode++;         /* eat comma */
1461         }
1462     }
1463
1464     fname = canonify(cmd->words[2]);
1465     if (!fname) {
1466         printf("%s: %s\n", fname, fxp_error());
1467         return 0;
1468     }
1469
1470     sftp_register(req = fxp_stat_send(fname));
1471     rreq = sftp_find_request(pktin = sftp_recv());
1472     assert(rreq == req);
1473     result = fxp_stat_recv(pktin, rreq, &attrs);
1474
1475     if (!result || !(attrs.flags & SSH_FILEXFER_ATTR_PERMISSIONS)) {
1476         printf("get attrs for %s: %s\n", fname,
1477                result ? "file permissions not provided" : fxp_error());
1478         sfree(fname);
1479         return 0;
1480     }
1481
1482     attrs.flags = SSH_FILEXFER_ATTR_PERMISSIONS;   /* perms _only_ */
1483     oldperms = attrs.permissions & 07777;
1484     attrs.permissions &= ~attrs_clr;
1485     attrs.permissions ^= attrs_xor;
1486     newperms = attrs.permissions & 07777;
1487
1488     sftp_register(req = fxp_setstat_send(fname, attrs));
1489     rreq = sftp_find_request(pktin = sftp_recv());
1490     assert(rreq == req);
1491     result = fxp_setstat_recv(pktin, rreq);
1492
1493     if (!result) {
1494         printf("set attrs for %s: %s\n", fname, fxp_error());
1495         sfree(fname);
1496         return 0;
1497     }
1498
1499     printf("%s: %04o -> %04o\n", fname, oldperms, newperms);
1500
1501     sfree(fname);
1502     return 1;
1503 }
1504
1505 static int sftp_cmd_open(struct sftp_command *cmd)
1506 {
1507     int portnumber;
1508
1509     if (back != NULL) {
1510         printf("psftp: already connected\n");
1511         return 0;
1512     }
1513
1514     if (cmd->nwords < 2) {
1515         printf("open: expects a host name\n");
1516         return 0;
1517     }
1518
1519     if (cmd->nwords > 2) {
1520         portnumber = atoi(cmd->words[2]);
1521         if (portnumber == 0) {
1522             printf("open: invalid port number\n");
1523             return 0;
1524         }
1525     } else
1526         portnumber = 0;
1527
1528     if (psftp_connect(cmd->words[1], NULL, portnumber)) {
1529         back = NULL;                   /* connection is already closed */
1530         return -1;                     /* this is fatal */
1531     }
1532     do_sftp_init();
1533     return 1;
1534 }
1535
1536 static int sftp_cmd_lcd(struct sftp_command *cmd)
1537 {
1538     char *currdir, *errmsg;
1539
1540     if (cmd->nwords < 2) {
1541         printf("lcd: expects a local directory name\n");
1542         return 0;
1543     }
1544
1545     errmsg = psftp_lcd(cmd->words[1]);
1546     if (errmsg) {
1547         printf("lcd: unable to change directory: %s\n", errmsg);
1548         sfree(errmsg);
1549         return 0;
1550     }
1551
1552     currdir = psftp_getcwd();
1553     printf("New local directory is %s\n", currdir);
1554     sfree(currdir);
1555
1556     return 1;
1557 }
1558
1559 static int sftp_cmd_lpwd(struct sftp_command *cmd)
1560 {
1561     char *currdir;
1562
1563     currdir = psftp_getcwd();
1564     printf("Current local directory is %s\n", currdir);
1565     sfree(currdir);
1566
1567     return 1;
1568 }
1569
1570 static int sftp_cmd_pling(struct sftp_command *cmd)
1571 {
1572     int exitcode;
1573
1574     exitcode = system(cmd->words[1]);
1575     return (exitcode == 0);
1576 }
1577
1578 static int sftp_cmd_help(struct sftp_command *cmd);
1579
1580 static struct sftp_cmd_lookup {
1581     char *name;
1582     /*
1583      * For help purposes, there are two kinds of command:
1584      * 
1585      *  - primary commands, in which `longhelp' is non-NULL. In
1586      *    this case `shorthelp' is descriptive text, and `longhelp'
1587      *    is longer descriptive text intended to be printed after
1588      *    the command name.
1589      * 
1590      *  - alias commands, in which `longhelp' is NULL. In this case
1591      *    `shorthelp' is the name of a primary command, which
1592      *    contains the help that should double up for this command.
1593      */
1594     int listed;                        /* do we list this in primary help? */
1595     char *shorthelp;
1596     char *longhelp;
1597     int (*obey) (struct sftp_command *);
1598 } sftp_lookup[] = {
1599     /*
1600      * List of sftp commands. This is binary-searched so it MUST be
1601      * in ASCII order.
1602      */
1603     {
1604         "!", TRUE, "run a local command",
1605             "<command>\n"
1606             /* FIXME: this example is crap for non-Windows. */
1607             "  Runs a local command. For example, \"!del myfile\".\n",
1608             sftp_cmd_pling
1609     },
1610     {
1611         "bye", TRUE, "finish your SFTP session",
1612             "\n"
1613             "  Terminates your SFTP session and quits the PSFTP program.\n",
1614             sftp_cmd_quit
1615     },
1616     {
1617         "cd", TRUE, "change your remote working directory",
1618             " [ <New working directory> ]\n"
1619             "  Change the remote working directory for your SFTP session.\n"
1620             "  If a new working directory is not supplied, you will be\n"
1621             "  returned to your home directory.\n",
1622             sftp_cmd_cd
1623     },
1624     {
1625         "chmod", TRUE, "change file permissions and modes",
1626             " ( <octal-digits> | <modifiers> ) <filename>\n"
1627             "  Change the file permissions on a file or directory.\n"
1628             "  <octal-digits> can be any octal Unix permission specifier.\n"
1629             "  Alternatively, <modifiers> can include:\n"
1630             "    u+r     make file readable by owning user\n"
1631             "    u+w     make file writable by owning user\n"
1632             "    u+x     make file executable by owning user\n"
1633             "    u-r     make file not readable by owning user\n"
1634             "    [also u-w, u-x]\n"
1635             "    g+r     make file readable by members of owning group\n"
1636             "    [also g+w, g+x, g-r, g-w, g-x]\n"
1637             "    o+r     make file readable by all other users\n"
1638             "    [also o+w, o+x, o-r, o-w, o-x]\n"
1639             "    a+r     make file readable by absolutely everybody\n"
1640             "    [also a+w, a+x, a-r, a-w, a-x]\n"
1641             "    u+s     enable the Unix set-user-ID bit\n"
1642             "    u-s     disable the Unix set-user-ID bit\n"
1643             "    g+s     enable the Unix set-group-ID bit\n"
1644             "    g-s     disable the Unix set-group-ID bit\n"
1645             "    +t      enable the Unix \"sticky bit\"\n"
1646             "  You can give more than one modifier for the same user (\"g-rwx\"), and\n"
1647             "  more than one user for the same modifier (\"ug+w\"). You can\n"
1648             "  use commas to separate different modifiers (\"u+rwx,g+s\").\n",
1649             sftp_cmd_chmod
1650     },
1651     {
1652         "close", TRUE, "finish your SFTP session but do not quit PSFTP",
1653             "\n"
1654             "  Terminates your SFTP session, but does not quit the PSFTP\n"
1655             "  program. You can then use \"open\" to start another SFTP\n"
1656             "  session, to the same server or to a different one.\n",
1657             sftp_cmd_close
1658     },
1659     {
1660         "del", TRUE, "delete a file",
1661             " <filename>\n"
1662             "  Delete a file.\n",
1663             sftp_cmd_rm
1664     },
1665     {
1666         "delete", FALSE, "del", NULL, sftp_cmd_rm
1667     },
1668     {
1669         "dir", TRUE, "list contents of a remote directory",
1670             " [ <directory-name> ]\n"
1671             "  List the contents of a specified directory on the server.\n"
1672             "  If <directory-name> is not given, the current working directory\n"
1673             "  will be listed.\n",
1674             sftp_cmd_ls
1675     },
1676     {
1677         "exit", TRUE, "bye", NULL, sftp_cmd_quit
1678     },
1679     {
1680         "get", TRUE, "download a file from the server to your local machine",
1681             " <filename> [ <local-filename> ]\n"
1682             "  Downloads a file on the server and stores it locally under\n"
1683             "  the same name, or under a different one if you supply the\n"
1684             "  argument <local-filename>.\n",
1685             sftp_cmd_get
1686     },
1687     {
1688         "help", TRUE, "give help",
1689             " [ <command> [ <command> ... ] ]\n"
1690             "  Give general help if no commands are specified.\n"
1691             "  If one or more commands are specified, give specific help on\n"
1692             "  those particular commands.\n",
1693             sftp_cmd_help
1694     },
1695     {
1696         "lcd", TRUE, "change local working directory",
1697             " <local-directory-name>\n"
1698             "  Change the local working directory of the PSFTP program (the\n"
1699             "  default location where the \"get\" command will save files).\n",
1700             sftp_cmd_lcd
1701     },
1702     {
1703         "lpwd", TRUE, "print local working directory",
1704             "\n"
1705             "  Print the local working directory of the PSFTP program (the\n"
1706             "  default location where the \"get\" command will save files).\n",
1707             sftp_cmd_lpwd
1708     },
1709     {
1710         "ls", TRUE, "dir", NULL,
1711             sftp_cmd_ls
1712     },
1713     {
1714         "mget", TRUE, "download multiple files at once",
1715             " <filename-or-wildcard> [ <filename-or-wildcard>... ]\n"
1716             "  Downloads many files from the server, storing each one under\n"
1717             "  the same name it has on the server side. You can use wildcards\n"
1718             "  such as \"*.c\" to specify lots of files at once.\n",
1719             sftp_cmd_mget
1720     },
1721     {
1722         "mkdir", TRUE, "create a directory on the remote server",
1723             " <directory-name>\n"
1724             "  Creates a directory with the given name on the server.\n",
1725             sftp_cmd_mkdir
1726     },
1727     {
1728         "mput", TRUE, "upload multiple files at once",
1729             " <filename-or-wildcard> [ <filename-or-wildcard>... ]\n"
1730             "  Uploads many files to the server, storing each one under the\n"
1731             "  same name it has on the client side. You can use wildcards\n"
1732             "  such as \"*.c\" to specify lots of files at once.\n",
1733             sftp_cmd_mput
1734     },
1735     {
1736         "mv", TRUE, "move or rename a file on the remote server",
1737             " <source-filename> <destination-filename>\n"
1738             "  Moves or renames the file <source-filename> on the server,\n"
1739             "  so that it is accessible under the name <destination-filename>.\n",
1740             sftp_cmd_mv
1741     },
1742     {
1743         "open", TRUE, "connect to a host",
1744             " [<user>@]<hostname> [<port>]\n"
1745             "  Establishes an SFTP connection to a given host. Only usable\n"
1746             "  when you did not already specify a host name on the command\n"
1747             "  line.\n",
1748             sftp_cmd_open
1749     },
1750     {
1751         "put", TRUE, "upload a file from your local machine to the server",
1752             " <filename> [ <remote-filename> ]\n"
1753             "  Uploads a file to the server and stores it there under\n"
1754             "  the same name, or under a different one if you supply the\n"
1755             "  argument <remote-filename>.\n",
1756             sftp_cmd_put
1757     },
1758     {
1759         "pwd", TRUE, "print your remote working directory",
1760             "\n"
1761             "  Print the current remote working directory for your SFTP session.\n",
1762             sftp_cmd_pwd
1763     },
1764     {
1765         "quit", TRUE, "bye", NULL,
1766             sftp_cmd_quit
1767     },
1768     {
1769         "reget", TRUE, "continue downloading a file",
1770             " <filename> [ <local-filename> ]\n"
1771             "  Works exactly like the \"get\" command, but the local file\n"
1772             "  must already exist. The download will begin at the end of the\n"
1773             "  file. This is for resuming a download that was interrupted.\n",
1774             sftp_cmd_reget
1775     },
1776     {
1777         "ren", TRUE, "mv", NULL,
1778             sftp_cmd_mv
1779     },
1780     {
1781         "rename", FALSE, "mv", NULL,
1782             sftp_cmd_mv
1783     },
1784     {
1785         "reput", TRUE, "continue uploading a file",
1786             " <filename> [ <remote-filename> ]\n"
1787             "  Works exactly like the \"put\" command, but the remote file\n"
1788             "  must already exist. The upload will begin at the end of the\n"
1789             "  file. This is for resuming an upload that was interrupted.\n",
1790             sftp_cmd_reput
1791     },
1792     {
1793         "rm", TRUE, "del", NULL,
1794             sftp_cmd_rm
1795     },
1796     {
1797         "rmdir", TRUE, "remove a directory on the remote server",
1798             " <directory-name>\n"
1799             "  Removes the directory with the given name on the server.\n"
1800             "  The directory will not be removed unless it is empty.\n",
1801             sftp_cmd_rmdir
1802     }
1803 };
1804
1805 const struct sftp_cmd_lookup *lookup_command(char *name)
1806 {
1807     int i, j, k, cmp;
1808
1809     i = -1;
1810     j = sizeof(sftp_lookup) / sizeof(*sftp_lookup);
1811     while (j - i > 1) {
1812         k = (j + i) / 2;
1813         cmp = strcmp(name, sftp_lookup[k].name);
1814         if (cmp < 0)
1815             j = k;
1816         else if (cmp > 0)
1817             i = k;
1818         else {
1819             return &sftp_lookup[k];
1820         }
1821     }
1822     return NULL;
1823 }
1824
1825 static int sftp_cmd_help(struct sftp_command *cmd)
1826 {
1827     int i;
1828     if (cmd->nwords == 1) {
1829         /*
1830          * Give short help on each command.
1831          */
1832         int maxlen;
1833         maxlen = 0;
1834         for (i = 0; i < sizeof(sftp_lookup) / sizeof(*sftp_lookup); i++) {
1835             int len;
1836             if (!sftp_lookup[i].listed)
1837                 continue;
1838             len = strlen(sftp_lookup[i].name);
1839             if (maxlen < len)
1840                 maxlen = len;
1841         }
1842         for (i = 0; i < sizeof(sftp_lookup) / sizeof(*sftp_lookup); i++) {
1843             const struct sftp_cmd_lookup *lookup;
1844             if (!sftp_lookup[i].listed)
1845                 continue;
1846             lookup = &sftp_lookup[i];
1847             printf("%-*s", maxlen+2, lookup->name);
1848             if (lookup->longhelp == NULL)
1849                 lookup = lookup_command(lookup->shorthelp);
1850             printf("%s\n", lookup->shorthelp);
1851         }
1852     } else {
1853         /*
1854          * Give long help on specific commands.
1855          */
1856         for (i = 1; i < cmd->nwords; i++) {
1857             const struct sftp_cmd_lookup *lookup;
1858             lookup = lookup_command(cmd->words[i]);
1859             if (!lookup) {
1860                 printf("help: %s: command not found\n", cmd->words[i]);
1861             } else {
1862                 printf("%s", lookup->name);
1863                 if (lookup->longhelp == NULL)
1864                     lookup = lookup_command(lookup->shorthelp);
1865                 printf("%s", lookup->longhelp);
1866             }
1867         }
1868     }
1869     return 1;
1870 }
1871
1872 /* ----------------------------------------------------------------------
1873  * Command line reading and parsing.
1874  */
1875 struct sftp_command *sftp_getcmd(FILE *fp, int mode, int modeflags)
1876 {
1877     char *line;
1878     struct sftp_command *cmd;
1879     char *p, *q, *r;
1880     int quoting;
1881
1882     cmd = snew(struct sftp_command);
1883     cmd->words = NULL;
1884     cmd->nwords = 0;
1885     cmd->wordssize = 0;
1886
1887     line = NULL;
1888
1889     if (fp) {
1890         if (modeflags & 1)
1891             printf("psftp> ");
1892         line = fgetline(fp);
1893     } else {
1894         line = ssh_sftp_get_cmdline("psftp> ", back == NULL);
1895     }
1896
1897     if (!line || !*line) {
1898         cmd->obey = sftp_cmd_quit;
1899         if ((mode == 0) || (modeflags & 1))
1900             printf("quit\n");
1901         return cmd;                    /* eof */
1902     }
1903
1904     line[strcspn(line, "\r\n")] = '\0';
1905
1906     if (modeflags & 1) {
1907         printf("%s\n", line);
1908     }
1909
1910     p = line;
1911     while (*p && (*p == ' ' || *p == '\t'))
1912         p++;
1913
1914     if (*p == '!') {
1915         /*
1916          * Special case: the ! command. This is always parsed as
1917          * exactly two words: one containing the !, and the second
1918          * containing everything else on the line.
1919          */
1920         cmd->nwords = cmd->wordssize = 2;
1921         cmd->words = sresize(cmd->words, cmd->wordssize, char *);
1922         cmd->words[0] = dupstr("!");
1923         cmd->words[1] = dupstr(p+1);
1924     } else {
1925
1926         /*
1927          * Parse the command line into words. The syntax is:
1928          *  - double quotes are removed, but cause spaces within to be
1929          *    treated as non-separating.
1930          *  - a double-doublequote pair is a literal double quote, inside
1931          *    _or_ outside quotes. Like this:
1932          *
1933          *      firstword "second word" "this has ""quotes"" in" and""this""
1934          *
1935          * becomes
1936          *
1937          *      >firstword<
1938          *      >second word<
1939          *      >this has "quotes" in<
1940          *      >and"this"<
1941          */
1942         while (*p) {
1943             /* skip whitespace */
1944             while (*p && (*p == ' ' || *p == '\t'))
1945                 p++;
1946             /* mark start of word */
1947             q = r = p;                 /* q sits at start, r writes word */
1948             quoting = 0;
1949             while (*p) {
1950                 if (!quoting && (*p == ' ' || *p == '\t'))
1951                     break;                     /* reached end of word */
1952                 else if (*p == '"' && p[1] == '"')
1953                     p += 2, *r++ = '"';    /* a literal quote */
1954                 else if (*p == '"')
1955                     p++, quoting = !quoting;
1956                 else
1957                     *r++ = *p++;
1958             }
1959             if (*p)
1960                 p++;                   /* skip over the whitespace */
1961             *r = '\0';
1962             if (cmd->nwords >= cmd->wordssize) {
1963                 cmd->wordssize = cmd->nwords + 16;
1964                 cmd->words = sresize(cmd->words, cmd->wordssize, char *);
1965             }
1966             cmd->words[cmd->nwords++] = dupstr(q);
1967         }
1968     }
1969
1970     sfree(line);
1971
1972     /*
1973      * Now parse the first word and assign a function.
1974      */
1975
1976     if (cmd->nwords == 0)
1977         cmd->obey = sftp_cmd_null;
1978     else {
1979         const struct sftp_cmd_lookup *lookup;
1980         lookup = lookup_command(cmd->words[0]);
1981         if (!lookup)
1982             cmd->obey = sftp_cmd_unknown;
1983         else
1984             cmd->obey = lookup->obey;
1985     }
1986
1987     return cmd;
1988 }
1989
1990 static int do_sftp_init(void)
1991 {
1992     struct sftp_packet *pktin;
1993     struct sftp_request *req, *rreq;
1994
1995     /*
1996      * Do protocol initialisation. 
1997      */
1998     if (!fxp_init()) {
1999         fprintf(stderr,
2000                 "Fatal: unable to initialise SFTP: %s\n", fxp_error());
2001         return 1;                      /* failure */
2002     }
2003
2004     /*
2005      * Find out where our home directory is.
2006      */
2007     sftp_register(req = fxp_realpath_send("."));
2008     rreq = sftp_find_request(pktin = sftp_recv());
2009     assert(rreq == req);
2010     homedir = fxp_realpath_recv(pktin, rreq);
2011
2012     if (!homedir) {
2013         fprintf(stderr,
2014                 "Warning: failed to resolve home directory: %s\n",
2015                 fxp_error());
2016         homedir = dupstr(".");
2017     } else {
2018         printf("Remote working directory is %s\n", homedir);
2019     }
2020     pwd = dupstr(homedir);
2021     return 0;
2022 }
2023
2024 void do_sftp_cleanup()
2025 {
2026     char ch;
2027     if (back) {
2028         back->special(backhandle, TS_EOF);
2029         sftp_recvdata(&ch, 1);
2030         back->free(backhandle);
2031         sftp_cleanup_request();
2032         back = NULL;
2033         backhandle = NULL;
2034     }
2035     if (pwd) {
2036         sfree(pwd);
2037         pwd = NULL;
2038     }
2039     if (homedir) {
2040         sfree(homedir);
2041         homedir = NULL;
2042     }
2043 }
2044
2045 void do_sftp(int mode, int modeflags, char *batchfile)
2046 {
2047     FILE *fp;
2048     int ret;
2049
2050     /*
2051      * Batch mode?
2052      */
2053     if (mode == 0) {
2054
2055         /* ------------------------------------------------------------------
2056          * Now we're ready to do Real Stuff.
2057          */
2058         while (1) {
2059             struct sftp_command *cmd;
2060             cmd = sftp_getcmd(NULL, 0, 0);
2061             if (!cmd)
2062                 break;
2063             ret = cmd->obey(cmd);
2064             if (cmd->words) {
2065                 int i;
2066                 for(i = 0; i < cmd->nwords; i++)
2067                     sfree(cmd->words[i]);
2068                 sfree(cmd->words);
2069             }
2070             sfree(cmd);
2071             if (ret < 0)
2072                 break;
2073         }
2074     } else {
2075         fp = fopen(batchfile, "r");
2076         if (!fp) {
2077             printf("Fatal: unable to open %s\n", batchfile);
2078             return;
2079         }
2080         while (1) {
2081             struct sftp_command *cmd;
2082             cmd = sftp_getcmd(fp, mode, modeflags);
2083             if (!cmd)
2084                 break;
2085             ret = cmd->obey(cmd);
2086             if (ret < 0)
2087                 break;
2088             if (ret == 0) {
2089                 if (!(modeflags & 2))
2090                     break;
2091             }
2092         }
2093         fclose(fp);
2094
2095     }
2096 }
2097
2098 /* ----------------------------------------------------------------------
2099  * Dirty bits: integration with PuTTY.
2100  */
2101
2102 static int verbose = 0;
2103
2104 /*
2105  *  Print an error message and perform a fatal exit.
2106  */
2107 void fatalbox(char *fmt, ...)
2108 {
2109     char *str, *str2;
2110     va_list ap;
2111     va_start(ap, fmt);
2112     str = dupvprintf(fmt, ap);
2113     str2 = dupcat("Fatal: ", str, "\n", NULL);
2114     sfree(str);
2115     va_end(ap);
2116     fputs(str2, stderr);
2117     sfree(str2);
2118
2119     cleanup_exit(1);
2120 }
2121 void modalfatalbox(char *fmt, ...)
2122 {
2123     char *str, *str2;
2124     va_list ap;
2125     va_start(ap, fmt);
2126     str = dupvprintf(fmt, ap);
2127     str2 = dupcat("Fatal: ", str, "\n", NULL);
2128     sfree(str);
2129     va_end(ap);
2130     fputs(str2, stderr);
2131     sfree(str2);
2132
2133     cleanup_exit(1);
2134 }
2135 void connection_fatal(void *frontend, char *fmt, ...)
2136 {
2137     char *str, *str2;
2138     va_list ap;
2139     va_start(ap, fmt);
2140     str = dupvprintf(fmt, ap);
2141     str2 = dupcat("Fatal: ", str, "\n", NULL);
2142     sfree(str);
2143     va_end(ap);
2144     fputs(str2, stderr);
2145     sfree(str2);
2146
2147     cleanup_exit(1);
2148 }
2149
2150 void ldisc_send(void *handle, char *buf, int len, int interactive)
2151 {
2152     /*
2153      * This is only here because of the calls to ldisc_send(NULL,
2154      * 0) in ssh.c. Nothing in PSFTP actually needs to use the
2155      * ldisc as an ldisc. So if we get called with any real data, I
2156      * want to know about it.
2157      */
2158     assert(len == 0);
2159 }
2160
2161 /*
2162  * In psftp, all agent requests should be synchronous, so this is a
2163  * never-called stub.
2164  */
2165 void agent_schedule_callback(void (*callback)(void *, void *, int),
2166                              void *callback_ctx, void *data, int len)
2167 {
2168     assert(!"We shouldn't be here");
2169 }
2170
2171 /*
2172  * Receive a block of data from the SSH link. Block until all data
2173  * is available.
2174  *
2175  * To do this, we repeatedly call the SSH protocol module, with our
2176  * own trap in from_backend() to catch the data that comes back. We
2177  * do this until we have enough data.
2178  */
2179
2180 static unsigned char *outptr;          /* where to put the data */
2181 static unsigned outlen;                /* how much data required */
2182 static unsigned char *pending = NULL;  /* any spare data */
2183 static unsigned pendlen = 0, pendsize = 0;      /* length and phys. size of buffer */
2184 int from_backend(void *frontend, int is_stderr, const char *data, int datalen)
2185 {
2186     unsigned char *p = (unsigned char *) data;
2187     unsigned len = (unsigned) datalen;
2188
2189     /*
2190      * stderr data is just spouted to local stderr and otherwise
2191      * ignored.
2192      */
2193     if (is_stderr) {
2194         if (len > 0)
2195             fwrite(data, 1, len, stderr);
2196         return 0;
2197     }
2198
2199     /*
2200      * If this is before the real session begins, just return.
2201      */
2202     if (!outptr)
2203         return 0;
2204
2205     if ((outlen > 0) && (len > 0)) {
2206         unsigned used = outlen;
2207         if (used > len)
2208             used = len;
2209         memcpy(outptr, p, used);
2210         outptr += used;
2211         outlen -= used;
2212         p += used;
2213         len -= used;
2214     }
2215
2216     if (len > 0) {
2217         if (pendsize < pendlen + len) {
2218             pendsize = pendlen + len + 4096;
2219             pending = sresize(pending, pendsize, unsigned char);
2220         }
2221         memcpy(pending + pendlen, p, len);
2222         pendlen += len;
2223     }
2224
2225     return 0;
2226 }
2227 int sftp_recvdata(char *buf, int len)
2228 {
2229     outptr = (unsigned char *) buf;
2230     outlen = len;
2231
2232     /*
2233      * See if the pending-input block contains some of what we
2234      * need.
2235      */
2236     if (pendlen > 0) {
2237         unsigned pendused = pendlen;
2238         if (pendused > outlen)
2239             pendused = outlen;
2240         memcpy(outptr, pending, pendused);
2241         memmove(pending, pending + pendused, pendlen - pendused);
2242         outptr += pendused;
2243         outlen -= pendused;
2244         pendlen -= pendused;
2245         if (pendlen == 0) {
2246             pendsize = 0;
2247             sfree(pending);
2248             pending = NULL;
2249         }
2250         if (outlen == 0)
2251             return 1;
2252     }
2253
2254     while (outlen > 0) {
2255         if (ssh_sftp_loop_iteration() < 0)
2256             return 0;                  /* doom */
2257     }
2258
2259     return 1;
2260 }
2261 int sftp_senddata(char *buf, int len)
2262 {
2263     back->send(backhandle, buf, len);
2264     return 1;
2265 }
2266
2267 /*
2268  *  Short description of parameters.
2269  */
2270 static void usage(void)
2271 {
2272     printf("PuTTY Secure File Transfer (SFTP) client\n");
2273     printf("%s\n", ver);
2274     printf("Usage: psftp [options] [user@]host\n");
2275     printf("Options:\n");
2276     printf("  -b file   use specified batchfile\n");
2277     printf("  -bc       output batchfile commands\n");
2278     printf("  -be       don't stop batchfile processing if errors\n");
2279     printf("  -v        show verbose messages\n");
2280     printf("  -load sessname  Load settings from saved session\n");
2281     printf("  -l user   connect with specified username\n");
2282     printf("  -P port   connect to specified port\n");
2283     printf("  -pw passw login with specified password\n");
2284     printf("  -1 -2     force use of particular SSH protocol version\n");
2285     printf("  -C        enable compression\n");
2286     printf("  -i key    private key file for authentication\n");
2287     printf("  -batch    disable all interactive prompts\n");
2288     printf("  -V        print version information\n");
2289     cleanup_exit(1);
2290 }
2291
2292 static void version(void)
2293 {
2294   printf("psftp: %s\n", ver);
2295   cleanup_exit(1);
2296 }
2297
2298 /*
2299  * Connect to a host.
2300  */
2301 static int psftp_connect(char *userhost, char *user, int portnumber)
2302 {
2303     char *host, *realhost;
2304     const char *err;
2305     void *logctx;
2306
2307     /* Separate host and username */
2308     host = userhost;
2309     host = strrchr(host, '@');
2310     if (host == NULL) {
2311         host = userhost;
2312     } else {
2313         *host++ = '\0';
2314         if (user) {
2315             printf("psftp: multiple usernames specified; using \"%s\"\n",
2316                    user);
2317         } else
2318             user = userhost;
2319     }
2320
2321     /*
2322      * If we haven't loaded session details already (e.g., from -load),
2323      * try looking for a session called "host".
2324      */
2325     if (!loaded_session) {
2326         /* Try to load settings for `host' into a temporary config */
2327         Config cfg2;
2328         cfg2.host[0] = '\0';
2329         do_defaults(host, &cfg2);
2330         if (cfg2.host[0] != '\0') {
2331             /* Settings present and include hostname */
2332             /* Re-load data into the real config. */
2333             do_defaults(host, &cfg);
2334         } else {
2335             /* Session doesn't exist or mention a hostname. */
2336             /* Use `host' as a bare hostname. */
2337             strncpy(cfg.host, host, sizeof(cfg.host) - 1);
2338             cfg.host[sizeof(cfg.host) - 1] = '\0';
2339         }
2340     } else {
2341         /* Patch in hostname `host' to session details. */
2342         strncpy(cfg.host, host, sizeof(cfg.host) - 1);
2343         cfg.host[sizeof(cfg.host) - 1] = '\0';
2344     }
2345
2346     /*
2347      * Force use of SSH. (If they got the protocol wrong we assume the
2348      * port is useless too.)
2349      */
2350     if (cfg.protocol != PROT_SSH) {
2351         cfg.protocol = PROT_SSH;
2352         cfg.port = 22;
2353     }
2354
2355     /*
2356      * If saved session / Default Settings says SSH-1 (`1 only' or `1'),
2357      * then change it to SSH-2, on the grounds that that's more likely to
2358      * work for SFTP. (Can be overridden with `-1' option.)
2359      * But if it says `2 only' or `2', respect which.
2360      */
2361     if (cfg.sshprot != 2 && cfg.sshprot != 3)
2362         cfg.sshprot = 2;
2363
2364     /*
2365      * Enact command-line overrides.
2366      */
2367     cmdline_run_saved(&cfg);
2368
2369     /*
2370      * Trim leading whitespace off the hostname if it's there.
2371      */
2372     {
2373         int space = strspn(cfg.host, " \t");
2374         memmove(cfg.host, cfg.host+space, 1+strlen(cfg.host)-space);
2375     }
2376
2377     /* See if host is of the form user@host */
2378     if (cfg.host[0] != '\0') {
2379         char *atsign = strrchr(cfg.host, '@');
2380         /* Make sure we're not overflowing the user field */
2381         if (atsign) {
2382             if (atsign - cfg.host < sizeof cfg.username) {
2383                 strncpy(cfg.username, cfg.host, atsign - cfg.host);
2384                 cfg.username[atsign - cfg.host] = '\0';
2385             }
2386             memmove(cfg.host, atsign + 1, 1 + strlen(atsign + 1));
2387         }
2388     }
2389
2390     /*
2391      * Trim a colon suffix off the hostname if it's there.
2392      */
2393     cfg.host[strcspn(cfg.host, ":")] = '\0';
2394
2395     /*
2396      * Remove any remaining whitespace from the hostname.
2397      */
2398     {
2399         int p1 = 0, p2 = 0;
2400         while (cfg.host[p2] != '\0') {
2401             if (cfg.host[p2] != ' ' && cfg.host[p2] != '\t') {
2402                 cfg.host[p1] = cfg.host[p2];
2403                 p1++;
2404             }
2405             p2++;
2406         }
2407         cfg.host[p1] = '\0';
2408     }
2409
2410     /* Set username */
2411     if (user != NULL && user[0] != '\0') {
2412         strncpy(cfg.username, user, sizeof(cfg.username) - 1);
2413         cfg.username[sizeof(cfg.username) - 1] = '\0';
2414     }
2415     if (!cfg.username[0]) {
2416         if (!console_get_line("login as: ",
2417                               cfg.username, sizeof(cfg.username), FALSE)) {
2418             fprintf(stderr, "psftp: no username, aborting\n");
2419             cleanup_exit(1);
2420         } else {
2421             int len = strlen(cfg.username);
2422             if (cfg.username[len - 1] == '\n')
2423                 cfg.username[len - 1] = '\0';
2424         }
2425     }
2426
2427     if (portnumber)
2428         cfg.port = portnumber;
2429
2430     /*
2431      * Disable scary things which shouldn't be enabled for simple
2432      * things like SCP and SFTP: agent forwarding, port forwarding,
2433      * X forwarding.
2434      */
2435     cfg.x11_forward = 0;
2436     cfg.agentfwd = 0;
2437     cfg.portfwd[0] = cfg.portfwd[1] = '\0';
2438
2439     /* Set up subsystem name. */
2440     strcpy(cfg.remote_cmd, "sftp");
2441     cfg.ssh_subsys = TRUE;
2442     cfg.nopty = TRUE;
2443
2444     /*
2445      * Set up fallback option, for SSH1 servers or servers with the
2446      * sftp subsystem not enabled but the server binary installed
2447      * in the usual place. We only support fallback on Unix
2448      * systems, and we use a kludgy piece of shellery which should
2449      * try to find sftp-server in various places (the obvious
2450      * systemwide spots /usr/lib and /usr/local/lib, and then the
2451      * user's PATH) and finally give up.
2452      * 
2453      *   test -x /usr/lib/sftp-server && exec /usr/lib/sftp-server
2454      *   test -x /usr/local/lib/sftp-server && exec /usr/local/lib/sftp-server
2455      *   exec sftp-server
2456      * 
2457      * the idea being that this will attempt to use either of the
2458      * obvious pathnames and then give up, and when it does give up
2459      * it will print the preferred pathname in the error messages.
2460      */
2461     cfg.remote_cmd_ptr2 =
2462         "test -x /usr/lib/sftp-server && exec /usr/lib/sftp-server\n"
2463         "test -x /usr/local/lib/sftp-server && exec /usr/local/lib/sftp-server\n"
2464         "exec sftp-server";
2465     cfg.ssh_subsys2 = FALSE;
2466
2467     back = &ssh_backend;
2468
2469     err = back->init(NULL, &backhandle, &cfg, cfg.host, cfg.port, &realhost,
2470                      0, cfg.tcp_keepalives);
2471     if (err != NULL) {
2472         fprintf(stderr, "ssh_init: %s\n", err);
2473         return 1;
2474     }
2475     logctx = log_init(NULL, &cfg);
2476     back->provide_logctx(backhandle, logctx);
2477     console_provide_logctx(logctx);
2478     while (!back->sendok(backhandle)) {
2479         if (ssh_sftp_loop_iteration() < 0) {
2480             fprintf(stderr, "ssh_init: error during SSH connection setup\n");
2481             return 1;
2482         }
2483     }
2484     if (verbose && realhost != NULL)
2485         printf("Connected to %s\n", realhost);
2486     if (realhost != NULL)
2487         sfree(realhost);
2488     return 0;
2489 }
2490
2491 void cmdline_error(char *p, ...)
2492 {
2493     va_list ap;
2494     fprintf(stderr, "psftp: ");
2495     va_start(ap, p);
2496     vfprintf(stderr, p, ap);
2497     va_end(ap);
2498     fprintf(stderr, "\n       try typing \"psftp -h\" for help\n");
2499     exit(1);
2500 }
2501
2502 /*
2503  * Main program. Parse arguments etc.
2504  */
2505 int psftp_main(int argc, char *argv[])
2506 {
2507     int i;
2508     int portnumber = 0;
2509     char *userhost, *user;
2510     int mode = 0;
2511     int modeflags = 0;
2512     char *batchfile = NULL;
2513     int errors = 0;
2514
2515     flags = FLAG_STDERR | FLAG_INTERACTIVE
2516 #ifdef FLAG_SYNCAGENT
2517         | FLAG_SYNCAGENT
2518 #endif
2519         ;
2520     cmdline_tooltype = TOOLTYPE_FILETRANSFER;
2521     ssh_get_line = &console_get_line;
2522     sk_init();
2523
2524     userhost = user = NULL;
2525
2526     /* Load Default Settings before doing anything else. */
2527     do_defaults(NULL, &cfg);
2528     loaded_session = FALSE;
2529
2530     errors = 0;
2531     for (i = 1; i < argc; i++) {
2532         int ret;
2533         if (argv[i][0] != '-') {
2534             if (userhost)
2535                 usage();
2536             else
2537                 userhost = dupstr(argv[i]);
2538             continue;
2539         }
2540         ret = cmdline_process_param(argv[i], i+1<argc?argv[i+1]:NULL, 1, &cfg);
2541         if (ret == -2) {
2542             cmdline_error("option \"%s\" requires an argument", argv[i]);
2543         } else if (ret == 2) {
2544             i++;               /* skip next argument */
2545         } else if (ret == 1) {
2546             /* We have our own verbosity in addition to `flags'. */
2547             if (flags & FLAG_VERBOSE)
2548                 verbose = 1;
2549         } else if (strcmp(argv[i], "-h") == 0 ||
2550                    strcmp(argv[i], "-?") == 0) {
2551             usage();
2552         } else if (strcmp(argv[i], "-V") == 0) {
2553             version();
2554         } else if (strcmp(argv[i], "-batch") == 0) {
2555             console_batch_mode = 1;
2556         } else if (strcmp(argv[i], "-b") == 0 && i + 1 < argc) {
2557             mode = 1;
2558             batchfile = argv[++i];
2559         } else if (strcmp(argv[i], "-bc") == 0) {
2560             modeflags = modeflags | 1;
2561         } else if (strcmp(argv[i], "-be") == 0) {
2562             modeflags = modeflags | 2;
2563         } else if (strcmp(argv[i], "--") == 0) {
2564             i++;
2565             break;
2566         } else {
2567             cmdline_error("unknown option \"%s\"", argv[i]);
2568         }
2569     }
2570     argc -= i;
2571     argv += i;
2572     back = NULL;
2573
2574     /*
2575      * If the loaded session provides a hostname, and a hostname has not
2576      * otherwise been specified, pop it in `userhost' so that
2577      * `psftp -load sessname' is sufficient to start a session.
2578      */
2579     if (!userhost && cfg.host[0] != '\0') {
2580         userhost = dupstr(cfg.host);
2581     }
2582
2583     /*
2584      * If a user@host string has already been provided, connect to
2585      * it now.
2586      */
2587     if (userhost) {
2588         int ret;
2589         ret = psftp_connect(userhost, user, portnumber);
2590         sfree(userhost);
2591         if (ret)
2592             return 1;
2593         if (do_sftp_init())
2594             return 1;
2595     } else {
2596         printf("psftp: no hostname specified; use \"open host.name\""
2597                " to connect\n");
2598     }
2599
2600     do_sftp(mode, modeflags, batchfile);
2601
2602     if (back != NULL && back->socket(backhandle) != NULL) {
2603         char ch;
2604         back->special(backhandle, TS_EOF);
2605         sftp_recvdata(&ch, 1);
2606     }
2607     do_sftp_cleanup();
2608     random_save_seed();
2609     cmdline_cleanup();
2610     console_provide_logctx(NULL);
2611     sk_cleanup();
2612
2613     return 0;
2614 }