psftp.c

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