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                 printf("%s: canonify: %s\n", origwfname, fxp_error());
1262                 sfree(unwcfname);
1263                 return 0;
1264             }
1265
1266             if (!multiple && i < cmd->nwords)
1267                 outfname = cmd->words[i++];
1268             else
1269                 outfname = stripslashes(origwfname, 0);
1270
1271             ret = sftp_get_file(fname, outfname, recurse, restart);
1272
1273             sfree(fname);
1274
1275             if (swcm) {
1276                 sfree(origwfname);
1277                 origwfname = sftp_wildcard_get_filename(swcm);
1278             } else {
1279                 origwfname = NULL;
1280             }
1281         }
1282         sfree(unwcfname);
1283         if (swcm)
1284             sftp_finish_wildcard_matching(swcm);
1285         if (!ret)
1286             return ret;
1287
1288     } while (multiple && i < cmd->nwords);
1289
1290     return ret;
1291 }
1292 int sftp_cmd_get(struct sftp_command *cmd)
1293 {
1294     return sftp_general_get(cmd, 0, 0);
1295 }
1296 int sftp_cmd_mget(struct sftp_command *cmd)
1297 {
1298     return sftp_general_get(cmd, 0, 1);
1299 }
1300 int sftp_cmd_reget(struct sftp_command *cmd)
1301 {
1302     return sftp_general_get(cmd, 1, 0);
1303 }
1304
1305 /*
1306  * Send a file and store it at the remote end. We have three very
1307  * similar commands here. The basic one is `put'; `reput' differs
1308  * in that it checks for the existence of the destination file and
1309  * starts from where a previous aborted transfer left off; `mput'
1310  * differs in that it interprets all its arguments as files to
1311  * transfer (never as a different remote name for a local file) and
1312  * can handle wildcards.
1313  */
1314 int sftp_general_put(struct sftp_command *cmd, int restart, int multiple)
1315 {
1316     char *fname, *wfname, *origoutfname, *outfname;
1317     int i, ret;
1318     int recurse = FALSE;
1319
1320     if (back == NULL) {
1321         not_connected();
1322         return 0;
1323     }
1324
1325     i = 1;
1326     while (i < cmd->nwords && cmd->words[i][0] == '-') {
1327         if (!strcmp(cmd->words[i], "--")) {
1328             /* finish processing options */
1329             i++;
1330             break;
1331         } else if (!strcmp(cmd->words[i], "-r")) {
1332             recurse = TRUE;
1333         } else {
1334             printf("%s: unrecognised option '%s'\n", cmd->words[0], cmd->words[i]);
1335             return 0;
1336         }
1337         i++;
1338     }
1339
1340     if (i >= cmd->nwords) {
1341         printf("%s: expects a filename\n", cmd->words[0]);
1342         return 0;
1343     }
1344
1345     ret = 1;
1346     do {
1347         WildcardMatcher *wcm;
1348         fname = cmd->words[i++];
1349
1350         if (multiple && test_wildcard(fname, FALSE) == WCTYPE_WILDCARD) {
1351             wcm = begin_wildcard_matching(fname);
1352             wfname = wildcard_get_filename(wcm);
1353             if (!wfname) {
1354                 /* Politely warn the user that nothing matched. */
1355                 printf("%s: nothing matched\n", fname);
1356                 finish_wildcard_matching(wcm);
1357                 continue;
1358             }
1359         } else {
1360             wfname = fname;
1361             wcm = NULL;
1362         }
1363
1364         while (wfname) {
1365             if (!multiple && i < cmd->nwords)
1366                 origoutfname = cmd->words[i++];
1367             else
1368                 origoutfname = stripslashes(wfname, 1);
1369
1370             outfname = canonify(origoutfname);
1371             if (!outfname) {
1372                 printf("%s: canonify: %s\n", origoutfname, fxp_error());
1373                 if (wcm) {
1374                     sfree(wfname);
1375                     finish_wildcard_matching(wcm);
1376                 }
1377                 return 0;
1378             }
1379             ret = sftp_put_file(wfname, outfname, recurse, restart);
1380             sfree(outfname);
1381
1382             if (wcm) {
1383                 sfree(wfname);
1384                 wfname = wildcard_get_filename(wcm);
1385             } else {
1386                 wfname = NULL;
1387             }
1388         }
1389
1390         if (wcm)
1391             finish_wildcard_matching(wcm);
1392
1393         if (!ret)
1394             return ret;
1395
1396     } while (multiple && i < cmd->nwords);
1397
1398     return ret;
1399 }
1400 int sftp_cmd_put(struct sftp_command *cmd)
1401 {
1402     return sftp_general_put(cmd, 0, 0);
1403 }
1404 int sftp_cmd_mput(struct sftp_command *cmd)
1405 {
1406     return sftp_general_put(cmd, 0, 1);
1407 }
1408 int sftp_cmd_reput(struct sftp_command *cmd)
1409 {
1410     return sftp_general_put(cmd, 1, 0);
1411 }
1412
1413 int sftp_cmd_mkdir(struct sftp_command *cmd)
1414 {
1415     char *dir;
1416     struct sftp_packet *pktin;
1417     struct sftp_request *req;
1418     int result;
1419     int i, ret;
1420
1421     if (back == NULL) {
1422         not_connected();
1423         return 0;
1424     }
1425
1426     if (cmd->nwords < 2) {
1427         printf("mkdir: expects a directory\n");
1428         return 0;
1429     }
1430
1431     ret = 1;
1432     for (i = 1; i < cmd->nwords; i++) {
1433         dir = canonify(cmd->words[i]);
1434         if (!dir) {
1435             printf("%s: canonify: %s\n", dir, fxp_error());
1436             return 0;
1437         }
1438
1439         req = fxp_mkdir_send(dir);
1440         pktin = sftp_wait_for_reply(req);
1441         result = fxp_mkdir_recv(pktin, req);
1442
1443         if (!result) {
1444             printf("mkdir %s: %s\n", dir, fxp_error());
1445             ret = 0;
1446         } else
1447             printf("mkdir %s: OK\n", dir);
1448
1449         sfree(dir);
1450     }
1451
1452     return ret;
1453 }
1454
1455 static int sftp_action_rmdir(void *vctx, char *dir)
1456 {
1457     struct sftp_packet *pktin;
1458     struct sftp_request *req;
1459     int result;
1460
1461     req = fxp_rmdir_send(dir);
1462     pktin = sftp_wait_for_reply(req);
1463     result = fxp_rmdir_recv(pktin, req);
1464
1465     if (!result) {
1466         printf("rmdir %s: %s\n", dir, fxp_error());
1467         return 0;
1468     }
1469
1470     printf("rmdir %s: OK\n", dir);
1471
1472     return 1;
1473 }
1474
1475 int sftp_cmd_rmdir(struct sftp_command *cmd)
1476 {
1477     int i, ret;
1478
1479     if (back == NULL) {
1480         not_connected();
1481         return 0;
1482     }
1483
1484     if (cmd->nwords < 2) {
1485         printf("rmdir: expects a directory\n");
1486         return 0;
1487     }
1488
1489     ret = 1;
1490     for (i = 1; i < cmd->nwords; i++)
1491         ret &= wildcard_iterate(cmd->words[i], sftp_action_rmdir, NULL);
1492
1493     return ret;
1494 }
1495
1496 static int sftp_action_rm(void *vctx, char *fname)
1497 {
1498     struct sftp_packet *pktin;
1499     struct sftp_request *req;
1500     int result;
1501
1502     req = fxp_remove_send(fname);
1503     pktin = sftp_wait_for_reply(req);
1504     result = fxp_remove_recv(pktin, req);
1505
1506     if (!result) {
1507         printf("rm %s: %s\n", fname, fxp_error());
1508         return 0;
1509     }
1510
1511     printf("rm %s: OK\n", fname);
1512
1513     return 1;
1514 }
1515
1516 int sftp_cmd_rm(struct sftp_command *cmd)
1517 {
1518     int i, ret;
1519
1520     if (back == NULL) {
1521         not_connected();
1522         return 0;
1523     }
1524
1525     if (cmd->nwords < 2) {
1526         printf("rm: expects a filename\n");
1527         return 0;
1528     }
1529
1530     ret = 1;
1531     for (i = 1; i < cmd->nwords; i++)
1532         ret &= wildcard_iterate(cmd->words[i], sftp_action_rm, NULL);
1533
1534     return ret;
1535 }
1536
1537 static int check_is_dir(char *dstfname)
1538 {
1539     struct sftp_packet *pktin;
1540     struct sftp_request *req;
1541     struct fxp_attrs attrs;
1542     int result;
1543
1544     req = fxp_stat_send(dstfname);
1545     pktin = sftp_wait_for_reply(req);
1546     result = fxp_stat_recv(pktin, req, &attrs);
1547
1548     if (result &&
1549         (attrs.flags & SSH_FILEXFER_ATTR_PERMISSIONS) &&
1550         (attrs.permissions & 0040000))
1551         return TRUE;
1552     else
1553         return FALSE;
1554 }
1555
1556 struct sftp_context_mv {
1557     char *dstfname;
1558     int dest_is_dir;
1559 };
1560
1561 static int sftp_action_mv(void *vctx, char *srcfname)
1562 {
1563     struct sftp_context_mv *ctx = (struct sftp_context_mv *)vctx;
1564     struct sftp_packet *pktin;
1565     struct sftp_request *req;
1566     const char *error;
1567     char *finalfname, *newcanon = NULL;
1568     int ret, result;
1569
1570     if (ctx->dest_is_dir) {
1571         char *p;
1572         char *newname;
1573
1574         p = srcfname + strlen(srcfname);
1575         while (p > srcfname && p[-1] != '/') p--;
1576         newname = dupcat(ctx->dstfname, "/", p, NULL);
1577         newcanon = canonify(newname);
1578         if (!newcanon) {
1579             printf("%s: canonify: %s\n", newname, fxp_error());
1580             sfree(newname);
1581             return 0;
1582         }
1583         sfree(newname);
1584
1585         finalfname = newcanon;
1586     } else {
1587         finalfname = ctx->dstfname;
1588     }
1589
1590     req = fxp_rename_send(srcfname, finalfname);
1591     pktin = sftp_wait_for_reply(req);
1592     result = fxp_rename_recv(pktin, req);
1593
1594     error = result ? NULL : fxp_error();
1595
1596     if (error) {
1597         printf("mv %s %s: %s\n", srcfname, finalfname, error);
1598         ret = 0;
1599     } else {
1600         printf("%s -> %s\n", srcfname, finalfname);
1601         ret = 1;
1602     }
1603
1604     sfree(newcanon);
1605     return ret;
1606 }
1607
1608 int sftp_cmd_mv(struct sftp_command *cmd)
1609 {
1610     struct sftp_context_mv actx, *ctx = &actx;
1611     int i, ret;
1612
1613     if (back == NULL) {
1614         not_connected();
1615         return 0;
1616     }
1617
1618     if (cmd->nwords < 3) {
1619         printf("mv: expects two filenames\n");
1620         return 0;
1621     }
1622
1623     ctx->dstfname = canonify(cmd->words[cmd->nwords-1]);
1624     if (!ctx->dstfname) {
1625         printf("%s: canonify: %s\n", ctx->dstfname, fxp_error());
1626         return 0;
1627     }
1628
1629     /*
1630      * If there's more than one source argument, or one source
1631      * argument which is a wildcard, we _require_ that the
1632      * destination is a directory.
1633      */
1634     ctx->dest_is_dir = check_is_dir(ctx->dstfname);
1635     if ((cmd->nwords > 3 || is_wildcard(cmd->words[1])) && !ctx->dest_is_dir) {
1636         printf("mv: multiple or wildcard arguments require the destination"
1637                " to be a directory\n");
1638         sfree(ctx->dstfname);
1639         return 0;
1640     }
1641
1642     /*
1643      * Now iterate over the source arguments.
1644      */
1645     ret = 1;
1646     for (i = 1; i < cmd->nwords-1; i++)
1647         ret &= wildcard_iterate(cmd->words[i], sftp_action_mv, ctx);
1648
1649     sfree(ctx->dstfname);
1650     return ret;
1651 }
1652
1653 struct sftp_context_chmod {
1654     unsigned attrs_clr, attrs_xor;
1655 };
1656
1657 static int sftp_action_chmod(void *vctx, char *fname)
1658 {
1659     struct fxp_attrs attrs;
1660     struct sftp_packet *pktin;
1661     struct sftp_request *req;
1662     int result;
1663     unsigned oldperms, newperms;
1664     struct sftp_context_chmod *ctx = (struct sftp_context_chmod *)vctx;
1665
1666     req = fxp_stat_send(fname);
1667     pktin = sftp_wait_for_reply(req);
1668     result = fxp_stat_recv(pktin, req, &attrs);
1669
1670     if (!result || !(attrs.flags & SSH_FILEXFER_ATTR_PERMISSIONS)) {
1671         printf("get attrs for %s: %s\n", fname,
1672                result ? "file permissions not provided" : fxp_error());
1673         return 0;
1674     }
1675
1676     attrs.flags = SSH_FILEXFER_ATTR_PERMISSIONS;   /* perms _only_ */
1677     oldperms = attrs.permissions & 07777;
1678     attrs.permissions &= ~ctx->attrs_clr;
1679     attrs.permissions ^= ctx->attrs_xor;
1680     newperms = attrs.permissions & 07777;
1681
1682     if (oldperms == newperms)
1683         return 1;                      /* no need to do anything! */
1684
1685     req = fxp_setstat_send(fname, attrs);
1686     pktin = sftp_wait_for_reply(req);
1687     result = fxp_setstat_recv(pktin, req);
1688
1689     if (!result) {
1690         printf("set attrs for %s: %s\n", fname, fxp_error());
1691         return 0;
1692     }
1693
1694     printf("%s: %04o -> %04o\n", fname, oldperms, newperms);
1695
1696     return 1;
1697 }
1698
1699 int sftp_cmd_chmod(struct sftp_command *cmd)
1700 {
1701     char *mode;
1702     int i, ret;
1703     struct sftp_context_chmod actx, *ctx = &actx;
1704
1705     if (back == NULL) {
1706         not_connected();
1707         return 0;
1708     }
1709
1710     if (cmd->nwords < 3) {
1711         printf("chmod: expects a mode specifier and a filename\n");
1712         return 0;
1713     }
1714
1715     /*
1716      * Attempt to parse the mode specifier in cmd->words[1]. We
1717      * don't support the full horror of Unix chmod; instead we
1718      * support a much simpler syntax in which the user can either
1719      * specify an octal number, or a comma-separated sequence of
1720      * [ugoa]*[-+=][rwxst]+. (The initial [ugoa] sequence may
1721      * _only_ be omitted if the only attribute mentioned is t,
1722      * since all others require a user/group/other specification.
1723      * Additionally, the s attribute may not be specified for any
1724      * [ugoa] specifications other than exactly u or exactly g.
1725      */
1726     ctx->attrs_clr = ctx->attrs_xor = 0;
1727     mode = cmd->words[1];
1728     if (mode[0] >= '0' && mode[0] <= '9') {
1729         if (mode[strspn(mode, "01234567")]) {
1730             printf("chmod: numeric file modes should"
1731                    " contain digits 0-7 only\n");
1732             return 0;
1733         }
1734         ctx->attrs_clr = 07777;
1735         sscanf(mode, "%o", &ctx->attrs_xor);
1736         ctx->attrs_xor &= ctx->attrs_clr;
1737     } else {
1738         while (*mode) {
1739             char *modebegin = mode;
1740             unsigned subset, perms;
1741             int action;
1742
1743             subset = 0;
1744             while (*mode && *mode != ',' &&
1745                    *mode != '+' && *mode != '-' && *mode != '=') {
1746                 switch (*mode) {
1747                   case 'u': subset |= 04700; break; /* setuid, user perms */
1748                   case 'g': subset |= 02070; break; /* setgid, group perms */
1749                   case 'o': subset |= 00007; break; /* just other perms */
1750                   case 'a': subset |= 06777; break; /* all of the above */
1751                   default:
1752                     printf("chmod: file mode '%.*s' contains unrecognised"
1753                            " user/group/other specifier '%c'\n",
1754                            (int)strcspn(modebegin, ","), modebegin, *mode);
1755                     return 0;
1756                 }
1757                 mode++;
1758             }
1759             if (!*mode || *mode == ',') {
1760                 printf("chmod: file mode '%.*s' is incomplete\n",
1761                        (int)strcspn(modebegin, ","), modebegin);
1762                 return 0;
1763             }
1764             action = *mode++;
1765             if (!*mode || *mode == ',') {
1766                 printf("chmod: file mode '%.*s' is incomplete\n",
1767                        (int)strcspn(modebegin, ","), modebegin);
1768                 return 0;
1769             }
1770             perms = 0;
1771             while (*mode && *mode != ',') {
1772                 switch (*mode) {
1773                   case 'r': perms |= 00444; break;
1774                   case 'w': perms |= 00222; break;
1775                   case 'x': perms |= 00111; break;
1776                   case 't': perms |= 01000; subset |= 01000; break;
1777                   case 's':
1778                     if ((subset & 06777) != 04700 &&
1779                         (subset & 06777) != 02070) {
1780                         printf("chmod: file mode '%.*s': set[ug]id bit should"
1781                                " be used with exactly one of u or g only\n",
1782                                (int)strcspn(modebegin, ","), modebegin);
1783                         return 0;
1784                     }
1785                     perms |= 06000;
1786                     break;
1787                   default:
1788                     printf("chmod: file mode '%.*s' contains unrecognised"
1789                            " permission specifier '%c'\n",
1790                            (int)strcspn(modebegin, ","), modebegin, *mode);
1791                     return 0;
1792                 }
1793                 mode++;
1794             }
1795             if (!(subset & 06777) && (perms &~ subset)) {
1796                 printf("chmod: file mode '%.*s' contains no user/group/other"
1797                        " specifier and permissions other than 't' \n",
1798                        (int)strcspn(modebegin, ","), modebegin);
1799                 return 0;
1800             }
1801             perms &= subset;
1802             switch (action) {
1803               case '+':
1804                 ctx->attrs_clr |= perms;
1805                 ctx->attrs_xor |= perms;
1806                 break;
1807               case '-':
1808                 ctx->attrs_clr |= perms;
1809                 ctx->attrs_xor &= ~perms;
1810                 break;
1811               case '=':
1812                 ctx->attrs_clr |= subset;
1813                 ctx->attrs_xor |= perms;
1814                 break;
1815             }
1816             if (*mode) mode++;         /* eat comma */
1817         }
1818     }
1819
1820     ret = 1;
1821     for (i = 2; i < cmd->nwords; i++)
1822         ret &= wildcard_iterate(cmd->words[i], sftp_action_chmod, ctx);
1823
1824     return ret;
1825 }
1826
1827 static int sftp_cmd_open(struct sftp_command *cmd)
1828 {
1829     int portnumber;
1830
1831     if (back != NULL) {
1832         printf("psftp: already connected\n");
1833         return 0;
1834     }
1835
1836     if (cmd->nwords < 2) {
1837         printf("open: expects a host name\n");
1838         return 0;
1839     }
1840
1841     if (cmd->nwords > 2) {
1842         portnumber = atoi(cmd->words[2]);
1843         if (portnumber == 0) {
1844             printf("open: invalid port number\n");
1845             return 0;
1846         }
1847     } else
1848         portnumber = 0;
1849
1850     if (psftp_connect(cmd->words[1], NULL, portnumber)) {
1851         back = NULL;                   /* connection is already closed */
1852         return -1;                     /* this is fatal */
1853     }
1854     do_sftp_init();
1855     return 1;
1856 }
1857
1858 static int sftp_cmd_lcd(struct sftp_command *cmd)
1859 {
1860     char *currdir, *errmsg;
1861
1862     if (cmd->nwords < 2) {
1863         printf("lcd: expects a local directory name\n");
1864         return 0;
1865     }
1866
1867     errmsg = psftp_lcd(cmd->words[1]);
1868     if (errmsg) {
1869         printf("lcd: unable to change directory: %s\n", errmsg);
1870         sfree(errmsg);
1871         return 0;
1872     }
1873
1874     currdir = psftp_getcwd();
1875     printf("New local directory is %s\n", currdir);
1876     sfree(currdir);
1877
1878     return 1;
1879 }
1880
1881 static int sftp_cmd_lpwd(struct sftp_command *cmd)
1882 {
1883     char *currdir;
1884
1885     currdir = psftp_getcwd();
1886     printf("Current local directory is %s\n", currdir);
1887     sfree(currdir);
1888
1889     return 1;
1890 }
1891
1892 static int sftp_cmd_pling(struct sftp_command *cmd)
1893 {
1894     int exitcode;
1895
1896     exitcode = system(cmd->words[1]);
1897     return (exitcode == 0);
1898 }
1899
1900 static int sftp_cmd_help(struct sftp_command *cmd);
1901
1902 static struct sftp_cmd_lookup {
1903     char *name;
1904     /*
1905      * For help purposes, there are two kinds of command:
1906      *
1907      *  - primary commands, in which `longhelp' is non-NULL. In
1908      *    this case `shorthelp' is descriptive text, and `longhelp'
1909      *    is longer descriptive text intended to be printed after
1910      *    the command name.
1911      *
1912      *  - alias commands, in which `longhelp' is NULL. In this case
1913      *    `shorthelp' is the name of a primary command, which
1914      *    contains the help that should double up for this command.
1915      */
1916     int listed;                        /* do we list this in primary help? */
1917     char *shorthelp;
1918     char *longhelp;
1919     int (*obey) (struct sftp_command *);
1920 } sftp_lookup[] = {
1921     /*
1922      * List of sftp commands. This is binary-searched so it MUST be
1923      * in ASCII order.
1924      */
1925     {
1926         "!", TRUE, "run a local command",
1927             "<command>\n"
1928             /* FIXME: this example is crap for non-Windows. */
1929             "  Runs a local command. For example, \"!del myfile\".\n",
1930             sftp_cmd_pling
1931     },
1932     {
1933         "bye", TRUE, "finish your SFTP session",
1934             "\n"
1935             "  Terminates your SFTP session and quits the PSFTP program.\n",
1936             sftp_cmd_quit
1937     },
1938     {
1939         "cd", TRUE, "change your remote working directory",
1940             " [ <new working directory> ]\n"
1941             "  Change the remote working directory for your SFTP session.\n"
1942             "  If a new working directory is not supplied, you will be\n"
1943             "  returned to your home directory.\n",
1944             sftp_cmd_cd
1945     },
1946     {
1947         "chmod", TRUE, "change file permissions and modes",
1948             " <modes> <filename-or-wildcard> [ <filename-or-wildcard>... ]\n"
1949             "  Change the file permissions on one or more remote files or\n"
1950             "  directories.\n"
1951             "  <modes> can be any octal Unix permission specifier.\n"
1952             "  Alternatively, <modes> can include the following modifiers:\n"
1953             "    u+r     make file readable by owning user\n"
1954             "    u+w     make file writable by owning user\n"
1955             "    u+x     make file executable by owning user\n"
1956             "    u-r     make file not readable by owning user\n"
1957             "    [also u-w, u-x]\n"
1958             "    g+r     make file readable by members of owning group\n"
1959             "    [also g+w, g+x, g-r, g-w, g-x]\n"
1960             "    o+r     make file readable by all other users\n"
1961             "    [also o+w, o+x, o-r, o-w, o-x]\n"
1962             "    a+r     make file readable by absolutely everybody\n"
1963             "    [also a+w, a+x, a-r, a-w, a-x]\n"
1964             "    u+s     enable the Unix set-user-ID bit\n"
1965             "    u-s     disable the Unix set-user-ID bit\n"
1966             "    g+s     enable the Unix set-group-ID bit\n"
1967             "    g-s     disable the Unix set-group-ID bit\n"
1968             "    +t      enable the Unix \"sticky bit\"\n"
1969             "  You can give more than one modifier for the same user (\"g-rwx\"), and\n"
1970             "  more than one user for the same modifier (\"ug+w\"). You can\n"
1971             "  use commas to separate different modifiers (\"u+rwx,g+s\").\n",
1972             sftp_cmd_chmod
1973     },
1974     {
1975         "close", TRUE, "finish your SFTP session but do not quit PSFTP",
1976             "\n"
1977             "  Terminates your SFTP session, but does not quit the PSFTP\n"
1978             "  program. You can then use \"open\" to start another SFTP\n"
1979             "  session, to the same server or to a different one.\n",
1980             sftp_cmd_close
1981     },
1982     {
1983         "del", TRUE, "delete files on the remote server",
1984             " <filename-or-wildcard> [ <filename-or-wildcard>... ]\n"
1985             "  Delete a file or files from the server.\n",
1986             sftp_cmd_rm
1987     },
1988     {
1989         "delete", FALSE, "del", NULL, sftp_cmd_rm
1990     },
1991     {
1992         "dir", TRUE, "list remote files",
1993             " [ <directory-name> ]/[ <wildcard> ]\n"
1994             "  List the contents of a specified directory on the server.\n"
1995             "  If <directory-name> is not given, the current working directory\n"
1996             "  is assumed.\n"
1997             "  If <wildcard> is given, it is treated as a set of files to\n"
1998             "  list; otherwise, all files are listed.\n",
1999             sftp_cmd_ls
2000     },
2001     {
2002         "exit", TRUE, "bye", NULL, sftp_cmd_quit
2003     },
2004     {
2005         "get", TRUE, "download a file from the server to your local machine",
2006             " [ -r ] [ -- ] <filename> [ <local-filename> ]\n"
2007             "  Downloads a file on the server and stores it locally under\n"
2008             "  the same name, or under a different one if you supply the\n"
2009             "  argument <local-filename>.\n"
2010             "  If -r specified, recursively fetch a directory.\n",
2011             sftp_cmd_get
2012     },
2013     {
2014         "help", TRUE, "give help",
2015             " [ <command> [ <command> ... ] ]\n"
2016             "  Give general help if no commands are specified.\n"
2017             "  If one or more commands are specified, give specific help on\n"
2018             "  those particular commands.\n",
2019             sftp_cmd_help
2020     },
2021     {
2022         "lcd", TRUE, "change local working directory",
2023             " <local-directory-name>\n"
2024             "  Change the local working directory of the PSFTP program (the\n"
2025             "  default location where the \"get\" command will save files).\n",
2026             sftp_cmd_lcd
2027     },
2028     {
2029         "lpwd", TRUE, "print local working directory",
2030             "\n"
2031             "  Print the local working directory of the PSFTP program (the\n"
2032             "  default location where the \"get\" command will save files).\n",
2033             sftp_cmd_lpwd
2034     },
2035     {
2036         "ls", TRUE, "dir", NULL,
2037             sftp_cmd_ls
2038     },
2039     {
2040         "mget", TRUE, "download multiple files at once",
2041             " [ -r ] [ -- ] <filename-or-wildcard> [ <filename-or-wildcard>... ]\n"
2042             "  Downloads many files from the server, storing each one under\n"
2043             "  the same name it has on the server side. You can use wildcards\n"
2044             "  such as \"*.c\" to specify lots of files at once.\n"
2045             "  If -r specified, recursively fetch files and directories.\n",
2046             sftp_cmd_mget
2047     },
2048     {
2049         "mkdir", TRUE, "create directories on the remote server",
2050             " <directory-name> [ <directory-name>... ]\n"
2051             "  Creates directories with the given names on the server.\n",
2052             sftp_cmd_mkdir
2053     },
2054     {
2055         "mput", TRUE, "upload multiple files at once",
2056             " [ -r ] [ -- ] <filename-or-wildcard> [ <filename-or-wildcard>... ]\n"
2057             "  Uploads many files to the server, storing each one under the\n"
2058             "  same name it has on the client side. You can use wildcards\n"
2059             "  such as \"*.c\" to specify lots of files at once.\n"
2060             "  If -r specified, recursively store files and directories.\n",
2061             sftp_cmd_mput
2062     },
2063     {
2064         "mv", TRUE, "move or rename file(s) on the remote server",
2065             " <source> [ <source>... ] <destination>\n"
2066             "  Moves or renames <source>(s) on the server to <destination>,\n"
2067             "  also on the server.\n"
2068             "  If <destination> specifies an existing directory, then <source>\n"
2069             "  may be a wildcard, and multiple <source>s may be given; all\n"
2070             "  source files are moved into <destination>.\n"
2071             "  Otherwise, <source> must specify a single file, which is moved\n"
2072             "  or renamed so that it is accessible under the name <destination>.\n",
2073             sftp_cmd_mv
2074     },
2075     {
2076         "open", TRUE, "connect to a host",
2077             " [<user>@]<hostname> [<port>]\n"
2078             "  Establishes an SFTP connection to a given host. Only usable\n"
2079             "  when you are not already connected to a server.\n",
2080             sftp_cmd_open
2081     },
2082     {
2083         "put", TRUE, "upload a file from your local machine to the server",
2084             " [ -r ] [ -- ] <filename> [ <remote-filename> ]\n"
2085             "  Uploads a file to the server and stores it there under\n"
2086             "  the same name, or under a different one if you supply the\n"
2087             "  argument <remote-filename>.\n"
2088             "  If -r specified, recursively store a directory.\n",
2089             sftp_cmd_put
2090     },
2091     {
2092         "pwd", TRUE, "print your remote working directory",
2093             "\n"
2094             "  Print the current remote working directory for your SFTP session.\n",
2095             sftp_cmd_pwd
2096     },
2097     {
2098         "quit", TRUE, "bye", NULL,
2099             sftp_cmd_quit
2100     },
2101     {
2102         "reget", TRUE, "continue downloading files",
2103             " [ -r ] [ -- ] <filename> [ <local-filename> ]\n"
2104             "  Works exactly like the \"get\" command, but the local file\n"
2105             "  must already exist. The download will begin at the end of the\n"
2106             "  file. This is for resuming a download that was interrupted.\n"
2107             "  If -r specified, resume interrupted \"get -r\".\n",
2108             sftp_cmd_reget
2109     },
2110     {
2111         "ren", TRUE, "mv", NULL,
2112             sftp_cmd_mv
2113     },
2114     {
2115         "rename", FALSE, "mv", NULL,
2116             sftp_cmd_mv
2117     },
2118     {
2119         "reput", TRUE, "continue uploading files",
2120             " [ -r ] [ -- ] <filename> [ <remote-filename> ]\n"
2121             "  Works exactly like the \"put\" command, but the remote file\n"
2122             "  must already exist. The upload will begin at the end of the\n"
2123             "  file. This is for resuming an upload that was interrupted.\n"
2124             "  If -r specified, resume interrupted \"put -r\".\n",
2125             sftp_cmd_reput
2126     },
2127     {
2128         "rm", TRUE, "del", NULL,
2129             sftp_cmd_rm
2130     },
2131     {
2132         "rmdir", TRUE, "remove directories on the remote server",
2133             " <directory-name> [ <directory-name>... ]\n"
2134             "  Removes the directory with the given name on the server.\n"
2135             "  The directory will not be removed unless it is empty.\n"
2136             "  Wildcards may be used to specify multiple directories.\n",
2137             sftp_cmd_rmdir
2138     }
2139 };
2140
2141 const struct sftp_cmd_lookup *lookup_command(char *name)
2142 {
2143     int i, j, k, cmp;
2144
2145     i = -1;
2146     j = sizeof(sftp_lookup) / sizeof(*sftp_lookup);
2147     while (j - i > 1) {
2148         k = (j + i) / 2;
2149         cmp = strcmp(name, sftp_lookup[k].name);
2150         if (cmp < 0)
2151             j = k;
2152         else if (cmp > 0)
2153             i = k;
2154         else {
2155             return &sftp_lookup[k];
2156         }
2157     }
2158     return NULL;
2159 }
2160
2161 static int sftp_cmd_help(struct sftp_command *cmd)
2162 {
2163     int i;
2164     if (cmd->nwords == 1) {
2165         /*
2166          * Give short help on each command.
2167          */
2168         int maxlen;
2169         maxlen = 0;
2170         for (i = 0; i < sizeof(sftp_lookup) / sizeof(*sftp_lookup); i++) {
2171             int len;
2172             if (!sftp_lookup[i].listed)
2173                 continue;
2174             len = strlen(sftp_lookup[i].name);
2175             if (maxlen < len)
2176                 maxlen = len;
2177         }
2178         for (i = 0; i < sizeof(sftp_lookup) / sizeof(*sftp_lookup); i++) {
2179             const struct sftp_cmd_lookup *lookup;
2180             if (!sftp_lookup[i].listed)
2181                 continue;
2182             lookup = &sftp_lookup[i];
2183             printf("%-*s", maxlen+2, lookup->name);
2184             if (lookup->longhelp == NULL)
2185                 lookup = lookup_command(lookup->shorthelp);
2186             printf("%s\n", lookup->shorthelp);
2187         }
2188     } else {
2189         /*
2190          * Give long help on specific commands.
2191          */
2192         for (i = 1; i < cmd->nwords; i++) {
2193             const struct sftp_cmd_lookup *lookup;
2194             lookup = lookup_command(cmd->words[i]);
2195             if (!lookup) {
2196                 printf("help: %s: command not found\n", cmd->words[i]);
2197             } else {
2198                 printf("%s", lookup->name);
2199                 if (lookup->longhelp == NULL)
2200                     lookup = lookup_command(lookup->shorthelp);
2201                 printf("%s", lookup->longhelp);
2202             }
2203         }
2204     }
2205     return 1;
2206 }
2207
2208 /* ----------------------------------------------------------------------
2209  * Command line reading and parsing.
2210  */
2211 struct sftp_command *sftp_getcmd(FILE *fp, int mode, int modeflags)
2212 {
2213     char *line;
2214     struct sftp_command *cmd;
2215     char *p, *q, *r;
2216     int quoting;
2217
2218     cmd = snew(struct sftp_command);
2219     cmd->words = NULL;
2220     cmd->nwords = 0;
2221     cmd->wordssize = 0;
2222
2223     line = NULL;
2224
2225     if (fp) {
2226         if (modeflags & 1)
2227             printf("psftp> ");
2228         line = fgetline(fp);
2229     } else {
2230         line = ssh_sftp_get_cmdline("psftp> ", back == NULL);
2231     }
2232
2233     if (!line || !*line) {
2234         cmd->obey = sftp_cmd_quit;
2235         if ((mode == 0) || (modeflags & 1))
2236             printf("quit\n");
2237         sfree(line);
2238         return cmd;                    /* eof */
2239     }
2240
2241     line[strcspn(line, "\r\n")] = '\0';
2242
2243     if (modeflags & 1) {
2244         printf("%s\n", line);
2245     }
2246
2247     p = line;
2248     while (*p && (*p == ' ' || *p == '\t'))
2249         p++;
2250
2251     if (*p == '!') {
2252         /*
2253          * Special case: the ! command. This is always parsed as
2254          * exactly two words: one containing the !, and the second
2255          * containing everything else on the line.
2256          */
2257         cmd->nwords = cmd->wordssize = 2;
2258         cmd->words = sresize(cmd->words, cmd->wordssize, char *);
2259         cmd->words[0] = dupstr("!");
2260         cmd->words[1] = dupstr(p+1);
2261     } else if (*p == '#') {
2262         /*
2263          * Special case: comment. Entire line is ignored.
2264          */
2265         cmd->nwords = cmd->wordssize = 0;
2266     } else {
2267
2268         /*
2269          * Parse the command line into words. The syntax is:
2270          *  - double quotes are removed, but cause spaces within to be
2271          *    treated as non-separating.
2272          *  - a double-doublequote pair is a literal double quote, inside
2273          *    _or_ outside quotes. Like this:
2274          *
2275          *      firstword "second word" "this has ""quotes"" in" and""this""
2276          *
2277          * becomes
2278          *
2279          *      >firstword<
2280          *      >second word<
2281          *      >this has "quotes" in<
2282          *      >and"this"<
2283          */
2284         while (1) {
2285             /* skip whitespace */
2286             while (*p && (*p == ' ' || *p == '\t'))
2287                 p++;
2288             /* terminate loop */
2289             if (!*p)
2290                 break;
2291             /* mark start of word */
2292             q = r = p;                 /* q sits at start, r writes word */
2293             quoting = 0;
2294             while (*p) {
2295                 if (!quoting && (*p == ' ' || *p == '\t'))
2296                     break;                     /* reached end of word */
2297                 else if (*p == '"' && p[1] == '"')
2298                     p += 2, *r++ = '"';    /* a literal quote */
2299                 else if (*p == '"')
2300                     p++, quoting = !quoting;
2301                 else
2302                     *r++ = *p++;
2303             }
2304             if (*p)
2305                 p++;                   /* skip over the whitespace */
2306             *r = '\0';
2307             if (cmd->nwords >= cmd->wordssize) {
2308                 cmd->wordssize = cmd->nwords + 16;
2309                 cmd->words = sresize(cmd->words, cmd->wordssize, char *);
2310             }
2311             cmd->words[cmd->nwords++] = dupstr(q);
2312         }
2313     }
2314
2315     sfree(line);
2316
2317     /*
2318      * Now parse the first word and assign a function.
2319      */
2320
2321     if (cmd->nwords == 0)
2322         cmd->obey = sftp_cmd_null;
2323     else {
2324         const struct sftp_cmd_lookup *lookup;
2325         lookup = lookup_command(cmd->words[0]);
2326         if (!lookup)
2327             cmd->obey = sftp_cmd_unknown;
2328         else
2329             cmd->obey = lookup->obey;
2330     }
2331
2332     return cmd;
2333 }
2334
2335 static int do_sftp_init(void)
2336 {
2337     struct sftp_packet *pktin;
2338     struct sftp_request *req;
2339
2340     /*
2341      * Do protocol initialisation.
2342      */
2343     if (!fxp_init()) {
2344         fprintf(stderr,
2345                 "Fatal: unable to initialise SFTP: %s\n", fxp_error());
2346         return 1;                      /* failure */
2347     }
2348
2349     /*
2350      * Find out where our home directory is.
2351      */
2352     req = fxp_realpath_send(".");
2353     pktin = sftp_wait_for_reply(req);
2354     homedir = fxp_realpath_recv(pktin, req);
2355
2356     if (!homedir) {
2357         fprintf(stderr,
2358                 "Warning: failed to resolve home directory: %s\n",
2359                 fxp_error());
2360         homedir = dupstr(".");
2361     } else {
2362         printf("Remote working directory is %s\n", homedir);
2363     }
2364     pwd = dupstr(homedir);
2365     return 0;
2366 }
2367
2368 void do_sftp_cleanup()
2369 {
2370     char ch;
2371     if (back) {
2372         back->special(backhandle, TS_EOF);
2373         sent_eof = TRUE;
2374         sftp_recvdata(&ch, 1);
2375         back->free(backhandle);
2376         sftp_cleanup_request();
2377         back = NULL;
2378         backhandle = NULL;
2379     }
2380     if (pwd) {
2381         sfree(pwd);
2382         pwd = NULL;
2383     }
2384     if (homedir) {
2385         sfree(homedir);
2386         homedir = NULL;
2387     }
2388 }
2389
2390 void do_sftp(int mode, int modeflags, char *batchfile)
2391 {
2392     FILE *fp;
2393     int ret;
2394
2395     /*
2396      * Batch mode?
2397      */
2398     if (mode == 0) {
2399
2400         /* ------------------------------------------------------------------
2401          * Now we're ready to do Real Stuff.
2402          */
2403         while (1) {
2404             struct sftp_command *cmd;
2405             cmd = sftp_getcmd(NULL, 0, 0);
2406             if (!cmd)
2407                 break;
2408             ret = cmd->obey(cmd);
2409             if (cmd->words) {
2410                 int i;
2411                 for(i = 0; i < cmd->nwords; i++)
2412                     sfree(cmd->words[i]);
2413                 sfree(cmd->words);
2414             }
2415             sfree(cmd);
2416             if (ret < 0)
2417                 break;
2418         }
2419     } else {
2420         fp = fopen(batchfile, "r");
2421         if (!fp) {
2422             printf("Fatal: unable to open %s\n", batchfile);
2423             return;
2424         }
2425         while (1) {
2426             struct sftp_command *cmd;
2427             cmd = sftp_getcmd(fp, mode, modeflags);
2428             if (!cmd)
2429                 break;
2430             ret = cmd->obey(cmd);
2431             if (ret < 0)
2432                 break;
2433             if (ret == 0) {
2434                 if (!(modeflags & 2))
2435                     break;
2436             }
2437         }
2438         fclose(fp);
2439
2440     }
2441 }
2442
2443 /* ----------------------------------------------------------------------
2444  * Dirty bits: integration with PuTTY.
2445  */
2446
2447 static int verbose = 0;
2448
2449 /*
2450  *  Print an error message and perform a fatal exit.
2451  */
2452 void fatalbox(char *fmt, ...)
2453 {
2454     char *str, *str2;
2455     va_list ap;
2456     va_start(ap, fmt);
2457     str = dupvprintf(fmt, ap);
2458     str2 = dupcat("Fatal: ", str, "\n", NULL);
2459     sfree(str);
2460     va_end(ap);
2461     fputs(str2, stderr);
2462     sfree(str2);
2463
2464     cleanup_exit(1);
2465 }
2466 void modalfatalbox(char *fmt, ...)
2467 {
2468     char *str, *str2;
2469     va_list ap;
2470     va_start(ap, fmt);
2471     str = dupvprintf(fmt, ap);
2472     str2 = dupcat("Fatal: ", str, "\n", NULL);
2473     sfree(str);
2474     va_end(ap);
2475     fputs(str2, stderr);
2476     sfree(str2);
2477
2478     cleanup_exit(1);
2479 }
2480 void connection_fatal(void *frontend, char *fmt, ...)
2481 {
2482     char *str, *str2;
2483     va_list ap;
2484     va_start(ap, fmt);
2485     str = dupvprintf(fmt, ap);
2486     str2 = dupcat("Fatal: ", str, "\n", NULL);
2487     sfree(str);
2488     va_end(ap);
2489     fputs(str2, stderr);
2490     sfree(str2);
2491
2492     cleanup_exit(1);
2493 }
2494
2495 void ldisc_send(void *handle, char *buf, int len, int interactive)
2496 {
2497     /*
2498      * This is only here because of the calls to ldisc_send(NULL,
2499      * 0) in ssh.c. Nothing in PSFTP actually needs to use the
2500      * ldisc as an ldisc. So if we get called with any real data, I
2501      * want to know about it.
2502      */
2503     assert(len == 0);
2504 }
2505
2506 /*
2507  * In psftp, all agent requests should be synchronous, so this is a
2508  * never-called stub.
2509  */
2510 void agent_schedule_callback(void (*callback)(void *, void *, int),
2511                              void *callback_ctx, void *data, int len)
2512 {
2513     assert(!"We shouldn't be here");
2514 }
2515
2516 /*
2517  * Receive a block of data from the SSH link. Block until all data
2518  * is available.
2519  *
2520  * To do this, we repeatedly call the SSH protocol module, with our
2521  * own trap in from_backend() to catch the data that comes back. We
2522  * do this until we have enough data.
2523  */
2524
2525 static unsigned char *outptr;          /* where to put the data */
2526 static unsigned outlen;                /* how much data required */
2527 static unsigned char *pending = NULL;  /* any spare data */
2528 static unsigned pendlen = 0, pendsize = 0;      /* length and phys. size of buffer */
2529 int from_backend(void *frontend, int is_stderr, const char *data, int datalen)
2530 {
2531     unsigned char *p = (unsigned char *) data;
2532     unsigned len = (unsigned) datalen;
2533
2534     /*
2535      * stderr data is just spouted to local stderr and otherwise
2536      * ignored.
2537      */
2538     if (is_stderr) {
2539         if (len > 0)
2540             if (fwrite(data, 1, len, stderr) < len)
2541                 /* oh well */;
2542         return 0;
2543     }
2544
2545     /*
2546      * If this is before the real session begins, just return.
2547      */
2548     if (!outptr)
2549         return 0;
2550
2551     if ((outlen > 0) && (len > 0)) {
2552         unsigned used = outlen;
2553         if (used > len)
2554             used = len;
2555         memcpy(outptr, p, used);
2556         outptr += used;
2557         outlen -= used;
2558         p += used;
2559         len -= used;
2560     }
2561
2562     if (len > 0) {
2563         if (pendsize < pendlen + len) {
2564             pendsize = pendlen + len + 4096;
2565             pending = sresize(pending, pendsize, unsigned char);
2566         }
2567         memcpy(pending + pendlen, p, len);
2568         pendlen += len;
2569     }
2570
2571     return 0;
2572 }
2573 int from_backend_untrusted(void *frontend_handle, const char *data, int len)
2574 {
2575     /*
2576      * No "untrusted" output should get here (the way the code is
2577      * currently, it's all diverted by FLAG_STDERR).
2578      */
2579     assert(!"Unexpected call to from_backend_untrusted()");
2580     return 0; /* not reached */
2581 }
2582 int from_backend_eof(void *frontend)
2583 {
2584     /*
2585      * We expect to be the party deciding when to close the
2586      * connection, so if we see EOF before we sent it ourselves, we
2587      * should panic.
2588      */
2589     if (!sent_eof) {
2590         connection_fatal(frontend,
2591                          "Received unexpected end-of-file from SFTP server");
2592     }
2593     return FALSE;
2594 }
2595 int sftp_recvdata(char *buf, int len)
2596 {
2597     outptr = (unsigned char *) buf;
2598     outlen = len;
2599
2600     /*
2601      * See if the pending-input block contains some of what we
2602      * need.
2603      */
2604     if (pendlen > 0) {
2605         unsigned pendused = pendlen;
2606         if (pendused > outlen)
2607             pendused = outlen;
2608         memcpy(outptr, pending, pendused);
2609         memmove(pending, pending + pendused, pendlen - pendused);
2610         outptr += pendused;
2611         outlen -= pendused;
2612         pendlen -= pendused;
2613         if (pendlen == 0) {
2614             pendsize = 0;
2615             sfree(pending);
2616             pending = NULL;
2617         }
2618         if (outlen == 0)
2619             return 1;
2620     }
2621
2622     while (outlen > 0) {
2623         if (back->exitcode(backhandle) >= 0 || ssh_sftp_loop_iteration() < 0)
2624             return 0;                  /* doom */
2625     }
2626
2627     return 1;
2628 }
2629 int sftp_senddata(char *buf, int len)
2630 {
2631     back->send(backhandle, buf, len);
2632     return 1;
2633 }
2634
2635 /*
2636  *  Short description of parameters.
2637  */
2638 static void usage(void)
2639 {
2640     printf("PuTTY Secure File Transfer (SFTP) client\n");
2641     printf("%s\n", ver);
2642     printf("Usage: psftp [options] [user@]host\n");
2643     printf("Options:\n");
2644     printf("  -V        print version information and exit\n");
2645     printf("  -pgpfp    print PGP key fingerprints and exit\n");
2646     printf("  -b file   use specified batchfile\n");
2647     printf("  -bc       output batchfile commands\n");
2648     printf("  -be       don't stop batchfile processing if errors\n");
2649     printf("  -v        show verbose messages\n");
2650     printf("  -load sessname  Load settings from saved session\n");
2651     printf("  -l user   connect with specified username\n");
2652     printf("  -P port   connect to specified port\n");
2653     printf("  -pw passw login with specified password\n");
2654     printf("  -1 -2     force use of particular SSH protocol version\n");
2655     printf("  -4 -6     force use of IPv4 or IPv6\n");
2656     printf("  -C        enable compression\n");
2657     printf("  -i key    private key file for authentication\n");
2658     printf("  -noagent  disable use of Pageant\n");
2659     printf("  -agent    enable use of Pageant\n");
2660     printf("  -batch    disable all interactive prompts\n");
2661     cleanup_exit(1);
2662 }
2663
2664 static void version(void)
2665 {
2666   printf("psftp: %s\n", ver);
2667   cleanup_exit(1);
2668 }
2669
2670 /*
2671  * Connect to a host.
2672  */
2673 static int psftp_connect(char *userhost, char *user, int portnumber)
2674 {
2675     char *host, *realhost;
2676     const char *err;
2677     void *logctx;
2678
2679     /* Separate host and username */
2680     host = userhost;
2681     host = strrchr(host, '@');
2682     if (host == NULL) {
2683         host = userhost;
2684     } else {
2685         *host++ = '\0';
2686         if (user) {
2687             printf("psftp: multiple usernames specified; using \"%s\"\n",
2688                    user);
2689         } else
2690             user = userhost;
2691     }
2692
2693     /*
2694      * If we haven't loaded session details already (e.g., from -load),
2695      * try looking for a session called "host".
2696      */
2697     if (!loaded_session) {
2698         /* Try to load settings for `host' into a temporary config */
2699         Conf *conf2 = conf_new();
2700         conf_set_str(conf2, CONF_host, "");
2701         do_defaults(host, conf2);
2702         if (conf_get_str(conf2, CONF_host)[0] != '\0') {
2703             /* Settings present and include hostname */
2704             /* Re-load data into the real config. */
2705             do_defaults(host, conf);
2706         } else {
2707             /* Session doesn't exist or mention a hostname. */
2708             /* Use `host' as a bare hostname. */
2709             conf_set_str(conf, CONF_host, host);
2710         }
2711     } else {
2712         /* Patch in hostname `host' to session details. */
2713         conf_set_str(conf, CONF_host, host);
2714     }
2715
2716     /*
2717      * Force use of SSH. (If they got the protocol wrong we assume the
2718      * port is useless too.)
2719      */
2720     if (conf_get_int(conf, CONF_protocol) != PROT_SSH) {
2721         conf_set_int(conf, CONF_protocol, PROT_SSH);
2722         conf_set_int(conf, CONF_port, 22);
2723     }
2724
2725     /*
2726      * If saved session / Default Settings says SSH-1 (`1 only' or `1'),
2727      * then change it to SSH-2, on the grounds that that's more likely to
2728      * work for SFTP. (Can be overridden with `-1' option.)
2729      * But if it says `2 only' or `2', respect which.
2730      */
2731     if ((conf_get_int(conf, CONF_sshprot) & ~1) != 2)   /* is it 2 or 3? */
2732         conf_set_int(conf, CONF_sshprot, 2);
2733
2734     /*
2735      * Enact command-line overrides.
2736      */
2737     cmdline_run_saved(conf);
2738
2739     /*
2740      * Muck about with the hostname in various ways.
2741      */
2742     {
2743         char *hostbuf = dupstr(conf_get_str(conf, CONF_host));
2744         char *host = hostbuf;
2745         char *p, *q;
2746
2747         /*
2748          * Trim leading whitespace.
2749          */
2750         host += strspn(host, " \t");
2751
2752         /*
2753          * See if host is of the form user@host, and separate out
2754          * the username if so.
2755          */
2756         if (host[0] != '\0') {
2757             char *atsign = strrchr(host, '@');
2758             if (atsign) {
2759                 *atsign = '\0';
2760                 conf_set_str(conf, CONF_username, host);
2761                 host = atsign + 1;
2762             }
2763         }
2764
2765         /*
2766          * Remove any remaining whitespace.
2767          */
2768         p = hostbuf;
2769         q = host;
2770         while (*q) {
2771             if (*q != ' ' && *q != '\t')
2772                 *p++ = *q;
2773             q++;
2774         }
2775         *p = '\0';
2776
2777         conf_set_str(conf, CONF_host, hostbuf);
2778         sfree(hostbuf);
2779     }
2780
2781     /* Set username */
2782     if (user != NULL && user[0] != '\0') {
2783         conf_set_str(conf, CONF_username, user);
2784     }
2785
2786     if (portnumber)
2787         conf_set_int(conf, CONF_port, portnumber);
2788
2789     /*
2790      * Disable scary things which shouldn't be enabled for simple
2791      * things like SCP and SFTP: agent forwarding, port forwarding,
2792      * X forwarding.
2793      */
2794     conf_set_int(conf, CONF_x11_forward, 0);
2795     conf_set_int(conf, CONF_agentfwd, 0);
2796     conf_set_int(conf, CONF_ssh_simple, TRUE);
2797     {
2798         char *key;
2799         while ((key = conf_get_str_nthstrkey(conf, CONF_portfwd, 0)) != NULL)
2800             conf_del_str_str(conf, CONF_portfwd, key);
2801     }
2802
2803     /* Set up subsystem name. */
2804     conf_set_str(conf, CONF_remote_cmd, "sftp");
2805     conf_set_int(conf, CONF_ssh_subsys, TRUE);
2806     conf_set_int(conf, CONF_nopty, TRUE);
2807
2808     /*
2809      * Set up fallback option, for SSH-1 servers or servers with the
2810      * sftp subsystem not enabled but the server binary installed
2811      * in the usual place. We only support fallback on Unix
2812      * systems, and we use a kludgy piece of shellery which should
2813      * try to find sftp-server in various places (the obvious
2814      * systemwide spots /usr/lib and /usr/local/lib, and then the
2815      * user's PATH) and finally give up.
2816      *
2817      *   test -x /usr/lib/sftp-server && exec /usr/lib/sftp-server
2818      *   test -x /usr/local/lib/sftp-server && exec /usr/local/lib/sftp-server
2819      *   exec sftp-server
2820      *
2821      * the idea being that this will attempt to use either of the
2822      * obvious pathnames and then give up, and when it does give up
2823      * it will print the preferred pathname in the error messages.
2824      */
2825     conf_set_str(conf, CONF_remote_cmd2,
2826                  "test -x /usr/lib/sftp-server &&"
2827                  " exec /usr/lib/sftp-server\n"
2828                  "test -x /usr/local/lib/sftp-server &&"
2829                  " exec /usr/local/lib/sftp-server\n"
2830                  "exec sftp-server");
2831     conf_set_int(conf, CONF_ssh_subsys2, FALSE);
2832
2833     back = &ssh_backend;
2834
2835     err = back->init(NULL, &backhandle, conf,
2836                      conf_get_str(conf, CONF_host),
2837                      conf_get_int(conf, CONF_port),
2838                      &realhost, 0,
2839                      conf_get_int(conf, CONF_tcp_keepalives));
2840     if (err != NULL) {
2841         fprintf(stderr, "ssh_init: %s\n", err);
2842         return 1;
2843     }
2844     logctx = log_init(NULL, conf);
2845     back->provide_logctx(backhandle, logctx);
2846     console_provide_logctx(logctx);
2847     while (!back->sendok(backhandle)) {
2848         if (back->exitcode(backhandle) >= 0)
2849             return 1;
2850         if (ssh_sftp_loop_iteration() < 0) {
2851             fprintf(stderr, "ssh_init: error during SSH connection setup\n");
2852             return 1;
2853         }
2854     }
2855     if (verbose && realhost != NULL)
2856         printf("Connected to %s\n", realhost);
2857     if (realhost != NULL)
2858         sfree(realhost);
2859     return 0;
2860 }
2861
2862 void cmdline_error(char *p, ...)
2863 {
2864     va_list ap;
2865     fprintf(stderr, "psftp: ");
2866     va_start(ap, p);
2867     vfprintf(stderr, p, ap);
2868     va_end(ap);
2869     fprintf(stderr, "\n       try typing \"psftp -h\" for help\n");
2870     exit(1);
2871 }
2872
2873 /*
2874  * Main program. Parse arguments etc.
2875  */
2876 int psftp_main(int argc, char *argv[])
2877 {
2878     int i;
2879     int portnumber = 0;
2880     char *userhost, *user;
2881     int mode = 0;
2882     int modeflags = 0;
2883     char *batchfile = NULL;
2884
2885     flags = FLAG_STDERR | FLAG_INTERACTIVE
2886 #ifdef FLAG_SYNCAGENT
2887         | FLAG_SYNCAGENT
2888 #endif
2889         ;
2890     cmdline_tooltype = TOOLTYPE_FILETRANSFER;
2891     sk_init();
2892
2893     userhost = user = NULL;
2894
2895     /* Load Default Settings before doing anything else. */
2896     conf = conf_new();
2897     do_defaults(NULL, conf);
2898     loaded_session = FALSE;
2899
2900     for (i = 1; i < argc; i++) {
2901         int ret;
2902         if (argv[i][0] != '-') {
2903             if (userhost)
2904                 usage();
2905             else
2906                 userhost = dupstr(argv[i]);
2907             continue;
2908         }
2909         ret = cmdline_process_param(argv[i], i+1<argc?argv[i+1]:NULL, 1, conf);
2910         if (ret == -2) {
2911             cmdline_error("option \"%s\" requires an argument", argv[i]);
2912         } else if (ret == 2) {
2913             i++;               /* skip next argument */
2914         } else if (ret == 1) {
2915             /* We have our own verbosity in addition to `flags'. */
2916             if (flags & FLAG_VERBOSE)
2917                 verbose = 1;
2918         } else if (strcmp(argv[i], "-h") == 0 ||
2919                    strcmp(argv[i], "-?") == 0 ||
2920                    strcmp(argv[i], "--help") == 0) {
2921             usage();
2922         } else if (strcmp(argv[i], "-pgpfp") == 0) {
2923             pgp_fingerprints();
2924             return 1;
2925         } else if (strcmp(argv[i], "-V") == 0 ||
2926                    strcmp(argv[i], "--version") == 0) {
2927             version();
2928         } else if (strcmp(argv[i], "-batch") == 0) {
2929             console_batch_mode = 1;
2930         } else if (strcmp(argv[i], "-b") == 0 && i + 1 < argc) {
2931             mode = 1;
2932             batchfile = argv[++i];
2933         } else if (strcmp(argv[i], "-bc") == 0) {
2934             modeflags = modeflags | 1;
2935         } else if (strcmp(argv[i], "-be") == 0) {
2936             modeflags = modeflags | 2;
2937         } else if (strcmp(argv[i], "--") == 0) {
2938             i++;
2939             break;
2940         } else {
2941             cmdline_error("unknown option \"%s\"", argv[i]);
2942         }
2943     }
2944     argc -= i;
2945     argv += i;
2946     back = NULL;
2947
2948     /*
2949      * If the loaded session provides a hostname, and a hostname has not
2950      * otherwise been specified, pop it in `userhost' so that
2951      * `psftp -load sessname' is sufficient to start a session.
2952      */
2953     if (!userhost && conf_get_str(conf, CONF_host)[0] != '\0') {
2954         userhost = dupstr(conf_get_str(conf, CONF_host));
2955     }
2956
2957     /*
2958      * If a user@host string has already been provided, connect to
2959      * it now.
2960      */
2961     if (userhost) {
2962         int ret;
2963         ret = psftp_connect(userhost, user, portnumber);
2964         sfree(userhost);
2965         if (ret)
2966             return 1;
2967         if (do_sftp_init())
2968             return 1;
2969     } else {
2970         printf("psftp: no hostname specified; use \"open host.name\""
2971                " to connect\n");
2972     }
2973
2974     do_sftp(mode, modeflags, batchfile);
2975
2976     if (back != NULL && back->connected(backhandle)) {
2977         char ch;
2978         back->special(backhandle, TS_EOF);
2979         sent_eof = TRUE;
2980         sftp_recvdata(&ch, 1);
2981     }
2982     do_sftp_cleanup();
2983     random_save_seed();
2984     cmdline_cleanup();
2985     console_provide_logctx(NULL);
2986     sk_cleanup();
2987
2988     return 0;
2989 }