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