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