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