psftp.c

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