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  * Actual sftp commands.
 173  */
 174 struct sftp_command {
 175     char **words;
 176     int nwords, wordssize;
 177     int (*obey) (struct sftp_command *);        /* returns <0 to quit */
 178 };
 179
 180 int sftp_cmd_null(struct sftp_command *cmd)
 181 {
 182     return 1;                          /* success */
 183 }
 184
 185 int sftp_cmd_unknown(struct sftp_command *cmd)
 186 {
 187     printf("psftp: unknown command \"%s\"\n", cmd->words[0]);
 188     return 0;                          /* failure */
 189 }
 190
 191 int sftp_cmd_quit(struct sftp_command *cmd)
 192 {
 193     return -1;
 194 }
 195
 196 /*
 197  * List a directory. If no arguments are given, list pwd; otherwise
 198  * list the directory given in words[1].
 199  */
 200 static int sftp_ls_compare(const void *av, const void *bv)
 201 {
 202     const struct fxp_name *const *a = (const struct fxp_name *const *) av;
 203     const struct fxp_name *const *b = (const struct fxp_name *const *) bv;
 204     return strcmp((*a)->filename, (*b)->filename);
 205 }
 206 int sftp_cmd_ls(struct sftp_command *cmd)
 207 {
 208     struct fxp_handle *dirh;
 209     struct fxp_names *names;
 210     struct fxp_name **ournames;
 211     int nnames, namesize;
 212     char *dir, *cdir;
 213     struct sftp_packet *pktin;
 214     struct sftp_request *req, *rreq;
 215     int i;
 216
 217     if (back == NULL) {
 218         printf("psftp: not connected to a host; use \"open host.name\"\n");
 219         return 0;
 220     }
 221
 222     if (cmd->nwords < 2)
 223         dir = ".";
 224     else
 225         dir = cmd->words[1];
 226
 227     cdir = canonify(dir);
 228     if (!cdir) {
 229         printf("%s: %s\n", dir, fxp_error());
 230         return 0;
 231     }
 232
 233     printf("Listing directory %s\n", cdir);
 234
 235     sftp_register(req = fxp_opendir_send(cdir));
 236     rreq = sftp_find_request(pktin = sftp_recv());
 237     assert(rreq == req);
 238     dirh = fxp_opendir_recv(pktin, rreq);
 239
 240     if (dirh == NULL) {
 241         printf("Unable to open %s: %s\n", dir, fxp_error());
 242     } else {
 243         nnames = namesize = 0;
 244         ournames = NULL;
 245
 246         while (1) {
 247
 248             sftp_register(req = fxp_readdir_send(dirh));
 249             rreq = sftp_find_request(pktin = sftp_recv());
 250             assert(rreq == req);
 251             names = fxp_readdir_recv(pktin, rreq);
 252
 253             if (names == NULL) {
 254                 if (fxp_error_type() == SSH_FX_EOF)
 255                     break;
 256                 printf("Reading directory %s: %s\n", dir, fxp_error());
 257                 break;
 258             }
 259             if (names->nnames == 0) {
 260                 fxp_free_names(names);
 261                 break;
 262             }
 263
 264             if (nnames + names->nnames >= namesize) {
 265                 namesize += names->nnames + 128;
 266                 ournames = sresize(ournames, namesize, struct fxp_name *);
 267             }
 268
 269             for (i = 0; i < names->nnames; i++)
 270                 ournames[nnames++] = fxp_dup_name(&names->names[i]);
 271
 272             fxp_free_names(names);
 273         }
 274         sftp_register(req = fxp_close_send(dirh));
 275         rreq = sftp_find_request(pktin = sftp_recv());
 276         assert(rreq == req);
 277         fxp_close_recv(pktin, rreq);
 278
 279         /*
 280          * Now we have our filenames. Sort them by actual file
 281          * name, and then output the longname parts.
 282          */
 283         qsort(ournames, nnames, sizeof(*ournames), sftp_ls_compare);
 284
 285         /*
 286          * And print them.
 287          */
 288         for (i = 0; i < nnames; i++) {
 289             printf("%s\n", ournames[i]->longname);
 290             fxp_free_name(ournames[i]);
 291         }
 292         sfree(ournames);
 293     }
 294
 295     sfree(cdir);
 296
 297     return 1;
 298 }
 299
 300 /*
 301  * Change directories. We do this by canonifying the new name, then
 302  * trying to OPENDIR it. Only if that succeeds do we set the new pwd.
 303  */
 304 int sftp_cmd_cd(struct sftp_command *cmd)
 305 {
 306     struct fxp_handle *dirh;
 307     struct sftp_packet *pktin;
 308     struct sftp_request *req, *rreq;
 309     char *dir;
 310
 311     if (back == NULL) {
 312         printf("psftp: not connected to a host; use \"open host.name\"\n");
 313         return 0;
 314     }
 315
 316     if (cmd->nwords < 2)
 317         dir = dupstr(homedir);
 318     else
 319         dir = canonify(cmd->words[1]);
 320
 321     if (!dir) {
 322         printf("%s: %s\n", dir, fxp_error());
 323         return 0;
 324     }
 325
 326     sftp_register(req = fxp_opendir_send(dir));
 327     rreq = sftp_find_request(pktin = sftp_recv());
 328     assert(rreq == req);
 329     dirh = fxp_opendir_recv(pktin, rreq);
 330
 331     if (!dirh) {
 332         printf("Directory %s: %s\n", dir, fxp_error());
 333         sfree(dir);
 334         return 0;
 335     }
 336
 337     sftp_register(req = fxp_close_send(dirh));
 338     rreq = sftp_find_request(pktin = sftp_recv());
 339     assert(rreq == req);
 340     fxp_close_recv(pktin, rreq);
 341
 342     sfree(pwd);
 343     pwd = dir;
 344     printf("Remote directory is now %s\n", pwd);
 345
 346     return 1;
 347 }
 348
 349 /*
 350  * Print current directory. Easy as pie.
 351  */
 352 int sftp_cmd_pwd(struct sftp_command *cmd)
 353 {
 354     if (back == NULL) {
 355         printf("psftp: not connected to a host; use \"open host.name\"\n");
 356         return 0;
 357     }
 358
 359     printf("Remote directory is %s\n", pwd);
 360     return 1;
 361 }
 362
 363 /*
 364  * Get a file and save it at the local end. We have two very
 365  * similar commands here: `get' and `reget', which differ in that
 366  * `reget' checks for the existence of the destination file and
 367  * starts from where a previous aborted transfer left off.
 368  */
 369 int sftp_general_get(struct sftp_command *cmd, int restart)
 370 {
 371     struct fxp_handle *fh;
 372     struct sftp_packet *pktin;
 373     struct sftp_request *req, *rreq;
 374     struct fxp_xfer *xfer;
 375     char *fname, *outfname;
 376     uint64 offset;
 377     FILE *fp;
 378     int ret;
 379
 380     if (back == NULL) {
 381         printf("psftp: not connected to a host; use \"open host.name\"\n");
 382         return 0;
 383     }
 384
 385     if (cmd->nwords < 2) {
 386         printf("get: expects a filename\n");
 387         return 0;
 388     }
 389
 390     fname = canonify(cmd->words[1]);
 391     if (!fname) {
 392         printf("%s: %s\n", cmd->words[1], fxp_error());
 393         return 0;
 394     }
 395     outfname = (cmd->nwords == 2 ?
 396                 stripslashes(cmd->words[1], 0) : cmd->words[2]);
 397
 398     sftp_register(req = fxp_open_send(fname, SSH_FXF_READ));
 399     rreq = sftp_find_request(pktin = sftp_recv());
 400     assert(rreq == req);
 401     fh = fxp_open_recv(pktin, rreq);
 402
 403     if (!fh) {
 404         printf("%s: %s\n", fname, fxp_error());
 405         sfree(fname);
 406         return 0;
 407     }
 408
 409     if (restart) {
 410         fp = fopen(outfname, "rb+");
 411     } else {
 412         fp = fopen(outfname, "wb");
 413     }
 414
 415     if (!fp) {
 416         printf("local: unable to open %s\n", outfname);
 417
 418         sftp_register(req = fxp_close_send(fh));
 419         rreq = sftp_find_request(pktin = sftp_recv());
 420         assert(rreq == req);
 421         fxp_close_recv(pktin, rreq);
 422
 423         sfree(fname);
 424         return 0;
 425     }
 426
 427     if (restart) {
 428         long posn;
 429         fseek(fp, 0L, SEEK_END);
 430         posn = ftell(fp);
 431         printf("reget: restarting at file position %ld\n", posn);
 432         offset = uint64_make(0, posn);
 433     } else {
 434         offset = uint64_make(0, 0);
 435     }
 436
 437     printf("remote:%s => local:%s\n", fname, outfname);
 438
 439     /*
 440      * FIXME: we can use FXP_FSTAT here to get the file size, and
 441      * thus put up a progress bar.
 442      */
 443     ret = 1;
 444     xfer = xfer_download_init(fh, offset);
 445     while (!xfer_done(xfer)) {
 446         void *vbuf;
 447         int ret, len;
 448         int wpos, wlen;
 449
 450         xfer_download_queue(xfer);
 451         pktin = sftp_recv();
 452         ret = xfer_download_gotpkt(xfer, pktin);
 453
 454         if (ret < 0) {
 455             printf("error while reading: %s\n", fxp_error());
 456             ret = 0;
 457         }
 458
 459         while (xfer_download_data(xfer, &vbuf, &len)) {
 460             unsigned char *buf = (unsigned char *)vbuf;
 461
 462             wpos = 0;
 463             while (wpos < len) {
 464                 wlen = fwrite(buf + wpos, 1, len - wpos, fp);
 465                 if (wlen <= 0) {
 466                     printf("error while writing local file\n");
 467                     ret = 0;
 468                     xfer_set_error(xfer);
 469                 }
 470                 wpos += wlen;
 471             }
 472             if (wpos < len) {          /* we had an error */
 473                 ret = 0;
 474                 xfer_set_error(xfer);
 475             }
 476
 477             sfree(vbuf);
 478         }
 479     }
 480
 481     xfer_cleanup(xfer);
 482
 483     fclose(fp);
 484
 485     sftp_register(req = fxp_close_send(fh));
 486     rreq = sftp_find_request(pktin = sftp_recv());
 487     assert(rreq == req);
 488     fxp_close_recv(pktin, rreq);
 489
 490     sfree(fname);
 491
 492     return ret;
 493 }
 494 int sftp_cmd_get(struct sftp_command *cmd)
 495 {
 496     return sftp_general_get(cmd, 0);
 497 }
 498 int sftp_cmd_reget(struct sftp_command *cmd)
 499 {
 500     return sftp_general_get(cmd, 1);
 501 }
 502
 503 /*
 504  * Send a file and store it at the remote end. We have two very
 505  * similar commands here: `put' and `reput', which differ in that
 506  * `reput' checks for the existence of the destination file and
 507  * starts from where a previous aborted transfer left off.
 508  */
 509 int sftp_general_put(struct sftp_command *cmd, int restart)
 510 {
 511     struct fxp_handle *fh;
 512     struct fxp_xfer *xfer;
 513     char *fname, *origoutfname, *outfname;
 514     struct sftp_packet *pktin;
 515     struct sftp_request *req, *rreq;
 516     uint64 offset;
 517     FILE *fp;
 518     int ret, err, eof;
 519
 520     if (back == NULL) {
 521         printf("psftp: not connected to a host; use \"open host.name\"\n");
 522         return 0;
 523     }
 524
 525     if (cmd->nwords < 2) {
 526         printf("put: expects a filename\n");
 527         return 0;
 528     }
 529
 530     fname = cmd->words[1];
 531     origoutfname = (cmd->nwords == 2 ?
 532                     stripslashes(cmd->words[1], 1) : cmd->words[2]);
 533     outfname = canonify(origoutfname);
 534     if (!outfname) {
 535         printf("%s: %s\n", origoutfname, fxp_error());
 536         return 0;
 537     }
 538
 539     fp = fopen(fname, "rb");
 540     if (!fp) {
 541         printf("local: unable to open %s\n", fname);
 542         sfree(outfname);
 543         return 0;
 544     }
 545     if (restart) {
 546         sftp_register(req = fxp_open_send(outfname, SSH_FXF_WRITE));
 547     } else {
 548         sftp_register(req = fxp_open_send(outfname, SSH_FXF_WRITE |
 549                                           SSH_FXF_CREAT | SSH_FXF_TRUNC));
 550     }
 551     rreq = sftp_find_request(pktin = sftp_recv());
 552     assert(rreq == req);
 553     fh = fxp_open_recv(pktin, rreq);
 554
 555     if (!fh) {
 556         printf("%s: %s\n", outfname, fxp_error());
 557         sfree(outfname);
 558         return 0;
 559     }
 560
 561     if (restart) {
 562         char decbuf[30];
 563         struct fxp_attrs attrs;
 564         int ret;
 565
 566         sftp_register(req = fxp_fstat_send(fh));
 567         rreq = sftp_find_request(pktin = sftp_recv());
 568         assert(rreq == req);
 569         ret = fxp_fstat_recv(pktin, rreq, &attrs);
 570
 571         if (!ret) {
 572             printf("read size of %s: %s\n", outfname, fxp_error());
 573             sfree(outfname);
 574             return 0;
 575         }
 576         if (!(attrs.flags & SSH_FILEXFER_ATTR_SIZE)) {
 577             printf("read size of %s: size was not given\n", outfname);
 578             sfree(outfname);
 579             return 0;
 580         }
 581         offset = attrs.size;
 582         uint64_decimal(offset, decbuf);
 583         printf("reput: restarting at file position %s\n", decbuf);
 584         if (uint64_compare(offset, uint64_make(0, LONG_MAX)) > 0) {
 585             printf("reput: remote file is larger than we can deal with\n");
 586             sfree(outfname);
 587             return 0;
 588         }
 589         if (fseek(fp, offset.lo, SEEK_SET) != 0)
 590             fseek(fp, 0, SEEK_END);    /* *shrug* */
 591     } else {
 592         offset = uint64_make(0, 0);
 593     }
 594
 595     printf("local:%s => remote:%s\n", fname, outfname);
 596
 597     /*
 598      * FIXME: we can use FXP_FSTAT here to get the file size, and
 599      * thus put up a progress bar.
 600      */
 601     ret = 1;
 602     xfer = xfer_upload_init(fh, offset);
 603     err = eof = 0;
 604     while ((!err && !eof) || !xfer_done(xfer)) {
 605         char buffer[4096];
 606         int len, ret;
 607
 608         while (xfer_upload_ready(xfer) && !err && !eof) {
 609             len = fread(buffer, 1, sizeof(buffer), fp);
 610             if (len == -1) {
 611                 printf("error while reading local file\n");
 612                 err = 1;
 613             } else if (len == 0) {
 614                 eof = 1;
 615             } else {
 616                 xfer_upload_data(xfer, buffer, len);
 617             }
 618         }
 619
 620         if (!xfer_done(xfer)) {
 621             pktin = sftp_recv();
 622             ret = xfer_upload_gotpkt(xfer, pktin);
 623             if (!ret) {
 624                 printf("error while writing: %s\n", fxp_error());
 625                 err = 1;
 626             }
 627         }
 628     }
 629
 630     xfer_cleanup(xfer);
 631
 632     sftp_register(req = fxp_close_send(fh));
 633     rreq = sftp_find_request(pktin = sftp_recv());
 634     assert(rreq == req);
 635     fxp_close_recv(pktin, rreq);
 636
 637     fclose(fp);
 638     sfree(outfname);
 639
 640     return ret;
 641 }
 642 int sftp_cmd_put(struct sftp_command *cmd)
 643 {
 644     return sftp_general_put(cmd, 0);
 645 }
 646 int sftp_cmd_reput(struct sftp_command *cmd)
 647 {
 648     return sftp_general_put(cmd, 1);
 649 }
 650
 651 int sftp_cmd_mkdir(struct sftp_command *cmd)
 652 {
 653     char *dir;
 654     struct sftp_packet *pktin;
 655     struct sftp_request *req, *rreq;
 656     int result;
 657
 658     if (back == NULL) {
 659         printf("psftp: not connected to a host; use \"open host.name\"\n");
 660         return 0;
 661     }
 662
 663     if (cmd->nwords < 2) {
 664         printf("mkdir: expects a directory\n");
 665         return 0;
 666     }
 667
 668     dir = canonify(cmd->words[1]);
 669     if (!dir) {
 670         printf("%s: %s\n", dir, fxp_error());
 671         return 0;
 672     }
 673
 674     sftp_register(req = fxp_mkdir_send(dir));
 675     rreq = sftp_find_request(pktin = sftp_recv());
 676     assert(rreq == req);
 677     result = fxp_mkdir_recv(pktin, rreq);
 678
 679     if (!result) {
 680         printf("mkdir %s: %s\n", dir, fxp_error());
 681         sfree(dir);
 682         return 0;
 683     }
 684
 685     sfree(dir);
 686     return 1;
 687 }
 688
 689 int sftp_cmd_rmdir(struct sftp_command *cmd)
 690 {
 691     char *dir;
 692     struct sftp_packet *pktin;
 693     struct sftp_request *req, *rreq;
 694     int result;
 695
 696     if (back == NULL) {
 697         printf("psftp: not connected to a host; use \"open host.name\"\n");
 698         return 0;
 699     }
 700
 701     if (cmd->nwords < 2) {
 702         printf("rmdir: expects a directory\n");
 703         return 0;
 704     }
 705
 706     dir = canonify(cmd->words[1]);
 707     if (!dir) {
 708         printf("%s: %s\n", dir, fxp_error());
 709         return 0;
 710     }
 711
 712     sftp_register(req = fxp_rmdir_send(dir));
 713     rreq = sftp_find_request(pktin = sftp_recv());
 714     assert(rreq == req);
 715     result = fxp_rmdir_recv(pktin, rreq);
 716
 717     if (!result) {
 718         printf("rmdir %s: %s\n", dir, fxp_error());
 719         sfree(dir);
 720         return 0;
 721     }
 722
 723     sfree(dir);
 724     return 1;
 725 }
 726
 727 int sftp_cmd_rm(struct sftp_command *cmd)
 728 {
 729     char *fname;
 730     struct sftp_packet *pktin;
 731     struct sftp_request *req, *rreq;
 732     int result;
 733
 734     if (back == NULL) {
 735         printf("psftp: not connected to a host; use \"open host.name\"\n");
 736         return 0;
 737     }
 738
 739     if (cmd->nwords < 2) {
 740         printf("rm: expects a filename\n");
 741         return 0;
 742     }
 743
 744     fname = canonify(cmd->words[1]);
 745     if (!fname) {
 746         printf("%s: %s\n", fname, fxp_error());
 747         return 0;
 748     }
 749
 750     sftp_register(req = fxp_remove_send(fname));
 751     rreq = sftp_find_request(pktin = sftp_recv());
 752     assert(rreq == req);
 753     result = fxp_remove_recv(pktin, rreq);
 754
 755     if (!result) {
 756         printf("rm %s: %s\n", fname, fxp_error());
 757         sfree(fname);
 758         return 0;
 759     }
 760
 761     sfree(fname);
 762     return 1;
 763 }
 764
 765 int sftp_cmd_mv(struct sftp_command *cmd)
 766 {
 767     char *srcfname, *dstfname;
 768     struct sftp_packet *pktin;
 769     struct sftp_request *req, *rreq;
 770     int result;
 771
 772     if (back == NULL) {
 773         printf("psftp: not connected to a host; use \"open host.name\"\n");
 774         return 0;
 775     }
 776
 777     if (cmd->nwords < 3) {
 778         printf("mv: expects two filenames\n");
 779         return 0;
 780     }
 781     srcfname = canonify(cmd->words[1]);
 782     if (!srcfname) {
 783         printf("%s: %s\n", srcfname, fxp_error());
 784         return 0;
 785     }
 786
 787     dstfname = canonify(cmd->words[2]);
 788     if (!dstfname) {
 789         printf("%s: %s\n", dstfname, fxp_error());
 790         return 0;
 791     }
 792
 793     sftp_register(req = fxp_rename_send(srcfname, dstfname));
 794     rreq = sftp_find_request(pktin = sftp_recv());
 795     assert(rreq == req);
 796     result = fxp_rename_recv(pktin, rreq);
 797
 798     if (!result) {
 799         char const *error = fxp_error();
 800         struct fxp_attrs attrs;
 801
 802         /*
 803          * The move might have failed because dstfname pointed at a
 804          * directory. We check this possibility now: if dstfname
 805          * _is_ a directory, we re-attempt the move by appending
 806          * the basename of srcfname to dstfname.
 807          */
 808         sftp_register(req = fxp_stat_send(dstfname));
 809         rreq = sftp_find_request(pktin = sftp_recv());
 810         assert(rreq == req);
 811         result = fxp_stat_recv(pktin, rreq, &attrs);
 812
 813         if (result &&
 814             (attrs.flags & SSH_FILEXFER_ATTR_PERMISSIONS) &&
 815             (attrs.permissions & 0040000)) {
 816             char *p;
 817             char *newname, *newcanon;
 818             printf("(destination %s is a directory)\n", dstfname);
 819             p = srcfname + strlen(srcfname);
 820             while (p > srcfname && p[-1] != '/') p--;
 821             newname = dupcat(dstfname, "/", p, NULL);
 822             newcanon = canonify(newname);
 823             sfree(newname);
 824             if (newcanon) {
 825                 sfree(dstfname);
 826                 dstfname = newcanon;
 827
 828                 sftp_register(req = fxp_rename_send(srcfname, dstfname));
 829                 rreq = sftp_find_request(pktin = sftp_recv());
 830                 assert(rreq == req);
 831                 result = fxp_rename_recv(pktin, rreq);
 832
 833                 error = result ? NULL : fxp_error();
 834             }
 835         }
 836         if (error) {
 837             printf("mv %s %s: %s\n", srcfname, dstfname, error);
 838             sfree(srcfname);
 839             sfree(dstfname);
 840             return 0;
 841         }
 842     }
 843     printf("%s -> %s\n", srcfname, dstfname);
 844
 845     sfree(srcfname);
 846     sfree(dstfname);
 847     return 1;
 848 }
 849
 850 int sftp_cmd_chmod(struct sftp_command *cmd)
 851 {
 852     char *fname, *mode;
 853     int result;
 854     struct fxp_attrs attrs;
 855     unsigned attrs_clr, attrs_xor, oldperms, newperms;
 856     struct sftp_packet *pktin;
 857     struct sftp_request *req, *rreq;
 858
 859     if (back == NULL) {
 860         printf("psftp: not connected to a host; use \"open host.name\"\n");
 861         return 0;
 862     }
 863
 864     if (cmd->nwords < 3) {
 865         printf("chmod: expects a mode specifier and a filename\n");
 866         return 0;
 867     }
 868
 869     /*
 870      * Attempt to parse the mode specifier in cmd->words[1]. We
 871      * don't support the full horror of Unix chmod; instead we
 872      * support a much simpler syntax in which the user can either
 873      * specify an octal number, or a comma-separated sequence of
 874      * [ugoa]*[-+=][rwxst]+. (The initial [ugoa] sequence may
 875      * _only_ be omitted if the only attribute mentioned is t,
 876      * since all others require a user/group/other specification.
 877      * Additionally, the s attribute may not be specified for any
 878      * [ugoa] specifications other than exactly u or exactly g.
 879      */
 880     attrs_clr = attrs_xor = 0;
 881     mode = cmd->words[1];
 882     if (mode[0] >= '0' && mode[0] <= '9') {
 883         if (mode[strspn(mode, "01234567")]) {
 884             printf("chmod: numeric file modes should"
 885                    " contain digits 0-7 only\n");
 886             return 0;
 887         }
 888         attrs_clr = 07777;
 889         sscanf(mode, "%o", &attrs_xor);
 890         attrs_xor &= attrs_clr;
 891     } else {
 892         while (*mode) {
 893             char *modebegin = mode;
 894             unsigned subset, perms;
 895             int action;
 896
 897             subset = 0;
 898             while (*mode && *mode != ',' &&
 899                    *mode != '+' && *mode != '-' && *mode != '=') {
 900                 switch (*mode) {
 901                   case 'u': subset |= 04700; break; /* setuid, user perms */
 902                   case 'g': subset |= 02070; break; /* setgid, group perms */
 903                   case 'o': subset |= 00007; break; /* just other perms */
 904                   case 'a': subset |= 06777; break; /* all of the above */
 905                   default:
 906                     printf("chmod: file mode '%.*s' contains unrecognised"
 907                            " user/group/other specifier '%c'\n",
 908                            (int)strcspn(modebegin, ","), modebegin, *mode);
 909                     return 0;
 910                 }
 911                 mode++;
 912             }
 913             if (!*mode || *mode == ',') {
 914                 printf("chmod: file mode '%.*s' is incomplete\n",
 915                        (int)strcspn(modebegin, ","), modebegin);
 916                 return 0;
 917             }
 918             action = *mode++;
 919             if (!*mode || *mode == ',') {
 920                 printf("chmod: file mode '%.*s' is incomplete\n",
 921                        (int)strcspn(modebegin, ","), modebegin);
 922                 return 0;
 923             }
 924             perms = 0;
 925             while (*mode && *mode != ',') {
 926                 switch (*mode) {
 927                   case 'r': perms |= 00444; break;
 928                   case 'w': perms |= 00222; break;
 929                   case 'x': perms |= 00111; break;
 930                   case 't': perms |= 01000; subset |= 01000; break;
 931                   case 's':
 932                     if ((subset & 06777) != 04700 &&
 933                         (subset & 06777) != 02070) {
 934                         printf("chmod: file mode '%.*s': set[ug]id bit should"
 935                                " be used with exactly one of u or g only\n",
 936                                (int)strcspn(modebegin, ","), modebegin);
 937                         return 0;
 938                     }
 939                     perms |= 06000;
 940                     break;
 941                   default:
 942                     printf("chmod: file mode '%.*s' contains unrecognised"
 943                            " permission specifier '%c'\n",
 944                            (int)strcspn(modebegin, ","), modebegin, *mode);
 945                     return 0;
 946                 }
 947                 mode++;
 948             }
 949             if (!(subset & 06777) && (perms &~ subset)) {
 950                 printf("chmod: file mode '%.*s' contains no user/group/other"
 951                        " specifier and permissions other than 't' \n",
 952                        (int)strcspn(modebegin, ","), modebegin);
 953                 return 0;
 954             }
 955             perms &= subset;
 956             switch (action) {
 957               case '+':
 958                 attrs_clr |= perms;
 959                 attrs_xor |= perms;
 960                 break;
 961               case '-':
 962                 attrs_clr |= perms;
 963                 attrs_xor &= ~perms;
 964                 break;
 965               case '=':
 966                 attrs_clr |= subset;
 967                 attrs_xor |= perms;
 968                 break;
 969             }
 970             if (*mode) mode++;         /* eat comma */
 971         }
 972     }
 973
 974     fname = canonify(cmd->words[2]);
 975     if (!fname) {
 976         printf("%s: %s\n", fname, fxp_error());
 977         return 0;
 978     }
 979
 980     sftp_register(req = fxp_stat_send(fname));
 981     rreq = sftp_find_request(pktin = sftp_recv());
 982     assert(rreq == req);
 983     result = fxp_stat_recv(pktin, rreq, &attrs);
 984
 985     if (!result || !(attrs.flags & SSH_FILEXFER_ATTR_PERMISSIONS)) {
 986         printf("get attrs for %s: %s\n", fname,
 987                result ? "file permissions not provided" : fxp_error());
 988         sfree(fname);
 989         return 0;
 990     }
 991
 992     attrs.flags = SSH_FILEXFER_ATTR_PERMISSIONS;   /* perms _only_ */
 993     oldperms = attrs.permissions & 07777;
 994     attrs.permissions &= ~attrs_clr;
 995     attrs.permissions ^= attrs_xor;
 996     newperms = attrs.permissions & 07777;
 997
 998     sftp_register(req = fxp_setstat_send(fname, attrs));
 999     rreq = sftp_find_request(pktin = sftp_recv());
1000     assert(rreq == req);
1001     result = fxp_setstat_recv(pktin, rreq);
1002
1003     if (!result) {
1004         printf("set attrs for %s: %s\n", fname, fxp_error());
1005         sfree(fname);
1006         return 0;
1007     }
1008
1009     printf("%s: %04o -> %04o\n", fname, oldperms, newperms);
1010
1011     sfree(fname);
1012     return 1;
1013 }
1014
1015 static int sftp_cmd_open(struct sftp_command *cmd)
1016 {
1017     int portnumber;
1018
1019     if (back != NULL) {
1020         printf("psftp: already connected\n");
1021         return 0;
1022     }
1023
1024     if (cmd->nwords < 2) {
1025         printf("open: expects a host name\n");
1026         return 0;
1027     }
1028
1029     if (cmd->nwords > 2) {
1030         portnumber = atoi(cmd->words[2]);
1031         if (portnumber == 0) {
1032             printf("open: invalid port number\n");
1033             return 0;
1034         }
1035     } else
1036         portnumber = 0;
1037
1038     if (psftp_connect(cmd->words[1], NULL, portnumber)) {
1039         back = NULL;                   /* connection is already closed */
1040         return -1;                     /* this is fatal */
1041     }
1042     do_sftp_init();
1043     return 1;
1044 }
1045
1046 static int sftp_cmd_lcd(struct sftp_command *cmd)
1047 {
1048     char *currdir, *errmsg;
1049
1050     if (cmd->nwords < 2) {
1051         printf("lcd: expects a local directory name\n");
1052         return 0;
1053     }
1054
1055     errmsg = psftp_lcd(cmd->words[1]);
1056     if (errmsg) {
1057         printf("lcd: unable to change directory: %s\n", errmsg);
1058         sfree(errmsg);
1059         return 0;
1060     }
1061
1062     currdir = psftp_getcwd();
1063     printf("New local directory is %s\n", currdir);
1064     sfree(currdir);
1065
1066     return 1;
1067 }
1068
1069 static int sftp_cmd_lpwd(struct sftp_command *cmd)
1070 {
1071     char *currdir;
1072
1073     currdir = psftp_getcwd();
1074     printf("Current local directory is %s\n", currdir);
1075     sfree(currdir);
1076
1077     return 1;
1078 }
1079
1080 static int sftp_cmd_pling(struct sftp_command *cmd)
1081 {
1082     int exitcode;
1083
1084     exitcode = system(cmd->words[1]);
1085     return (exitcode == 0);
1086 }
1087
1088 static int sftp_cmd_help(struct sftp_command *cmd);
1089
1090 static struct sftp_cmd_lookup {
1091     char *name;
1092     /*
1093      * For help purposes, there are two kinds of command:
1094      *
1095      *  - primary commands, in which `longhelp' is non-NULL. In
1096      *    this case `shorthelp' is descriptive text, and `longhelp'
1097      *    is longer descriptive text intended to be printed after
1098      *    the command name.
1099      *
1100      *  - alias commands, in which `longhelp' is NULL. In this case
1101      *    `shorthelp' is the name of a primary command, which
1102      *    contains the help that should double up for this command.
1103      */
1104     int listed;                        /* do we list this in primary help? */
1105     char *shorthelp;
1106     char *longhelp;
1107     int (*obey) (struct sftp_command *);
1108 } sftp_lookup[] = {
1109     /*
1110      * List of sftp commands. This is binary-searched so it MUST be
1111      * in ASCII order.
1112      */
1113     {
1114         "!", TRUE, "run a local command",
1115             "<command>\n"
1116             /* FIXME: this example is crap for non-Windows. */
1117             "  Runs a local command. For example, \"!del myfile\".\n",
1118             sftp_cmd_pling
1119     },
1120     {
1121         "bye", TRUE, "finish your SFTP session",
1122             "\n"
1123             "  Terminates your SFTP session and quits the PSFTP program.\n",
1124             sftp_cmd_quit
1125     },
1126     {
1127         "cd", TRUE, "change your remote working directory",
1128             " [ <New working directory> ]\n"
1129             "  Change the remote working directory for your SFTP session.\n"
1130             "  If a new working directory is not supplied, you will be\n"
1131             "  returned to your home directory.\n",
1132             sftp_cmd_cd
1133     },
1134     {
1135         "chmod", TRUE, "change file permissions and modes",
1136             " ( <octal-digits> | <modifiers> ) <filename>\n"
1137             "  Change the file permissions on a file or directory.\n"
1138             "  <octal-digits> can be any octal Unix permission specifier.\n"
1139             "  Alternatively, <modifiers> can include:\n"
1140             "    u+r     make file readable by owning user\n"
1141             "    u+w     make file writable by owning user\n"
1142             "    u+x     make file executable by owning user\n"
1143             "    u-r     make file not readable by owning user\n"
1144             "    [also u-w, u-x]\n"
1145             "    g+r     make file readable by members of owning group\n"
1146             "    [also g+w, g+x, g-r, g-w, g-x]\n"
1147             "    o+r     make file readable by all other users\n"
1148             "    [also o+w, o+x, o-r, o-w, o-x]\n"
1149             "    a+r     make file readable by absolutely everybody\n"
1150             "    [also a+w, a+x, a-r, a-w, a-x]\n"
1151             "    u+s     enable the Unix set-user-ID bit\n"
1152             "    u-s     disable the Unix set-user-ID bit\n"
1153             "    g+s     enable the Unix set-group-ID bit\n"
1154             "    g-s     disable the Unix set-group-ID bit\n"
1155             "    +t      enable the Unix \"sticky bit\"\n"
1156             "  You can give more than one modifier for the same user (\"g-rwx\"), and\n"
1157             "  more than one user for the same modifier (\"ug+w\"). You can\n"
1158             "  use commas to separate different modifiers (\"u+rwx,g+s\").\n",
1159             sftp_cmd_chmod
1160     },
1161     {
1162         "del", TRUE, "delete a file",
1163             " <filename>\n"
1164             "  Delete a file.\n",
1165             sftp_cmd_rm
1166     },
1167     {
1168         "delete", FALSE, "del", NULL, sftp_cmd_rm
1169     },
1170     {
1171         "dir", TRUE, "list contents of a remote directory",
1172             " [ <directory-name> ]\n"
1173             "  List the contents of a specified directory on the server.\n"
1174             "  If <directory-name> is not given, the current working directory\n"
1175             "  will be listed.\n",
1176             sftp_cmd_ls
1177     },
1178     {
1179         "exit", TRUE, "bye", NULL, sftp_cmd_quit
1180     },
1181     {
1182         "get", TRUE, "download a file from the server to your local machine",
1183             " <filename> [ <local-filename> ]\n"
1184             "  Downloads a file on the server and stores it locally under\n"
1185             "  the same name, or under a different one if you supply the\n"
1186             "  argument <local-filename>.\n",
1187             sftp_cmd_get
1188     },
1189     {
1190         "help", TRUE, "give help",
1191             " [ <command> [ <command> ... ] ]\n"
1192             "  Give general help if no commands are specified.\n"
1193             "  If one or more commands are specified, give specific help on\n"
1194             "  those particular commands.\n",
1195             sftp_cmd_help
1196     },
1197     {
1198         "lcd", TRUE, "change local working directory",
1199             " <local-directory-name>\n"
1200             "  Change the local working directory of the PSFTP program (the\n"
1201             "  default location where the \"get\" command will save files).\n",
1202             sftp_cmd_lcd
1203     },
1204     {
1205         "lpwd", TRUE, "print local working directory",
1206             "\n"
1207             "  Print the local working directory of the PSFTP program (the\n"
1208             "  default location where the \"get\" command will save files).\n",
1209             sftp_cmd_lpwd
1210     },
1211     {
1212         "ls", TRUE, "dir", NULL,
1213             sftp_cmd_ls
1214     },
1215     {
1216         "mkdir", TRUE, "create a directory on the remote server",
1217             " <directory-name>\n"
1218             "  Creates a directory with the given name on the server.\n",
1219             sftp_cmd_mkdir
1220     },
1221     {
1222         "mv", TRUE, "move or rename a file on the remote server",
1223             " <source-filename> <destination-filename>\n"
1224             "  Moves or renames the file <source-filename> on the server,\n"
1225             "  so that it is accessible under the name <destination-filename>.\n",
1226             sftp_cmd_mv
1227     },
1228     {
1229         "open", TRUE, "connect to a host",
1230             " [<user>@]<hostname> [<port>]\n"
1231             "  Establishes an SFTP connection to a given host. Only usable\n"
1232             "  when you did not already specify a host name on the command\n"
1233             "  line.\n",
1234             sftp_cmd_open
1235     },
1236     {
1237         "put", TRUE, "upload a file from your local machine to the server",
1238             " <filename> [ <remote-filename> ]\n"
1239             "  Uploads a file to the server and stores it there under\n"
1240             "  the same name, or under a different one if you supply the\n"
1241             "  argument <remote-filename>.\n",
1242             sftp_cmd_put
1243     },
1244     {
1245         "pwd", TRUE, "print your remote working directory",
1246             "\n"
1247             "  Print the current remote working directory for your SFTP session.\n",
1248             sftp_cmd_pwd
1249     },
1250     {
1251         "quit", TRUE, "bye", NULL,
1252             sftp_cmd_quit
1253     },
1254     {
1255         "reget", TRUE, "continue downloading a file",
1256             " <filename> [ <local-filename> ]\n"
1257             "  Works exactly like the \"get\" command, but the local file\n"
1258             "  must already exist. The download will begin at the end of the\n"
1259             "  file. This is for resuming a download that was interrupted.\n",
1260             sftp_cmd_reget
1261     },
1262     {
1263         "ren", TRUE, "mv", NULL,
1264             sftp_cmd_mv
1265     },
1266     {
1267         "rename", FALSE, "mv", NULL,
1268             sftp_cmd_mv
1269     },
1270     {
1271         "reput", TRUE, "continue uploading a file",
1272             " <filename> [ <remote-filename> ]\n"
1273             "  Works exactly like the \"put\" command, but the remote file\n"
1274             "  must already exist. The upload will begin at the end of the\n"
1275             "  file. This is for resuming an upload that was interrupted.\n",
1276             sftp_cmd_reput
1277     },
1278     {
1279         "rm", TRUE, "del", NULL,
1280             sftp_cmd_rm
1281     },
1282     {
1283         "rmdir", TRUE, "remove a directory on the remote server",
1284             " <directory-name>\n"
1285             "  Removes the directory with the given name on the server.\n"
1286             "  The directory will not be removed unless it is empty.\n",
1287             sftp_cmd_rmdir
1288     }
1289 };
1290
1291 const struct sftp_cmd_lookup *lookup_command(char *name)
1292 {
1293     int i, j, k, cmp;
1294
1295     i = -1;
1296     j = sizeof(sftp_lookup) / sizeof(*sftp_lookup);
1297     while (j - i > 1) {
1298         k = (j + i) / 2;
1299         cmp = strcmp(name, sftp_lookup[k].name);
1300         if (cmp < 0)
1301             j = k;
1302         else if (cmp > 0)
1303             i = k;
1304         else {
1305             return &sftp_lookup[k];
1306         }
1307     }
1308     return NULL;
1309 }
1310
1311 static int sftp_cmd_help(struct sftp_command *cmd)
1312 {
1313     int i;
1314     if (cmd->nwords == 1) {
1315         /*
1316          * Give short help on each command.
1317          */
1318         int maxlen;
1319         maxlen = 0;
1320         for (i = 0; i < sizeof(sftp_lookup) / sizeof(*sftp_lookup); i++) {
1321             int len;
1322             if (!sftp_lookup[i].listed)
1323                 continue;
1324             len = strlen(sftp_lookup[i].name);
1325             if (maxlen < len)
1326                 maxlen = len;
1327         }
1328         for (i = 0; i < sizeof(sftp_lookup) / sizeof(*sftp_lookup); i++) {
1329             const struct sftp_cmd_lookup *lookup;
1330             if (!sftp_lookup[i].listed)
1331                 continue;
1332             lookup = &sftp_lookup[i];
1333             printf("%-*s", maxlen+2, lookup->name);
1334             if (lookup->longhelp == NULL)
1335                 lookup = lookup_command(lookup->shorthelp);
1336             printf("%s\n", lookup->shorthelp);
1337         }
1338     } else {
1339         /*
1340          * Give long help on specific commands.
1341          */
1342         for (i = 1; i < cmd->nwords; i++) {
1343             const struct sftp_cmd_lookup *lookup;
1344             lookup = lookup_command(cmd->words[i]);
1345             if (!lookup) {
1346                 printf("help: %s: command not found\n", cmd->words[i]);
1347             } else {
1348                 printf("%s", lookup->name);
1349                 if (lookup->longhelp == NULL)
1350                     lookup = lookup_command(lookup->shorthelp);
1351                 printf("%s", lookup->longhelp);
1352             }
1353         }
1354     }
1355     return 1;
1356 }
1357
1358 /* ----------------------------------------------------------------------
1359  * Command line reading and parsing.
1360  */
1361 struct sftp_command *sftp_getcmd(FILE *fp, int mode, int modeflags)
1362 {
1363     char *line;
1364     int linelen, linesize;
1365     struct sftp_command *cmd;
1366     char *p, *q, *r;
1367     int quoting;
1368
1369     if ((mode == 0) || (modeflags & 1)) {
1370         printf("psftp> ");
1371     }
1372     fflush(stdout);
1373
1374     cmd = snew(struct sftp_command);
1375     cmd->words = NULL;
1376     cmd->nwords = 0;
1377     cmd->wordssize = 0;
1378
1379     line = NULL;
1380     linesize = linelen = 0;
1381     while (1) {
1382         int len;
1383         char *ret;
1384
1385         linesize += 512;
1386         line = sresize(line, linesize, char);
1387         ret = fgets(line + linelen, linesize - linelen, fp);
1388
1389         if (!ret || (linelen == 0 && line[0] == '\0')) {
1390             cmd->obey = sftp_cmd_quit;
1391             if ((mode == 0) || (modeflags & 1))
1392                 printf("quit\n");
1393             return cmd;                /* eof */
1394         }
1395         len = linelen + strlen(line + linelen);
1396         linelen += len;
1397         if (line[linelen - 1] == '\n') {
1398             linelen--;
1399             line[linelen] = '\0';
1400             break;
1401         }
1402     }
1403     if (modeflags & 1) {
1404         printf("%s\n", line);
1405     }
1406
1407     p = line;
1408     while (*p && (*p == ' ' || *p == '\t'))
1409         p++;
1410
1411     if (*p == '!') {
1412         /*
1413          * Special case: the ! command. This is always parsed as
1414          * exactly two words: one containing the !, and the second
1415          * containing everything else on the line.
1416          */
1417         cmd->nwords = cmd->wordssize = 2;
1418         cmd->words = sresize(cmd->words, cmd->wordssize, char *);
1419         cmd->words[0] = dupstr("!");
1420         cmd->words[1] = dupstr(p+1);
1421     } else {
1422
1423         /*
1424          * Parse the command line into words. The syntax is:
1425          *  - double quotes are removed, but cause spaces within to be
1426          *    treated as non-separating.
1427          *  - a double-doublequote pair is a literal double quote, inside
1428          *    _or_ outside quotes. Like this:
1429          *
1430          *      firstword "second word" "this has ""quotes"" in" and""this""
1431          *
1432          * becomes
1433          *
1434          *      >firstword<
1435          *      >second word<
1436          *      >this has "quotes" in<
1437          *      >and"this"<
1438          */
1439         while (*p) {
1440             /* skip whitespace */
1441             while (*p && (*p == ' ' || *p == '\t'))
1442                 p++;
1443             /* mark start of word */
1444             q = r = p;                 /* q sits at start, r writes word */
1445             quoting = 0;
1446             while (*p) {
1447                 if (!quoting && (*p == ' ' || *p == '\t'))
1448                     break;                     /* reached end of word */
1449                 else if (*p == '"' && p[1] == '"')
1450                     p += 2, *r++ = '"';    /* a literal quote */
1451                 else if (*p == '"')
1452                     p++, quoting = !quoting;
1453                 else
1454                     *r++ = *p++;
1455             }
1456             if (*p)
1457                 p++;                   /* skip over the whitespace */
1458             *r = '\0';
1459             if (cmd->nwords >= cmd->wordssize) {
1460                 cmd->wordssize = cmd->nwords + 16;
1461                 cmd->words = sresize(cmd->words, cmd->wordssize, char *);
1462             }
1463             cmd->words[cmd->nwords++] = dupstr(q);
1464         }
1465     }
1466
1467         sfree(line);
1468     /*
1469      * Now parse the first word and assign a function.
1470      */
1471
1472     if (cmd->nwords == 0)
1473         cmd->obey = sftp_cmd_null;
1474     else {
1475         const struct sftp_cmd_lookup *lookup;
1476         lookup = lookup_command(cmd->words[0]);
1477         if (!lookup)
1478             cmd->obey = sftp_cmd_unknown;
1479         else
1480             cmd->obey = lookup->obey;
1481     }
1482
1483     return cmd;
1484 }
1485
1486 static int do_sftp_init(void)
1487 {
1488     struct sftp_packet *pktin;
1489     struct sftp_request *req, *rreq;
1490
1491     /*
1492      * Do protocol initialisation.
1493      */
1494     if (!fxp_init()) {
1495         fprintf(stderr,
1496                 "Fatal: unable to initialise SFTP: %s\n", fxp_error());
1497         return 1;                      /* failure */
1498     }
1499
1500     /*
1501      * Find out where our home directory is.
1502      */
1503     sftp_register(req = fxp_realpath_send("."));
1504     rreq = sftp_find_request(pktin = sftp_recv());
1505     assert(rreq == req);
1506     homedir = fxp_realpath_recv(pktin, rreq);
1507
1508     if (!homedir) {
1509         fprintf(stderr,
1510                 "Warning: failed to resolve home directory: %s\n",
1511                 fxp_error());
1512         homedir = dupstr(".");
1513     } else {
1514         printf("Remote working directory is %s\n", homedir);
1515     }
1516     pwd = dupstr(homedir);
1517     return 0;
1518 }
1519
1520 void do_sftp_cleanup()
1521 {
1522     char ch;
1523     if (back) {
1524         back->special(backhandle, TS_EOF);
1525         sftp_recvdata(&ch, 1);
1526         back->free(backhandle);
1527         sftp_cleanup_request();
1528     }
1529     if (pwd) {
1530         sfree(pwd);
1531         pwd = NULL;
1532     }
1533     if (homedir) {
1534         sfree(homedir);
1535         homedir = NULL;
1536     }
1537 }
1538
1539 void do_sftp(int mode, int modeflags, char *batchfile)
1540 {
1541     FILE *fp;
1542     int ret;
1543
1544     /*
1545      * Batch mode?
1546      */
1547     if (mode == 0) {
1548
1549         /* ------------------------------------------------------------------
1550          * Now we're ready to do Real Stuff.
1551          */
1552         while (1) {
1553             struct sftp_command *cmd;
1554             cmd = sftp_getcmd(stdin, 0, 0);
1555             if (!cmd)
1556                 break;
1557             ret = cmd->obey(cmd);
1558             if (cmd->words) {
1559                 int i;
1560                 for(i = 0; i < cmd->nwords; i++)
1561                     sfree(cmd->words[i]);
1562                 sfree(cmd->words);
1563             }
1564             sfree(cmd);
1565             if (ret < 0)
1566                 break;
1567         }
1568     } else {
1569         fp = fopen(batchfile, "r");
1570         if (!fp) {
1571             printf("Fatal: unable to open %s\n", batchfile);
1572             return;
1573         }
1574         while (1) {
1575             struct sftp_command *cmd;
1576             cmd = sftp_getcmd(fp, mode, modeflags);
1577             if (!cmd)
1578                 break;
1579             ret = cmd->obey(cmd);
1580             if (ret < 0)
1581                 break;
1582             if (ret == 0) {
1583                 if (!(modeflags & 2))
1584                     break;
1585             }
1586         }
1587         fclose(fp);
1588
1589     }
1590 }
1591
1592 /* ----------------------------------------------------------------------
1593  * Dirty bits: integration with PuTTY.
1594  */
1595
1596 static int verbose = 0;
1597
1598 /*
1599  *  Print an error message and perform a fatal exit.
1600  */
1601 void fatalbox(char *fmt, ...)
1602 {
1603     char *str, *str2;
1604     va_list ap;
1605     va_start(ap, fmt);
1606     str = dupvprintf(fmt, ap);
1607     str2 = dupcat("Fatal: ", str, "\n", NULL);
1608     sfree(str);
1609     va_end(ap);
1610     fputs(str2, stderr);
1611     sfree(str2);
1612
1613     cleanup_exit(1);
1614 }
1615 void modalfatalbox(char *fmt, ...)
1616 {
1617     char *str, *str2;
1618     va_list ap;
1619     va_start(ap, fmt);
1620     str = dupvprintf(fmt, ap);
1621     str2 = dupcat("Fatal: ", str, "\n", NULL);
1622     sfree(str);
1623     va_end(ap);
1624     fputs(str2, stderr);
1625     sfree(str2);
1626
1627     cleanup_exit(1);
1628 }
1629 void connection_fatal(void *frontend, char *fmt, ...)
1630 {
1631     char *str, *str2;
1632     va_list ap;
1633     va_start(ap, fmt);
1634     str = dupvprintf(fmt, ap);
1635     str2 = dupcat("Fatal: ", str, "\n", NULL);
1636     sfree(str);
1637     va_end(ap);
1638     fputs(str2, stderr);
1639     sfree(str2);
1640
1641     cleanup_exit(1);
1642 }
1643
1644 void ldisc_send(void *handle, char *buf, int len, int interactive)
1645 {
1646     /*
1647      * This is only here because of the calls to ldisc_send(NULL,
1648      * 0) in ssh.c. Nothing in PSFTP actually needs to use the
1649      * ldisc as an ldisc. So if we get called with any real data, I
1650      * want to know about it.
1651      */
1652     assert(len == 0);
1653 }
1654
1655 /*
1656  * In psftp, all agent requests should be synchronous, so this is a
1657  * never-called stub.
1658  */
1659 void agent_schedule_callback(void (*callback)(void *, void *, int),
1660                              void *callback_ctx, void *data, int len)
1661 {
1662     assert(!"We shouldn't be here");
1663 }
1664
1665 /*
1666  * Receive a block of data from the SSH link. Block until all data
1667  * is available.
1668  *
1669  * To do this, we repeatedly call the SSH protocol module, with our
1670  * own trap in from_backend() to catch the data that comes back. We
1671  * do this until we have enough data.
1672  */
1673
1674 static unsigned char *outptr;          /* where to put the data */
1675 static unsigned outlen;                /* how much data required */
1676 static unsigned char *pending = NULL;  /* any spare data */
1677 static unsigned pendlen = 0, pendsize = 0;      /* length and phys. size of buffer */
1678 int from_backend(void *frontend, int is_stderr, const char *data, int datalen)
1679 {
1680     unsigned char *p = (unsigned char *) data;
1681     unsigned len = (unsigned) datalen;
1682
1683     /*
1684      * stderr data is just spouted to local stderr and otherwise
1685      * ignored.
1686      */
1687     if (is_stderr) {
1688         if (len > 0)
1689             fwrite(data, 1, len, stderr);
1690         return 0;
1691     }
1692
1693     /*
1694      * If this is before the real session begins, just return.
1695      */
1696     if (!outptr)
1697         return 0;
1698
1699     if ((outlen > 0) && (len > 0)) {
1700         unsigned used = outlen;
1701         if (used > len)
1702             used = len;
1703         memcpy(outptr, p, used);
1704         outptr += used;
1705         outlen -= used;
1706         p += used;
1707         len -= used;
1708     }
1709
1710     if (len > 0) {
1711         if (pendsize < pendlen + len) {
1712             pendsize = pendlen + len + 4096;
1713             pending = sresize(pending, pendsize, unsigned char);
1714         }
1715         memcpy(pending + pendlen, p, len);
1716         pendlen += len;
1717     }
1718
1719     return 0;
1720 }
1721 int sftp_recvdata(char *buf, int len)
1722 {
1723     outptr = (unsigned char *) buf;
1724     outlen = len;
1725
1726     /*
1727      * See if the pending-input block contains some of what we
1728      * need.
1729      */
1730     if (pendlen > 0) {
1731         unsigned pendused = pendlen;
1732         if (pendused > outlen)
1733             pendused = outlen;
1734         memcpy(outptr, pending, pendused);
1735         memmove(pending, pending + pendused, pendlen - pendused);
1736         outptr += pendused;
1737         outlen -= pendused;
1738         pendlen -= pendused;
1739         if (pendlen == 0) {
1740             pendsize = 0;
1741             sfree(pending);
1742             pending = NULL;
1743         }
1744         if (outlen == 0)
1745             return 1;
1746     }
1747
1748     while (outlen > 0) {
1749         if (ssh_sftp_loop_iteration() < 0)
1750             return 0;                  /* doom */
1751     }
1752
1753     return 1;
1754 }
1755 int sftp_senddata(char *buf, int len)
1756 {
1757     back->send(backhandle, buf, len);
1758     return 1;
1759 }
1760
1761 /*
1762  *  Short description of parameters.
1763  */
1764 static void usage(void)
1765 {
1766     printf("PuTTY Secure File Transfer (SFTP) client\n");
1767     printf("%s\n", ver);
1768     printf("Usage: psftp [options] [user@]host\n");
1769     printf("Options:\n");
1770     printf("  -b file   use specified batchfile\n");
1771     printf("  -bc       output batchfile commands\n");
1772     printf("  -be       don't stop batchfile processing if errors\n");
1773     printf("  -v        show verbose messages\n");
1774     printf("  -load sessname  Load settings from saved session\n");
1775     printf("  -l user   connect with specified username\n");
1776     printf("  -P port   connect to specified port\n");
1777     printf("  -pw passw login with specified password\n");
1778     printf("  -1 -2     force use of particular SSH protocol version\n");
1779     printf("  -C        enable compression\n");
1780     printf("  -i key    private key file for authentication\n");
1781     printf("  -batch    disable all interactive prompts\n");
1782     printf("  -V        print version information\n");
1783     cleanup_exit(1);
1784 }
1785
1786 static void version(void)
1787 {
1788   printf("psftp: %s\n", ver);
1789   cleanup_exit(1);
1790 }
1791
1792 /*
1793  * Connect to a host.
1794  */
1795 static int psftp_connect(char *userhost, char *user, int portnumber)
1796 {
1797     char *host, *realhost;
1798     const char *err;
1799     void *logctx;
1800
1801     /* Separate host and username */
1802     host = userhost;
1803     host = strrchr(host, '@');
1804     if (host == NULL) {
1805         host = userhost;
1806     } else {
1807         *host++ = '\0';
1808         if (user) {
1809             printf("psftp: multiple usernames specified; using \"%s\"\n",
1810                    user);
1811         } else
1812             user = userhost;
1813     }
1814
1815     /*
1816      * If we haven't loaded session details already (e.g., from -load),
1817      * try looking for a session called "host".
1818      */
1819     if (!loaded_session) {
1820         /* Try to load settings for `host' into a temporary config */
1821         Config cfg2;
1822         cfg2.host[0] = '\0';
1823         do_defaults(host, &cfg2);
1824         if (cfg2.host[0] != '\0') {
1825             /* Settings present and include hostname */
1826             /* Re-load data into the real config. */
1827             do_defaults(host, &cfg);
1828         } else {
1829             /* Session doesn't exist or mention a hostname. */
1830             /* Use `host' as a bare hostname. */
1831             strncpy(cfg.host, host, sizeof(cfg.host) - 1);
1832             cfg.host[sizeof(cfg.host) - 1] = '\0';
1833         }
1834     } else {
1835         /* Patch in hostname `host' to session details. */
1836         strncpy(cfg.host, host, sizeof(cfg.host) - 1);
1837         cfg.host[sizeof(cfg.host) - 1] = '\0';
1838     }
1839
1840     /*
1841      * Force use of SSH. (If they got the protocol wrong we assume the
1842      * port is useless too.)
1843      */
1844     if (cfg.protocol != PROT_SSH) {
1845         cfg.protocol = PROT_SSH;
1846         cfg.port = 22;
1847     }
1848
1849     /*
1850      * If saved session / Default Settings says SSH-1 (`1 only' or `1'),
1851      * then change it to SSH-2, on the grounds that that's more likely to
1852      * work for SFTP. (Can be overridden with `-1' option.)
1853      * But if it says `2 only' or `2', respect which.
1854      */
1855     if (cfg.sshprot != 2 && cfg.sshprot != 3)
1856         cfg.sshprot = 2;
1857
1858     /*
1859      * Enact command-line overrides.
1860      */
1861     cmdline_run_saved(&cfg);
1862
1863     /*
1864      * Trim leading whitespace off the hostname if it's there.
1865      */
1866     {
1867         int space = strspn(cfg.host, " \t");
1868         memmove(cfg.host, cfg.host+space, 1+strlen(cfg.host)-space);
1869     }
1870
1871     /* See if host is of the form user@host */
1872     if (cfg.host[0] != '\0') {
1873         char *atsign = strrchr(cfg.host, '@');
1874         /* Make sure we're not overflowing the user field */
1875         if (atsign) {
1876             if (atsign - cfg.host < sizeof cfg.username) {
1877                 strncpy(cfg.username, cfg.host, atsign - cfg.host);
1878                 cfg.username[atsign - cfg.host] = '\0';
1879             }
1880             memmove(cfg.host, atsign + 1, 1 + strlen(atsign + 1));
1881         }
1882     }
1883
1884     /*
1885      * Trim a colon suffix off the hostname if it's there.
1886      */
1887     cfg.host[strcspn(cfg.host, ":")] = '\0';
1888
1889     /*
1890      * Remove any remaining whitespace from the hostname.
1891      */
1892     {
1893         int p1 = 0, p2 = 0;
1894         while (cfg.host[p2] != '\0') {
1895             if (cfg.host[p2] != ' ' && cfg.host[p2] != '\t') {
1896                 cfg.host[p1] = cfg.host[p2];
1897                 p1++;
1898             }
1899             p2++;
1900         }
1901         cfg.host[p1] = '\0';
1902     }
1903
1904     /* Set username */
1905     if (user != NULL && user[0] != '\0') {
1906         strncpy(cfg.username, user, sizeof(cfg.username) - 1);
1907         cfg.username[sizeof(cfg.username) - 1] = '\0';
1908     }
1909     if (!cfg.username[0]) {
1910         if (!console_get_line("login as: ",
1911                               cfg.username, sizeof(cfg.username), FALSE)) {
1912             fprintf(stderr, "psftp: no username, aborting\n");
1913             cleanup_exit(1);
1914         } else {
1915             int len = strlen(cfg.username);
1916             if (cfg.username[len - 1] == '\n')
1917                 cfg.username[len - 1] = '\0';
1918         }
1919     }
1920
1921     if (portnumber)
1922         cfg.port = portnumber;
1923
1924     /*
1925      * Disable scary things which shouldn't be enabled for simple
1926      * things like SCP and SFTP: agent forwarding, port forwarding,
1927      * X forwarding.
1928      */
1929     cfg.x11_forward = 0;
1930     cfg.agentfwd = 0;
1931     cfg.portfwd[0] = cfg.portfwd[1] = '\0';
1932
1933     /* Set up subsystem name. */
1934     strcpy(cfg.remote_cmd, "sftp");
1935     cfg.ssh_subsys = TRUE;
1936     cfg.nopty = TRUE;
1937
1938     /*
1939      * Set up fallback option, for SSH1 servers or servers with the
1940      * sftp subsystem not enabled but the server binary installed
1941      * in the usual place. We only support fallback on Unix
1942      * systems, and we use a kludgy piece of shellery which should
1943      * try to find sftp-server in various places (the obvious
1944      * systemwide spots /usr/lib and /usr/local/lib, and then the
1945      * user's PATH) and finally give up.
1946      *
1947      *   test -x /usr/lib/sftp-server && exec /usr/lib/sftp-server
1948      *   test -x /usr/local/lib/sftp-server && exec /usr/local/lib/sftp-server
1949      *   exec sftp-server
1950      *
1951      * the idea being that this will attempt to use either of the
1952      * obvious pathnames and then give up, and when it does give up
1953      * it will print the preferred pathname in the error messages.
1954      */
1955     cfg.remote_cmd_ptr2 =
1956         "test -x /usr/lib/sftp-server && exec /usr/lib/sftp-server\n"
1957         "test -x /usr/local/lib/sftp-server && exec /usr/local/lib/sftp-server\n"
1958         "exec sftp-server";
1959     cfg.ssh_subsys2 = FALSE;
1960
1961     back = &ssh_backend;
1962
1963     err = back->init(NULL, &backhandle, &cfg, cfg.host, cfg.port, &realhost,
1964                      0, cfg.tcp_keepalives);
1965     if (err != NULL) {
1966         fprintf(stderr, "ssh_init: %s\n", err);
1967         return 1;
1968     }
1969     logctx = log_init(NULL, &cfg);
1970     back->provide_logctx(backhandle, logctx);
1971     console_provide_logctx(logctx);
1972     while (!back->sendok(backhandle)) {
1973         if (ssh_sftp_loop_iteration() < 0) {
1974             fprintf(stderr, "ssh_init: error during SSH connection setup\n");
1975             return 1;
1976         }
1977     }
1978     if (verbose && realhost != NULL)
1979         printf("Connected to %s\n", realhost);
1980     if (realhost != NULL)
1981         sfree(realhost);
1982     return 0;
1983 }
1984
1985 void cmdline_error(char *p, ...)
1986 {
1987     va_list ap;
1988     fprintf(stderr, "psftp: ");
1989     va_start(ap, p);
1990     vfprintf(stderr, p, ap);
1991     va_end(ap);
1992     fprintf(stderr, "\n       try typing \"psftp -h\" for help\n");
1993     exit(1);
1994 }
1995
1996 /*
1997  * Main program. Parse arguments etc.
1998  */
1999 int psftp_main(int argc, char *argv[])
2000 {
2001     int i;
2002     int portnumber = 0;
2003     char *userhost, *user;
2004     int mode = 0;
2005     int modeflags = 0;
2006     char *batchfile = NULL;
2007     int errors = 0;
2008
2009     flags = FLAG_STDERR | FLAG_INTERACTIVE
2010 #ifdef FLAG_SYNCAGENT
2011         | FLAG_SYNCAGENT
2012 #endif
2013         ;
2014     cmdline_tooltype = TOOLTYPE_FILETRANSFER;
2015     ssh_get_line = &console_get_line;
2016     sk_init();
2017
2018     userhost = user = NULL;
2019
2020     /* Load Default Settings before doing anything else. */
2021     do_defaults(NULL, &cfg);
2022     loaded_session = FALSE;
2023
2024     errors = 0;
2025     for (i = 1; i < argc; i++) {
2026         int ret;
2027         if (argv[i][0] != '-') {
2028             if (userhost)
2029                 usage();
2030             else
2031                 userhost = dupstr(argv[i]);
2032             continue;
2033         }
2034         ret = cmdline_process_param(argv[i], i+1<argc?argv[i+1]:NULL, 1, &cfg);
2035         if (ret == -2) {
2036             cmdline_error("option \"%s\" requires an argument", argv[i]);
2037         } else if (ret == 2) {
2038             i++;               /* skip next argument */
2039         } else if (ret == 1) {
2040             /* We have our own verbosity in addition to `flags'. */
2041             if (flags & FLAG_VERBOSE)
2042                 verbose = 1;
2043         } else if (strcmp(argv[i], "-h") == 0 ||
2044                    strcmp(argv[i], "-?") == 0) {
2045             usage();
2046         } else if (strcmp(argv[i], "-V") == 0) {
2047             version();
2048         } else if (strcmp(argv[i], "-batch") == 0) {
2049             console_batch_mode = 1;
2050         } else if (strcmp(argv[i], "-b") == 0 && i + 1 < argc) {
2051             mode = 1;
2052             batchfile = argv[++i];
2053         } else if (strcmp(argv[i], "-bc") == 0) {
2054             modeflags = modeflags | 1;
2055         } else if (strcmp(argv[i], "-be") == 0) {
2056             modeflags = modeflags | 2;
2057         } else if (strcmp(argv[i], "--") == 0) {
2058             i++;
2059             break;
2060         } else {
2061             cmdline_error("unknown option \"%s\"", argv[i]);
2062         }
2063     }
2064     argc -= i;
2065     argv += i;
2066     back = NULL;
2067
2068     /*
2069      * If the loaded session provides a hostname, and a hostname has not
2070      * otherwise been specified, pop it in `userhost' so that
2071      * `psftp -load sessname' is sufficient to start a session.
2072      */
2073     if (!userhost && cfg.host[0] != '\0') {
2074         userhost = dupstr(cfg.host);
2075     }
2076
2077     /*
2078      * If a user@host string has already been provided, connect to
2079      * it now.
2080      */
2081     if (userhost) {
2082         int ret;
2083         ret = psftp_connect(userhost, user, portnumber);
2084         sfree(userhost);
2085         if (ret)
2086             return 1;
2087         if (do_sftp_init())
2088             return 1;
2089     } else {
2090         printf("psftp: no hostname specified; use \"open host.name\""
2091                " to connect\n");
2092     }
2093
2094     do_sftp(mode, modeflags, batchfile);
2095
2096     if (back != NULL && back->socket(backhandle) != NULL) {
2097         char ch;
2098         back->special(backhandle, TS_EOF);
2099         sftp_recvdata(&ch, 1);
2100     }
2101     random_save_seed();
2102     cmdline_cleanup();
2103     console_provide_logctx(NULL);
2104     do_sftp_cleanup();
2105     backhandle = NULL;
2106     back = NULL;
2107     sk_cleanup();
2108
2109     return 0;
2110 }