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