psftp.c

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