psftp.c

   1 /*
   2  * psftp.c: front end for PSFTP.
   3  */
   4
   5 #include <windows.h>
   6
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <stdarg.h>
  10 #include <assert.h>
  11 #include <limits.h>
  12
  13 #define PUTTY_DO_GLOBALS
  14 #include "putty.h"
  15 #include "storage.h"
  16 #include "ssh.h"
  17 #include "sftp.h"
  18 #include "int64.h"
  19
  20 /*
  21  * Since SFTP is a request-response oriented protocol, it requires
  22  * no buffer management: when we send data, we stop and wait for an
  23  * acknowledgement _anyway_, and so we can't possibly overfill our
  24  * send buffer.
  25  */
  26
  27 static int psftp_connect(char *userhost, char *user, int portnumber);
  28 static int do_sftp_init(void);
  29
  30 /* ----------------------------------------------------------------------
  31  * sftp client state.
  32  */
  33
  34 char *pwd, *homedir;
  35 static Backend *back;
  36 static void *backhandle;
  37
  38 /* ----------------------------------------------------------------------
  39  * Higher-level helper functions used in commands.
  40  */
  41
  42 /*
  43  * Attempt to canonify a pathname starting from the pwd. If
  44  * canonification fails, at least fall back to returning a _valid_
  45  * pathname (though it may be ugly, eg /home/simon/../foobar).
  46  */
  47 char *canonify(char *name)
  48 {
  49     char *fullname, *canonname;
  50
  51     if (name[0] == '/') {
  52         fullname = dupstr(name);
  53     } else {
  54         char *slash;
  55         if (pwd[strlen(pwd) - 1] == '/')
  56             slash = "";
  57         else
  58             slash = "/";
  59         fullname = dupcat(pwd, slash, name, NULL);
  60     }
  61
  62     canonname = fxp_realpath(fullname);
  63
  64     if (canonname) {
  65         sfree(fullname);
  66         return canonname;
  67     } else {
  68         /*
  69          * Attempt number 2. Some FXP_REALPATH implementations
  70          * (glibc-based ones, in particular) require the _whole_
  71          * path to point to something that exists, whereas others
  72          * (BSD-based) only require all but the last component to
  73          * exist. So if the first call failed, we should strip off
  74          * everything from the last slash onwards and try again,
  75          * then put the final component back on.
  76          *
  77          * Special cases:
  78          *
  79          *  - if the last component is "/." or "/..", then we don't
  80          *    bother trying this because there's no way it can work.
  81          *
  82          *  - if the thing actually ends with a "/", we remove it
  83          *    before we start. Except if the string is "/" itself
  84          *    (although I can't see why we'd have got here if so,
  85          *    because surely "/" would have worked the first
  86          *    time?), in which case we don't bother.
  87          *
  88          *  - if there's no slash in the string at all, give up in
  89          *    confusion (we expect at least one because of the way
  90          *    we constructed the string).
  91          */
  92
  93         int i;
  94         char *returnname;
  95
  96         i = strlen(fullname);
  97         if (i > 2 && fullname[i - 1] == '/')
  98             fullname[--i] = '\0';      /* strip trailing / unless at pos 0 */
  99         while (i > 0 && fullname[--i] != '/');
 100
 101         /*
 102          * Give up on special cases.
 103          */
 104         if (fullname[i] != '/' ||      /* no slash at all */
 105             !strcmp(fullname + i, "/.") ||      /* ends in /. */
 106             !strcmp(fullname + i, "/..") ||     /* ends in /.. */
 107             !strcmp(fullname, "/")) {
 108             return fullname;
 109         }
 110
 111         /*
 112          * Now i points at the slash. Deal with the final special
 113          * case i==0 (ie the whole path was "/nonexistentfile").
 114          */
 115         fullname[i] = '\0';            /* separate the string */
 116         if (i == 0) {
 117             canonname = fxp_realpath("/");
 118         } else {
 119             canonname = fxp_realpath(fullname);
 120         }
 121
 122         if (!canonname)
 123             return fullname;           /* even that failed; give up */
 124
 125         /*
 126          * We have a canonical name for all but the last path
 127          * component. Concatenate the last component and return.
 128          */
 129         returnname = dupcat(canonname,
 130                             canonname[strlen(canonname) - 1] ==
 131                             '/' ? "" : "/", fullname + i + 1, NULL);
 132         sfree(fullname);
 133         sfree(canonname);
 134         return returnname;
 135     }
 136 }
 137
 138 /*
 139  * Return a pointer to the portion of str that comes after the last
 140  * slash (or backslash or colon, if `local' is TRUE).
 141  */
 142 static char *stripslashes(char *str, int local)
 143 {
 144     char *p;
 145
 146     if (local) {
 147         p = strchr(str, ':');
 148         if (p) str = p+1;
 149     }
 150
 151     p = strrchr(str, '/');
 152     if (p) str = p+1;
 153
 154     if (local) {
 155         p = strrchr(str, '\\');
 156         if (p) str = p+1;
 157     }
 158
 159     return str;
 160 }
 161
 162 /* ----------------------------------------------------------------------
 163  * Actual sftp commands.
 164  */
 165 struct sftp_command {
 166     char **words;
 167     int nwords, wordssize;
 168     int (*obey) (struct sftp_command *);        /* returns <0 to quit */
 169 };
 170
 171 int sftp_cmd_null(struct sftp_command *cmd)
 172 {
 173     return 1;                          /* success */
 174 }
 175
 176 int sftp_cmd_unknown(struct sftp_command *cmd)
 177 {
 178     printf("psftp: unknown command \"%s\"\n", cmd->words[0]);
 179     return 0;                          /* failure */
 180 }
 181
 182 int sftp_cmd_quit(struct sftp_command *cmd)
 183 {
 184     return -1;
 185 }
 186
 187 /*
 188  * List a directory. If no arguments are given, list pwd; otherwise
 189  * list the directory given in words[1].
 190  */
 191 static int sftp_ls_compare(const void *av, const void *bv)
 192 {
 193     const struct fxp_name *const *a = (const struct fxp_name *const *) av;
 194     const struct fxp_name *const *b = (const struct fxp_name *const *) bv;
 195     return strcmp((*a)->filename, (*b)->filename);
 196 }
 197 int sftp_cmd_ls(struct sftp_command *cmd)
 198 {
 199     struct fxp_handle *dirh;
 200     struct fxp_names *names;
 201     struct fxp_name **ournames;
 202     int nnames, namesize;
 203     char *dir, *cdir;
 204     int i;
 205
 206     if (back == NULL) {
 207         printf("psftp: not connected to a host; use \"open host.name\"\n");
 208         return 0;
 209     }
 210
 211     if (cmd->nwords < 2)
 212         dir = ".";
 213     else
 214         dir = cmd->words[1];
 215
 216     cdir = canonify(dir);
 217     if (!cdir) {
 218         printf("%s: %s\n", dir, fxp_error());
 219         return 0;
 220     }
 221
 222     printf("Listing directory %s\n", cdir);
 223
 224     dirh = fxp_opendir(cdir);
 225     if (dirh == NULL) {
 226         printf("Unable to open %s: %s\n", dir, fxp_error());
 227     } else {
 228         nnames = namesize = 0;
 229         ournames = NULL;
 230
 231         while (1) {
 232
 233             names = fxp_readdir(dirh);
 234             if (names == NULL) {
 235                 if (fxp_error_type() == SSH_FX_EOF)
 236                     break;
 237                 printf("Reading directory %s: %s\n", dir, fxp_error());
 238                 break;
 239             }
 240             if (names->nnames == 0) {
 241                 fxp_free_names(names);
 242                 break;
 243             }
 244
 245             if (nnames + names->nnames >= namesize) {
 246                 namesize += names->nnames + 128;
 247                 ournames =
 248                     srealloc(ournames, namesize * sizeof(*ournames));
 249             }
 250
 251             for (i = 0; i < names->nnames; i++)
 252                 ournames[nnames++] = fxp_dup_name(&names->names[i]);
 253
 254             fxp_free_names(names);
 255         }
 256         fxp_close(dirh);
 257
 258         /*
 259          * Now we have our filenames. Sort them by actual file
 260          * name, and then output the longname parts.
 261          */
 262         qsort(ournames, nnames, sizeof(*ournames), sftp_ls_compare);
 263
 264         /*
 265          * And print them.
 266          */
 267         for (i = 0; i < nnames; i++) {
 268             printf("%s\n", ournames[i]->longname);
 269             fxp_free_name(ournames[i]);
 270         }
 271         sfree(ournames);
 272     }
 273
 274     sfree(cdir);
 275
 276     return 1;
 277 }
 278
 279 /*
 280  * Change directories. We do this by canonifying the new name, then
 281  * trying to OPENDIR it. Only if that succeeds do we set the new pwd.
 282  */
 283 int sftp_cmd_cd(struct sftp_command *cmd)
 284 {
 285     struct fxp_handle *dirh;
 286     char *dir;
 287
 288     if (back == NULL) {
 289         printf("psftp: not connected to a host; use \"open host.name\"\n");
 290         return 0;
 291     }
 292
 293     if (cmd->nwords < 2)
 294         dir = dupstr(homedir);
 295     else
 296         dir = canonify(cmd->words[1]);
 297
 298     if (!dir) {
 299         printf("%s: %s\n", dir, fxp_error());
 300         return 0;
 301     }
 302
 303     dirh = fxp_opendir(dir);
 304     if (!dirh) {
 305         printf("Directory %s: %s\n", dir, fxp_error());
 306         sfree(dir);
 307         return 0;
 308     }
 309
 310     fxp_close(dirh);
 311
 312     sfree(pwd);
 313     pwd = dir;
 314     printf("Remote directory is now %s\n", pwd);
 315
 316     return 1;
 317 }
 318
 319 /*
 320  * Print current directory. Easy as pie.
 321  */
 322 int sftp_cmd_pwd(struct sftp_command *cmd)
 323 {
 324     if (back == NULL) {
 325         printf("psftp: not connected to a host; use \"open host.name\"\n");
 326         return 0;
 327     }
 328
 329     printf("Remote directory is %s\n", pwd);
 330     return 1;
 331 }
 332
 333 /*
 334  * Get a file and save it at the local end. We have two very
 335  * similar commands here: `get' and `reget', which differ in that
 336  * `reget' checks for the existence of the destination file and
 337  * starts from where a previous aborted transfer left off.
 338  */
 339 int sftp_general_get(struct sftp_command *cmd, int restart)
 340 {
 341     struct fxp_handle *fh;
 342     char *fname, *outfname;
 343     uint64 offset;
 344     FILE *fp;
 345     int ret;
 346
 347     if (back == NULL) {
 348         printf("psftp: not connected to a host; use \"open host.name\"\n");
 349         return 0;
 350     }
 351
 352     if (cmd->nwords < 2) {
 353         printf("get: expects a filename\n");
 354         return 0;
 355     }
 356
 357     fname = canonify(cmd->words[1]);
 358     if (!fname) {
 359         printf("%s: %s\n", cmd->words[1], fxp_error());
 360         return 0;
 361     }
 362     outfname = (cmd->nwords == 2 ?
 363                 stripslashes(cmd->words[1], 0) : cmd->words[2]);
 364
 365     fh = fxp_open(fname, SSH_FXF_READ);
 366     if (!fh) {
 367         printf("%s: %s\n", fname, fxp_error());
 368         sfree(fname);
 369         return 0;
 370     }
 371
 372     if (restart) {
 373         fp = fopen(outfname, "rb+");
 374     } else {
 375         fp = fopen(outfname, "wb");
 376     }
 377
 378     if (!fp) {
 379         printf("local: unable to open %s\n", outfname);
 380         fxp_close(fh);
 381         sfree(fname);
 382         return 0;
 383     }
 384
 385     if (restart) {
 386         long posn;
 387         fseek(fp, 0L, SEEK_END);
 388         posn = ftell(fp);
 389         printf("reget: restarting at file position %ld\n", posn);
 390         offset = uint64_make(0, posn);
 391     } else {
 392         offset = uint64_make(0, 0);
 393     }
 394
 395     printf("remote:%s => local:%s\n", fname, outfname);
 396
 397     /*
 398      * FIXME: we can use FXP_FSTAT here to get the file size, and
 399      * thus put up a progress bar.
 400      */
 401     ret = 1;
 402     while (1) {
 403         char buffer[4096];
 404         int len;
 405         int wpos, wlen;
 406
 407         len = fxp_read(fh, buffer, offset, sizeof(buffer));
 408         if ((len == -1 && fxp_error_type() == SSH_FX_EOF) || len == 0)
 409             break;
 410         if (len == -1) {
 411             printf("error while reading: %s\n", fxp_error());
 412             ret = 0;
 413             break;
 414         }
 415
 416         wpos = 0;
 417         while (wpos < len) {
 418             wlen = fwrite(buffer, 1, len - wpos, fp);
 419             if (wlen <= 0) {
 420                 printf("error while writing local file\n");
 421                 ret = 0;
 422                 break;
 423             }
 424             wpos += wlen;
 425         }
 426         if (wpos < len) {              /* we had an error */
 427             ret = 0;
 428             break;
 429         }
 430         offset = uint64_add32(offset, len);
 431     }
 432
 433     fclose(fp);
 434     fxp_close(fh);
 435     sfree(fname);
 436
 437     return ret;
 438 }
 439 int sftp_cmd_get(struct sftp_command *cmd)
 440 {
 441     return sftp_general_get(cmd, 0);
 442 }
 443 int sftp_cmd_reget(struct sftp_command *cmd)
 444 {
 445     return sftp_general_get(cmd, 1);
 446 }
 447
 448 /*
 449  * Send a file and store it at the remote end. We have two very
 450  * similar commands here: `put' and `reput', which differ in that
 451  * `reput' checks for the existence of the destination file and
 452  * starts from where a previous aborted transfer left off.
 453  */
 454 int sftp_general_put(struct sftp_command *cmd, int restart)
 455 {
 456     struct fxp_handle *fh;
 457     char *fname, *origoutfname, *outfname;
 458     uint64 offset;
 459     FILE *fp;
 460     int ret;
 461
 462     if (back == NULL) {
 463         printf("psftp: not connected to a host; use \"open host.name\"\n");
 464         return 0;
 465     }
 466
 467     if (cmd->nwords < 2) {
 468         printf("put: expects a filename\n");
 469         return 0;
 470     }
 471
 472     fname = cmd->words[1];
 473     origoutfname = (cmd->nwords == 2 ?
 474                     stripslashes(cmd->words[1], 1) : cmd->words[2]);
 475     outfname = canonify(origoutfname);
 476     if (!outfname) {
 477         printf("%s: %s\n", origoutfname, fxp_error());
 478         return 0;
 479     }
 480
 481     fp = fopen(fname, "rb");
 482     if (!fp) {
 483         printf("local: unable to open %s\n", fname);
 484         sfree(outfname);
 485         return 0;
 486     }
 487     if (restart) {
 488         fh = fxp_open(outfname,
 489                       SSH_FXF_WRITE);
 490     } else {
 491         fh = fxp_open(outfname,
 492                       SSH_FXF_WRITE | SSH_FXF_CREAT | SSH_FXF_TRUNC);
 493     }
 494     if (!fh) {
 495         printf("%s: %s\n", outfname, fxp_error());
 496         sfree(outfname);
 497         return 0;
 498     }
 499
 500     if (restart) {
 501         char decbuf[30];
 502         struct fxp_attrs attrs;
 503         if (!fxp_fstat(fh, &attrs)) {
 504             printf("read size of %s: %s\n", outfname, fxp_error());
 505             sfree(outfname);
 506             return 0;
 507         }
 508         if (!(attrs.flags & SSH_FILEXFER_ATTR_SIZE)) {
 509             printf("read size of %s: size was not given\n", outfname);
 510             sfree(outfname);
 511             return 0;
 512         }
 513         offset = attrs.size;
 514         uint64_decimal(offset, decbuf);
 515         printf("reput: restarting at file position %s\n", decbuf);
 516         if (uint64_compare(offset, uint64_make(0, LONG_MAX)) > 0) {
 517             printf("reput: remote file is larger than we can deal with\n");
 518             sfree(outfname);
 519             return 0;
 520         }
 521         if (fseek(fp, offset.lo, SEEK_SET) != 0)
 522             fseek(fp, 0, SEEK_END);    /* *shrug* */
 523     } else {
 524         offset = uint64_make(0, 0);
 525     }
 526
 527     printf("local:%s => remote:%s\n", fname, outfname);
 528
 529     /*
 530      * FIXME: we can use FXP_FSTAT here to get the file size, and
 531      * thus put up a progress bar.
 532      */
 533     ret = 1;
 534     while (1) {
 535         char buffer[4096];
 536         int len;
 537
 538         len = fread(buffer, 1, sizeof(buffer), fp);
 539         if (len == -1) {
 540             printf("error while reading local file\n");
 541             ret = 0;
 542             break;
 543         } else if (len == 0) {
 544             break;
 545         }
 546         if (!fxp_write(fh, buffer, offset, len)) {
 547             printf("error while writing: %s\n", fxp_error());
 548             ret = 0;
 549             break;
 550         }
 551         offset = uint64_add32(offset, len);
 552     }
 553
 554     fxp_close(fh);
 555     fclose(fp);
 556     sfree(outfname);
 557
 558     return ret;
 559 }
 560 int sftp_cmd_put(struct sftp_command *cmd)
 561 {
 562     return sftp_general_put(cmd, 0);
 563 }
 564 int sftp_cmd_reput(struct sftp_command *cmd)
 565 {
 566     return sftp_general_put(cmd, 1);
 567 }
 568
 569 int sftp_cmd_mkdir(struct sftp_command *cmd)
 570 {
 571     char *dir;
 572     int result;
 573
 574     if (back == NULL) {
 575         printf("psftp: not connected to a host; use \"open host.name\"\n");
 576         return 0;
 577     }
 578
 579     if (cmd->nwords < 2) {
 580         printf("mkdir: expects a directory\n");
 581         return 0;
 582     }
 583
 584     dir = canonify(cmd->words[1]);
 585     if (!dir) {
 586         printf("%s: %s\n", dir, fxp_error());
 587         return 0;
 588     }
 589
 590     result = fxp_mkdir(dir);
 591     if (!result) {
 592         printf("mkdir %s: %s\n", dir, fxp_error());
 593         sfree(dir);
 594         return 0;
 595     }
 596
 597     sfree(dir);
 598     return 1;
 599 }
 600
 601 int sftp_cmd_rmdir(struct sftp_command *cmd)
 602 {
 603     char *dir;
 604     int result;
 605
 606     if (back == NULL) {
 607         printf("psftp: not connected to a host; use \"open host.name\"\n");
 608         return 0;
 609     }
 610
 611     if (cmd->nwords < 2) {
 612         printf("rmdir: expects a directory\n");
 613         return 0;
 614     }
 615
 616     dir = canonify(cmd->words[1]);
 617     if (!dir) {
 618         printf("%s: %s\n", dir, fxp_error());
 619         return 0;
 620     }
 621
 622     result = fxp_rmdir(dir);
 623     if (!result) {
 624         printf("rmdir %s: %s\n", dir, fxp_error());
 625         sfree(dir);
 626         return 0;
 627     }
 628
 629     sfree(dir);
 630     return 1;
 631 }
 632
 633 int sftp_cmd_rm(struct sftp_command *cmd)
 634 {
 635     char *fname;
 636     int result;
 637
 638     if (back == NULL) {
 639         printf("psftp: not connected to a host; use \"open host.name\"\n");
 640         return 0;
 641     }
 642
 643     if (cmd->nwords < 2) {
 644         printf("rm: expects a filename\n");
 645         return 0;
 646     }
 647
 648     fname = canonify(cmd->words[1]);
 649     if (!fname) {
 650         printf("%s: %s\n", fname, fxp_error());
 651         return 0;
 652     }
 653
 654     result = fxp_remove(fname);
 655     if (!result) {
 656         printf("rm %s: %s\n", fname, fxp_error());
 657         sfree(fname);
 658         return 0;
 659     }
 660
 661     sfree(fname);
 662     return 1;
 663 }
 664
 665 int sftp_cmd_mv(struct sftp_command *cmd)
 666 {
 667     char *srcfname, *dstfname;
 668     int result;
 669
 670     if (back == NULL) {
 671         printf("psftp: not connected to a host; use \"open host.name\"\n");
 672         return 0;
 673     }
 674
 675     if (cmd->nwords < 3) {
 676         printf("mv: expects two filenames\n");
 677         return 0;
 678     }
 679     srcfname = canonify(cmd->words[1]);
 680     if (!srcfname) {
 681         printf("%s: %s\n", srcfname, fxp_error());
 682         return 0;
 683     }
 684
 685     dstfname = canonify(cmd->words[2]);
 686     if (!dstfname) {
 687         printf("%s: %s\n", dstfname, fxp_error());
 688         return 0;
 689     }
 690
 691     result = fxp_rename(srcfname, dstfname);
 692     if (!result) {
 693         char const *error = fxp_error();
 694         struct fxp_attrs attrs;
 695
 696         /*
 697          * The move might have failed because dstfname pointed at a
 698          * directory. We check this possibility now: if dstfname
 699          * _is_ a directory, we re-attempt the move by appending
 700          * the basename of srcfname to dstfname.
 701          */
 702         result = fxp_stat(dstfname, &attrs);
 703         if (result &&
 704             (attrs.flags & SSH_FILEXFER_ATTR_PERMISSIONS) &&
 705             (attrs.permissions & 0040000)) {
 706             char *p;
 707             char *newname, *newcanon;
 708             printf("(destination %s is a directory)\n", dstfname);
 709             p = srcfname + strlen(srcfname);
 710             while (p > srcfname && p[-1] != '/') p--;
 711             newname = dupcat(dstfname, "/", p, NULL);
 712             newcanon = canonify(newname);
 713             sfree(newname);
 714             if (newcanon) {
 715                 sfree(dstfname);
 716                 dstfname = newcanon;
 717                 result = fxp_rename(srcfname, dstfname);
 718                 error = result ? NULL : fxp_error();
 719             }
 720         }
 721         if (error) {
 722             printf("mv %s %s: %s\n", srcfname, dstfname, error);
 723             sfree(srcfname);
 724             sfree(dstfname);
 725             return 0;
 726         }
 727     }
 728     printf("%s -> %s\n", srcfname, dstfname);
 729
 730     sfree(srcfname);
 731     sfree(dstfname);
 732     return 1;
 733 }
 734
 735 int sftp_cmd_chmod(struct sftp_command *cmd)
 736 {
 737     char *fname, *mode;
 738     int result;
 739     struct fxp_attrs attrs;
 740     unsigned attrs_clr, attrs_xor, oldperms, newperms;
 741
 742     if (back == NULL) {
 743         printf("psftp: not connected to a host; use \"open host.name\"\n");
 744         return 0;
 745     }
 746
 747     if (cmd->nwords < 3) {
 748         printf("chmod: expects a mode specifier and a filename\n");
 749         return 0;
 750     }
 751
 752     /*
 753      * Attempt to parse the mode specifier in cmd->words[1]. We
 754      * don't support the full horror of Unix chmod; instead we
 755      * support a much simpler syntax in which the user can either
 756      * specify an octal number, or a comma-separated sequence of
 757      * [ugoa]*[-+=][rwxst]+. (The initial [ugoa] sequence may
 758      * _only_ be omitted if the only attribute mentioned is t,
 759      * since all others require a user/group/other specification.
 760      * Additionally, the s attribute may not be specified for any
 761      * [ugoa] specifications other than exactly u or exactly g.
 762      */
 763     attrs_clr = attrs_xor = 0;
 764     mode = cmd->words[1];
 765     if (mode[0] >= '0' && mode[0] <= '9') {
 766         if (mode[strspn(mode, "01234567")]) {
 767             printf("chmod: numeric file modes should"
 768                    " contain digits 0-7 only\n");
 769             return 0;
 770         }
 771         attrs_clr = 07777;
 772         sscanf(mode, "%o", &attrs_xor);
 773         attrs_xor &= attrs_clr;
 774     } else {
 775         while (*mode) {
 776             char *modebegin = mode;
 777             unsigned subset, perms;
 778             int action;
 779
 780             subset = 0;
 781             while (*mode && *mode != ',' &&
 782                    *mode != '+' && *mode != '-' && *mode != '=') {
 783                 switch (*mode) {
 784                   case 'u': subset |= 04700; break; /* setuid, user perms */
 785                   case 'g': subset |= 02070; break; /* setgid, group perms */
 786                   case 'o': subset |= 00007; break; /* just other perms */
 787                   case 'a': subset |= 06777; break; /* all of the above */
 788                   default:
 789                     printf("chmod: file mode '%.*s' contains unrecognised"
 790                            " user/group/other specifier '%c'\n",
 791                            strcspn(modebegin, ","), modebegin, *mode);
 792                     return 0;
 793                 }
 794                 mode++;
 795             }
 796             if (!*mode || *mode == ',') {
 797                 printf("chmod: file mode '%.*s' is incomplete\n",
 798                        strcspn(modebegin, ","), modebegin);
 799                 return 0;
 800             }
 801             action = *mode++;
 802             if (!*mode || *mode == ',') {
 803                 printf("chmod: file mode '%.*s' is incomplete\n",
 804                        strcspn(modebegin, ","), modebegin);
 805                 return 0;
 806             }
 807             perms = 0;
 808             while (*mode && *mode != ',') {
 809                 switch (*mode) {
 810                   case 'r': perms |= 00444; break;
 811                   case 'w': perms |= 00222; break;
 812                   case 'x': perms |= 00111; break;
 813                   case 't': perms |= 01000; subset |= 01000; break;
 814                   case 's':
 815                     if ((subset & 06777) != 04700 &&
 816                         (subset & 06777) != 02070) {
 817                         printf("chmod: file mode '%.*s': set[ug]id bit should"
 818                                " be used with exactly one of u or g only\n",
 819                                strcspn(modebegin, ","), modebegin);
 820                         return 0;
 821                     }
 822                     perms |= 06000;
 823                     break;
 824                   default:
 825                     printf("chmod: file mode '%.*s' contains unrecognised"
 826                            " permission specifier '%c'\n",
 827                            strcspn(modebegin, ","), modebegin, *mode);
 828                     return 0;
 829                 }
 830                 mode++;
 831             }
 832             if (!(subset & 06777) && (perms &~ subset)) {
 833                 printf("chmod: file mode '%.*s' contains no user/group/other"
 834                        " specifier and permissions other than 't' \n",
 835                        strcspn(modebegin, ","), modebegin);
 836                 return 0;
 837             }
 838             perms &= subset;
 839             switch (action) {
 840               case '+':
 841                 attrs_clr |= perms;
 842                 attrs_xor |= perms;
 843                 break;
 844               case '-':
 845                 attrs_clr |= perms;
 846                 attrs_xor &= ~perms;
 847                 break;
 848               case '=':
 849                 attrs_clr |= subset;
 850                 attrs_xor |= perms;
 851                 break;
 852             }
 853             if (*mode) mode++;         /* eat comma */
 854         }
 855     }
 856
 857     fname = canonify(cmd->words[2]);
 858     if (!fname) {
 859         printf("%s: %s\n", fname, fxp_error());
 860         return 0;
 861     }
 862
 863     result = fxp_stat(fname, &attrs);
 864     if (!result || !(attrs.flags & SSH_FILEXFER_ATTR_PERMISSIONS)) {
 865         printf("get attrs for %s: %s\n", fname,
 866                result ? "file permissions not provided" : fxp_error());
 867         sfree(fname);
 868         return 0;
 869     }
 870
 871     attrs.flags = SSH_FILEXFER_ATTR_PERMISSIONS;   /* perms _only_ */
 872     oldperms = attrs.permissions & 07777;
 873     attrs.permissions &= ~attrs_clr;
 874     attrs.permissions ^= attrs_xor;
 875     newperms = attrs.permissions & 07777;
 876
 877     result = fxp_setstat(fname, attrs);
 878
 879     if (!result) {
 880         printf("set attrs for %s: %s\n", fname, fxp_error());
 881         sfree(fname);
 882         return 0;
 883     }
 884
 885     printf("%s: %04o -> %04o\n", fname, oldperms, newperms);
 886
 887     sfree(fname);
 888     return 1;
 889 }
 890
 891 static int sftp_cmd_open(struct sftp_command *cmd)
 892 {
 893     if (back != NULL) {
 894         printf("psftp: already connected\n");
 895         return 0;
 896     }
 897
 898     if (cmd->nwords < 2) {
 899         printf("open: expects a host name\n");
 900         return 0;
 901     }
 902
 903     if (psftp_connect(cmd->words[1], NULL, 0)) {
 904         back = NULL;                   /* connection is already closed */
 905         return -1;                     /* this is fatal */
 906     }
 907     do_sftp_init();
 908     return 1;
 909 }
 910
 911 static int sftp_cmd_lcd(struct sftp_command *cmd)
 912 {
 913     char *currdir;
 914     int len;
 915
 916     if (cmd->nwords < 2) {
 917         printf("lcd: expects a local directory name\n");
 918         return 0;
 919     }
 920
 921     if (!SetCurrentDirectory(cmd->words[1])) {
 922         LPVOID message;
 923         int i;
 924         FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
 925                       FORMAT_MESSAGE_FROM_SYSTEM |
 926                       FORMAT_MESSAGE_IGNORE_INSERTS,
 927                       NULL, GetLastError(),
 928                       MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 929                       (LPTSTR)&message, 0, NULL);
 930         i = strcspn((char *)message, "\n");
 931         printf("lcd: unable to change directory: %.*s\n", i, (LPCTSTR)message);
 932         LocalFree(message);
 933         return 0;
 934     }
 935
 936     currdir = smalloc(256);
 937     len = GetCurrentDirectory(256, currdir);
 938     if (len > 256)
 939         currdir = srealloc(currdir, len);
 940     GetCurrentDirectory(len, currdir);
 941     printf("New local directory is %s\n", currdir);
 942     sfree(currdir);
 943
 944     return 1;
 945 }
 946
 947 static int sftp_cmd_lpwd(struct sftp_command *cmd)
 948 {
 949     char *currdir;
 950     int len;
 951
 952     currdir = smalloc(256);
 953     len = GetCurrentDirectory(256, currdir);
 954     if (len > 256)
 955         currdir = srealloc(currdir, len);
 956     GetCurrentDirectory(len, currdir);
 957     printf("Current local directory is %s\n", currdir);
 958     sfree(currdir);
 959
 960     return 1;
 961 }
 962
 963 static int sftp_cmd_pling(struct sftp_command *cmd)
 964 {
 965     int exitcode;
 966
 967     exitcode = system(cmd->words[1]);
 968     return (exitcode == 0);
 969 }
 970
 971 static int sftp_cmd_help(struct sftp_command *cmd);
 972
 973 static struct sftp_cmd_lookup {
 974     char *name;
 975     /*
 976      * For help purposes, there are two kinds of command:
 977      *
 978      *  - primary commands, in which `longhelp' is non-NULL. In
 979      *    this case `shorthelp' is descriptive text, and `longhelp'
 980      *    is longer descriptive text intended to be printed after
 981      *    the command name.
 982      *
 983      *  - alias commands, in which `longhelp' is NULL. In this case
 984      *    `shorthelp' is the name of a primary command, which
 985      *    contains the help that should double up for this command.
 986      */
 987     int listed;                        /* do we list this in primary help? */
 988     char *shorthelp;
 989     char *longhelp;
 990     int (*obey) (struct sftp_command *);
 991 } sftp_lookup[] = {
 992     /*
 993      * List of sftp commands. This is binary-searched so it MUST be
 994      * in ASCII order.
 995      */
 996     {
 997         "!", TRUE, "run a local Windows command",
 998             "<command>\n"
 999             "  Runs a local Windows command. For example, \"!del myfile\".\n",
1000             sftp_cmd_pling
1001     },
1002     {
1003         "bye", TRUE, "finish your SFTP session",
1004             "\n"
1005             "  Terminates your SFTP session and quits the PSFTP program.\n",
1006             sftp_cmd_quit
1007     },
1008     {
1009         "cd", TRUE, "change your remote working directory",
1010             " [ <New working directory> ]\n"
1011             "  Change the remote working directory for your SFTP session.\n"
1012             "  If a new working directory is not supplied, you will be\n"
1013             "  returned to your home directory.\n",
1014             sftp_cmd_cd
1015     },
1016     {
1017         "chmod", TRUE, "change file permissions and modes",
1018             " ( <octal-digits> | <modifiers> ) <filename>\n"
1019             "  Change the file permissions on a file or directory.\n"
1020             "  <octal-digits> can be any octal Unix permission specifier.\n"
1021             "  Alternatively, <modifiers> can include:\n"
1022             "    u+r     make file readable by owning user\n"
1023             "    u+w     make file writable by owning user\n"
1024             "    u+x     make file executable by owning user\n"
1025             "    u-r     make file not readable by owning user\n"
1026             "    [also u-w, u-x]\n"
1027             "    g+r     make file readable by members of owning group\n"
1028             "    [also g+w, g+x, g-r, g-w, g-x]\n"
1029             "    o+r     make file readable by all other users\n"
1030             "    [also o+w, o+x, o-r, o-w, o-x]\n"
1031             "    a+r     make file readable by absolutely everybody\n"
1032             "    [also a+w, a+x, a-r, a-w, a-x]\n"
1033             "    u+s     enable the Unix set-user-ID bit\n"
1034             "    u-s     disable the Unix set-user-ID bit\n"
1035             "    g+s     enable the Unix set-group-ID bit\n"
1036             "    g-s     disable the Unix set-group-ID bit\n"
1037             "    +t      enable the Unix \"sticky bit\"\n"
1038             "  You can give more than one modifier for the same user (\"g-rwx\"), and\n"
1039             "  more than one user for the same modifier (\"ug+w\"). You can\n"
1040             "  use commas to separate different modifiers (\"u+rwx,g+s\").\n",
1041             sftp_cmd_chmod
1042     },
1043     {
1044         "del", TRUE, "delete a file",
1045             " <filename>\n"
1046             "  Delete a file.\n",
1047             sftp_cmd_rm
1048     },
1049     {
1050         "delete", FALSE, "del", NULL, sftp_cmd_rm
1051     },
1052     {
1053         "dir", TRUE, "list contents of a remote directory",
1054             " [ <directory-name> ]\n"
1055             "  List the contents of a specified directory on the server.\n"
1056             "  If <directory-name> is not given, the current working directory\n"
1057             "  will be listed.\n",
1058             sftp_cmd_ls
1059     },
1060     {
1061         "exit", TRUE, "bye", NULL, sftp_cmd_quit
1062     },
1063     {
1064         "get", TRUE, "download a file from the server to your local machine",
1065             " <filename> [ <local-filename> ]\n"
1066             "  Downloads a file on the server and stores it locally under\n"
1067             "  the same name, or under a different one if you supply the\n"
1068             "  argument <local-filename>.\n",
1069             sftp_cmd_get
1070     },
1071     {
1072         "help", TRUE, "give help",
1073             " [ <command> [ <command> ... ] ]\n"
1074             "  Give general help if no commands are specified.\n"
1075             "  If one or more commands are specified, give specific help on\n"
1076             "  those particular commands.\n",
1077             sftp_cmd_help
1078     },
1079     {
1080         "lcd", TRUE, "change local working directory",
1081             " <local-directory-name>\n"
1082             "  Change the local working directory of the PSFTP program (the\n"
1083             "  default location where the \"get\" command will save files).\n",
1084             sftp_cmd_lcd
1085     },
1086     {
1087         "lpwd", TRUE, "print local working directory",
1088             "\n"
1089             "  Print the local working directory of the PSFTP program (the\n"
1090             "  default location where the \"get\" command will save files).\n",
1091             sftp_cmd_lpwd
1092     },
1093     {
1094         "ls", TRUE, "dir", NULL,
1095             sftp_cmd_ls
1096     },
1097     {
1098         "mkdir", TRUE, "create a directory on the remote server",
1099             " <directory-name>\n"
1100             "  Creates a directory with the given name on the server.\n",
1101             sftp_cmd_mkdir
1102     },
1103     {
1104         "mv", TRUE, "move or rename a file on the remote server",
1105             " <source-filename> <destination-filename>\n"
1106             "  Moves or renames the file <source-filename> on the server,\n"
1107             "  so that it is accessible under the name <destination-filename>.\n",
1108             sftp_cmd_mv
1109     },
1110     {
1111         "open", TRUE, "connect to a host",
1112             " [<user>@]<hostname>\n"
1113             "  Establishes an SFTP connection to a given host. Only usable\n"
1114             "  when you did not already specify a host name on the command\n"
1115             "  line.\n",
1116             sftp_cmd_open
1117     },
1118     {
1119         "put", TRUE, "upload a file from your local machine to the server",
1120             " <filename> [ <remote-filename> ]\n"
1121             "  Uploads a file to the server and stores it there under\n"
1122             "  the same name, or under a different one if you supply the\n"
1123             "  argument <remote-filename>.\n",
1124             sftp_cmd_put
1125     },
1126     {
1127         "pwd", TRUE, "print your remote working directory",
1128             "\n"
1129             "  Print the current remote working directory for your SFTP session.\n",
1130             sftp_cmd_pwd
1131     },
1132     {
1133         "quit", TRUE, "bye", NULL,
1134             sftp_cmd_quit
1135     },
1136     {
1137         "reget", TRUE, "continue downloading a file",
1138             " <filename> [ <local-filename> ]\n"
1139             "  Works exactly like the \"get\" command, but the local file\n"
1140             "  must already exist. The download will begin at the end of the\n"
1141             "  file. This is for resuming a download that was interrupted.\n",
1142             sftp_cmd_reget
1143     },
1144     {
1145         "ren", TRUE, "mv", NULL,
1146             sftp_cmd_mv
1147     },
1148     {
1149         "rename", FALSE, "mv", NULL,
1150             sftp_cmd_mv
1151     },
1152     {
1153         "reput", TRUE, "continue uploading a file",
1154             " <filename> [ <remote-filename> ]\n"
1155             "  Works exactly like the \"put\" command, but the remote file\n"
1156             "  must already exist. The upload will begin at the end of the\n"
1157             "  file. This is for resuming an upload that was interrupted.\n",
1158             sftp_cmd_reput
1159     },
1160     {
1161         "rm", TRUE, "del", NULL,
1162             sftp_cmd_rm
1163     },
1164     {
1165         "rmdir", TRUE, "remove a directory on the remote server",
1166             " <directory-name>\n"
1167             "  Removes the directory with the given name on the server.\n"
1168             "  The directory will not be removed unless it is empty.\n",
1169             sftp_cmd_rmdir
1170     }
1171 };
1172
1173 const struct sftp_cmd_lookup *lookup_command(char *name)
1174 {
1175     int i, j, k, cmp;
1176
1177     i = -1;
1178     j = sizeof(sftp_lookup) / sizeof(*sftp_lookup);
1179     while (j - i > 1) {
1180         k = (j + i) / 2;
1181         cmp = strcmp(name, sftp_lookup[k].name);
1182         if (cmp < 0)
1183             j = k;
1184         else if (cmp > 0)
1185             i = k;
1186         else {
1187             return &sftp_lookup[k];
1188         }
1189     }
1190     return NULL;
1191 }
1192
1193 static int sftp_cmd_help(struct sftp_command *cmd)
1194 {
1195     int i;
1196     if (cmd->nwords == 1) {
1197         /*
1198          * Give short help on each command.
1199          */
1200         int maxlen;
1201         maxlen = 0;
1202         for (i = 0; i < sizeof(sftp_lookup) / sizeof(*sftp_lookup); i++) {
1203             int len;
1204             if (!sftp_lookup[i].listed)
1205                 continue;
1206             len = strlen(sftp_lookup[i].name);
1207             if (maxlen < len)
1208                 maxlen = len;
1209         }
1210         for (i = 0; i < sizeof(sftp_lookup) / sizeof(*sftp_lookup); i++) {
1211             const struct sftp_cmd_lookup *lookup;
1212             if (!sftp_lookup[i].listed)
1213                 continue;
1214             lookup = &sftp_lookup[i];
1215             printf("%-*s", maxlen+2, lookup->name);
1216             if (lookup->longhelp == NULL)
1217                 lookup = lookup_command(lookup->shorthelp);
1218             printf("%s\n", lookup->shorthelp);
1219         }
1220     } else {
1221         /*
1222          * Give long help on specific commands.
1223          */
1224         for (i = 1; i < cmd->nwords; i++) {
1225             const struct sftp_cmd_lookup *lookup;
1226             lookup = lookup_command(cmd->words[i]);
1227             if (!lookup) {
1228                 printf("help: %s: command not found\n", cmd->words[i]);
1229             } else {
1230                 printf("%s", lookup->name);
1231                 if (lookup->longhelp == NULL)
1232                     lookup = lookup_command(lookup->shorthelp);
1233                 printf("%s", lookup->longhelp);
1234             }
1235         }
1236     }
1237     return 1;
1238 }
1239
1240 /* ----------------------------------------------------------------------
1241  * Command line reading and parsing.
1242  */
1243 struct sftp_command *sftp_getcmd(FILE *fp, int mode, int modeflags)
1244 {
1245     char *line;
1246     int linelen, linesize;
1247     struct sftp_command *cmd;
1248     char *p, *q, *r;
1249     int quoting;
1250
1251     if ((mode == 0) || (modeflags & 1)) {
1252         printf("psftp> ");
1253     }
1254     fflush(stdout);
1255
1256     cmd = smalloc(sizeof(struct sftp_command));
1257     cmd->words = NULL;
1258     cmd->nwords = 0;
1259     cmd->wordssize = 0;
1260
1261     line = NULL;
1262     linesize = linelen = 0;
1263     while (1) {
1264         int len;
1265         char *ret;
1266
1267         linesize += 512;
1268         line = srealloc(line, linesize);
1269         ret = fgets(line + linelen, linesize - linelen, fp);
1270
1271         if (!ret || (linelen == 0 && line[0] == '\0')) {
1272             cmd->obey = sftp_cmd_quit;
1273             if ((mode == 0) || (modeflags & 1))
1274                 printf("quit\n");
1275             return cmd;                /* eof */
1276         }
1277         len = linelen + strlen(line + linelen);
1278         linelen += len;
1279         if (line[linelen - 1] == '\n') {
1280             linelen--;
1281             line[linelen] = '\0';
1282             break;
1283         }
1284     }
1285     if (modeflags & 1) {
1286         printf("%s\n", line);
1287     }
1288
1289     p = line;
1290     while (*p && (*p == ' ' || *p == '\t'))
1291         p++;
1292
1293     if (*p == '!') {
1294         /*
1295          * Special case: the ! command. This is always parsed as
1296          * exactly two words: one containing the !, and the second
1297          * containing everything else on the line.
1298          */
1299         cmd->nwords = cmd->wordssize = 2;
1300         cmd->words = srealloc(cmd->words, cmd->wordssize * sizeof(char *));
1301         cmd->words[0] = "!";
1302         cmd->words[1] = p+1;
1303     } else {
1304
1305         /*
1306          * Parse the command line into words. The syntax is:
1307          *  - double quotes are removed, but cause spaces within to be
1308          *    treated as non-separating.
1309          *  - a double-doublequote pair is a literal double quote, inside
1310          *    _or_ outside quotes. Like this:
1311          *
1312          *      firstword "second word" "this has ""quotes"" in" and""this""
1313          *
1314          * becomes
1315          *
1316          *      >firstword<
1317          *      >second word<
1318          *      >this has "quotes" in<
1319          *      >and"this"<
1320          */
1321         while (*p) {
1322             /* skip whitespace */
1323             while (*p && (*p == ' ' || *p == '\t'))
1324                 p++;
1325             /* mark start of word */
1326             q = r = p;                 /* q sits at start, r writes word */
1327             quoting = 0;
1328             while (*p) {
1329                 if (!quoting && (*p == ' ' || *p == '\t'))
1330                     break;                     /* reached end of word */
1331                 else if (*p == '"' && p[1] == '"')
1332                     p += 2, *r++ = '"';    /* a literal quote */
1333                 else if (*p == '"')
1334                     p++, quoting = !quoting;
1335                 else
1336                     *r++ = *p++;
1337             }
1338             if (*p)
1339                 p++;                   /* skip over the whitespace */
1340             *r = '\0';
1341             if (cmd->nwords >= cmd->wordssize) {
1342                 cmd->wordssize = cmd->nwords + 16;
1343                 cmd->words =
1344                     srealloc(cmd->words, cmd->wordssize * sizeof(char *));
1345             }
1346             cmd->words[cmd->nwords++] = q;
1347         }
1348     }
1349
1350     /*
1351      * Now parse the first word and assign a function.
1352      */
1353
1354     if (cmd->nwords == 0)
1355         cmd->obey = sftp_cmd_null;
1356     else {
1357         const struct sftp_cmd_lookup *lookup;
1358         lookup = lookup_command(cmd->words[0]);
1359         if (!lookup)
1360             cmd->obey = sftp_cmd_unknown;
1361         else
1362             cmd->obey = lookup->obey;
1363     }
1364
1365     return cmd;
1366 }
1367
1368 static int do_sftp_init(void)
1369 {
1370     /*
1371      * Do protocol initialisation.
1372      */
1373     if (!fxp_init()) {
1374         fprintf(stderr,
1375                 "Fatal: unable to initialise SFTP: %s\n", fxp_error());
1376         return 1;                      /* failure */
1377     }
1378
1379     /*
1380      * Find out where our home directory is.
1381      */
1382     homedir = fxp_realpath(".");
1383     if (!homedir) {
1384         fprintf(stderr,
1385                 "Warning: failed to resolve home directory: %s\n",
1386                 fxp_error());
1387         homedir = dupstr(".");
1388     } else {
1389         printf("Remote working directory is %s\n", homedir);
1390     }
1391     pwd = dupstr(homedir);
1392     return 0;
1393 }
1394
1395 void do_sftp(int mode, int modeflags, char *batchfile)
1396 {
1397     FILE *fp;
1398     int ret;
1399
1400     /*
1401      * Batch mode?
1402      */
1403     if (mode == 0) {
1404
1405         /* ------------------------------------------------------------------
1406          * Now we're ready to do Real Stuff.
1407          */
1408         while (1) {
1409             struct sftp_command *cmd;
1410             cmd = sftp_getcmd(stdin, 0, 0);
1411             if (!cmd)
1412                 break;
1413             if (cmd->obey(cmd) < 0)
1414                 break;
1415         }
1416     } else {
1417         fp = fopen(batchfile, "r");
1418         if (!fp) {
1419             printf("Fatal: unable to open %s\n", batchfile);
1420             return;
1421         }
1422         while (1) {
1423             struct sftp_command *cmd;
1424             cmd = sftp_getcmd(fp, mode, modeflags);
1425             if (!cmd)
1426                 break;
1427             ret = cmd->obey(cmd);
1428             if (ret < 0)
1429                 break;
1430             if (ret == 0) {
1431                 if (!(modeflags & 2))
1432                     break;
1433             }
1434         }
1435         fclose(fp);
1436
1437     }
1438 }
1439
1440 /* ----------------------------------------------------------------------
1441  * Dirty bits: integration with PuTTY.
1442  */
1443
1444 static int verbose = 0;
1445
1446 /*
1447  *  Print an error message and perform a fatal exit.
1448  */
1449 void fatalbox(char *fmt, ...)
1450 {
1451     char *str, *str2;
1452     va_list ap;
1453     va_start(ap, fmt);
1454     str = dupvprintf(fmt, ap);
1455     str2 = dupcat("Fatal: ", str, "\n", NULL);
1456     sfree(str);
1457     va_end(ap);
1458     fputs(str2, stderr);
1459     sfree(str2);
1460
1461     cleanup_exit(1);
1462 }
1463 void modalfatalbox(char *fmt, ...)
1464 {
1465     char *str, *str2;
1466     va_list ap;
1467     va_start(ap, fmt);
1468     str = dupvprintf(fmt, ap);
1469     str2 = dupcat("Fatal: ", str, "\n", NULL);
1470     sfree(str);
1471     va_end(ap);
1472     fputs(str2, stderr);
1473     sfree(str2);
1474
1475     cleanup_exit(1);
1476 }
1477 void connection_fatal(void *frontend, char *fmt, ...)
1478 {
1479     char *str, *str2;
1480     va_list ap;
1481     va_start(ap, fmt);
1482     str = dupvprintf(fmt, ap);
1483     str2 = dupcat("Fatal: ", str, "\n", NULL);
1484     sfree(str);
1485     va_end(ap);
1486     fputs(str2, stderr);
1487     sfree(str2);
1488
1489     cleanup_exit(1);
1490 }
1491
1492 void ldisc_send(void *handle, char *buf, int len, int interactive)
1493 {
1494     /*
1495      * This is only here because of the calls to ldisc_send(NULL,
1496      * 0) in ssh.c. Nothing in PSFTP actually needs to use the
1497      * ldisc as an ldisc. So if we get called with any real data, I
1498      * want to know about it.
1499      */
1500     assert(len == 0);
1501 }
1502
1503 /*
1504  * Be told what socket we're supposed to be using.
1505  */
1506 static SOCKET sftp_ssh_socket;
1507 char *do_select(SOCKET skt, int startup)
1508 {
1509     if (startup)
1510         sftp_ssh_socket = skt;
1511     else
1512         sftp_ssh_socket = INVALID_SOCKET;
1513     return NULL;
1514 }
1515 extern int select_result(WPARAM, LPARAM);
1516
1517 /*
1518  * Receive a block of data from the SSH link. Block until all data
1519  * is available.
1520  *
1521  * To do this, we repeatedly call the SSH protocol module, with our
1522  * own trap in from_backend() to catch the data that comes back. We
1523  * do this until we have enough data.
1524  */
1525
1526 static unsigned char *outptr;          /* where to put the data */
1527 static unsigned outlen;                /* how much data required */
1528 static unsigned char *pending = NULL;  /* any spare data */
1529 static unsigned pendlen = 0, pendsize = 0;      /* length and phys. size of buffer */
1530 int from_backend(void *frontend, int is_stderr, char *data, int datalen)
1531 {
1532     unsigned char *p = (unsigned char *) data;
1533     unsigned len = (unsigned) datalen;
1534
1535     assert(len > 0);
1536
1537     /*
1538      * stderr data is just spouted to local stderr and otherwise
1539      * ignored.
1540      */
1541     if (is_stderr) {
1542         fwrite(data, 1, len, stderr);
1543         return 0;
1544     }
1545
1546     /*
1547      * If this is before the real session begins, just return.
1548      */
1549     if (!outptr)
1550         return 0;
1551
1552     if (outlen > 0) {
1553         unsigned used = outlen;
1554         if (used > len)
1555             used = len;
1556         memcpy(outptr, p, used);
1557         outptr += used;
1558         outlen -= used;
1559         p += used;
1560         len -= used;
1561     }
1562
1563     if (len > 0) {
1564         if (pendsize < pendlen + len) {
1565             pendsize = pendlen + len + 4096;
1566             pending = (pending ? srealloc(pending, pendsize) :
1567                        smalloc(pendsize));
1568             if (!pending)
1569                 fatalbox("Out of memory");
1570         }
1571         memcpy(pending + pendlen, p, len);
1572         pendlen += len;
1573     }
1574
1575     return 0;
1576 }
1577 int sftp_recvdata(char *buf, int len)
1578 {
1579     outptr = (unsigned char *) buf;
1580     outlen = len;
1581
1582     /*
1583      * See if the pending-input block contains some of what we
1584      * need.
1585      */
1586     if (pendlen > 0) {
1587         unsigned pendused = pendlen;
1588         if (pendused > outlen)
1589             pendused = outlen;
1590         memcpy(outptr, pending, pendused);
1591         memmove(pending, pending + pendused, pendlen - pendused);
1592         outptr += pendused;
1593         outlen -= pendused;
1594         pendlen -= pendused;
1595         if (pendlen == 0) {
1596             pendsize = 0;
1597             sfree(pending);
1598             pending = NULL;
1599         }
1600         if (outlen == 0)
1601             return 1;
1602     }
1603
1604     while (outlen > 0) {
1605         fd_set readfds;
1606
1607         FD_ZERO(&readfds);
1608         FD_SET(sftp_ssh_socket, &readfds);
1609         if (select(1, &readfds, NULL, NULL, NULL) < 0)
1610             return 0;                  /* doom */
1611         select_result((WPARAM) sftp_ssh_socket, (LPARAM) FD_READ);
1612     }
1613
1614     return 1;
1615 }
1616 int sftp_senddata(char *buf, int len)
1617 {
1618     back->send(backhandle, (unsigned char *) buf, len);
1619     return 1;
1620 }
1621
1622 /*
1623  * Loop through the ssh connection and authentication process.
1624  */
1625 static void ssh_sftp_init(void)
1626 {
1627     if (sftp_ssh_socket == INVALID_SOCKET)
1628         return;
1629     while (!back->sendok(backhandle)) {
1630         fd_set readfds;
1631         FD_ZERO(&readfds);
1632         FD_SET(sftp_ssh_socket, &readfds);
1633         if (select(1, &readfds, NULL, NULL, NULL) < 0)
1634             return;                    /* doom */
1635         select_result((WPARAM) sftp_ssh_socket, (LPARAM) FD_READ);
1636     }
1637 }
1638
1639 /*
1640  *  Initialize the Win$ock driver.
1641  */
1642 static void init_winsock(void)
1643 {
1644     WORD winsock_ver;
1645     WSADATA wsadata;
1646
1647     winsock_ver = MAKEWORD(1, 1);
1648     if (WSAStartup(winsock_ver, &wsadata)) {
1649         fprintf(stderr, "Unable to initialise WinSock");
1650         cleanup_exit(1);
1651     }
1652     if (LOBYTE(wsadata.wVersion) != 1 || HIBYTE(wsadata.wVersion) != 1) {
1653         fprintf(stderr, "WinSock version is incompatible with 1.1");
1654         cleanup_exit(1);
1655     }
1656 }
1657
1658 /*
1659  *  Short description of parameters.
1660  */
1661 static void usage(void)
1662 {
1663     printf("PuTTY Secure File Transfer (SFTP) client\n");
1664     printf("%s\n", ver);
1665     printf("Usage: psftp [options] user@host\n");
1666     printf("Options:\n");
1667     printf("  -b file   use specified batchfile\n");
1668     printf("  -bc       output batchfile commands\n");
1669     printf("  -be       don't stop batchfile processing if errors\n");
1670     printf("  -v        show verbose messages\n");
1671     printf("  -load sessname  Load settings from saved session\n");
1672     printf("  -l user   connect with specified username\n");
1673     printf("  -P port   connect to specified port\n");
1674     printf("  -pw passw login with specified password\n");
1675     printf("  -1 -2     force use of particular SSH protocol version\n");
1676     printf("  -C        enable compression\n");
1677     printf("  -i key    private key file for authentication\n");
1678     printf("  -batch    disable all interactive prompts\n");
1679     cleanup_exit(1);
1680 }
1681
1682 /*
1683  * Connect to a host.
1684  */
1685 static int psftp_connect(char *userhost, char *user, int portnumber)
1686 {
1687     char *host, *realhost;
1688     char *err;
1689
1690     /* Separate host and username */
1691     host = userhost;
1692     host = strrchr(host, '@');
1693     if (host == NULL) {
1694         host = userhost;
1695     } else {
1696         *host++ = '\0';
1697         if (user) {
1698             printf("psftp: multiple usernames specified; using \"%s\"\n",
1699                    user);
1700         } else
1701             user = userhost;
1702     }
1703
1704     /* Try to load settings for this host */
1705     do_defaults(host, &cfg);
1706     if (cfg.host[0] == '\0') {
1707         /* No settings for this host; use defaults */
1708         do_defaults(NULL, &cfg);
1709         strncpy(cfg.host, host, sizeof(cfg.host) - 1);
1710         cfg.host[sizeof(cfg.host) - 1] = '\0';
1711     }
1712
1713     /*
1714      * Force use of SSH. (If they got the protocol wrong we assume the
1715      * port is useless too.)
1716      */
1717     if (cfg.protocol != PROT_SSH) {
1718         cfg.protocol = PROT_SSH;
1719         cfg.port = 22;
1720     }
1721
1722     /*
1723      * Enact command-line overrides.
1724      */
1725     cmdline_run_saved(&cfg);
1726
1727     /*
1728      * Trim leading whitespace off the hostname if it's there.
1729      */
1730     {
1731         int space = strspn(cfg.host, " \t");
1732         memmove(cfg.host, cfg.host+space, 1+strlen(cfg.host)-space);
1733     }
1734
1735     /* See if host is of the form user@host */
1736     if (cfg.host[0] != '\0') {
1737         char *atsign = strchr(cfg.host, '@');
1738         /* Make sure we're not overflowing the user field */
1739         if (atsign) {
1740             if (atsign - cfg.host < sizeof cfg.username) {
1741                 strncpy(cfg.username, cfg.host, atsign - cfg.host);
1742                 cfg.username[atsign - cfg.host] = '\0';
1743             }
1744             memmove(cfg.host, atsign + 1, 1 + strlen(atsign + 1));
1745         }
1746     }
1747
1748     /*
1749      * Trim a colon suffix off the hostname if it's there.
1750      */
1751     cfg.host[strcspn(cfg.host, ":")] = '\0';
1752
1753     /*
1754      * Remove any remaining whitespace from the hostname.
1755      */
1756     {
1757         int p1 = 0, p2 = 0;
1758         while (cfg.host[p2] != '\0') {
1759             if (cfg.host[p2] != ' ' && cfg.host[p2] != '\t') {
1760                 cfg.host[p1] = cfg.host[p2];
1761                 p1++;
1762             }
1763             p2++;
1764         }
1765         cfg.host[p1] = '\0';
1766     }
1767
1768     /* Set username */
1769     if (user != NULL && user[0] != '\0') {
1770         strncpy(cfg.username, user, sizeof(cfg.username) - 1);
1771         cfg.username[sizeof(cfg.username) - 1] = '\0';
1772     }
1773     if (!cfg.username[0]) {
1774         printf("login as: ");
1775         fflush(stdout);
1776         if (!fgets(cfg.username, sizeof(cfg.username), stdin)) {
1777             fprintf(stderr, "psftp: aborting\n");
1778             cleanup_exit(1);
1779         } else {
1780             int len = strlen(cfg.username);
1781             if (cfg.username[len - 1] == '\n')
1782                 cfg.username[len - 1] = '\0';
1783         }
1784     }
1785
1786     if (portnumber)
1787         cfg.port = portnumber;
1788
1789     /* SFTP uses SSH2 by default always */
1790     cfg.sshprot = 2;
1791
1792     /*
1793      * Disable scary things which shouldn't be enabled for simple
1794      * things like SCP and SFTP: agent forwarding, port forwarding,
1795      * X forwarding.
1796      */
1797     cfg.x11_forward = 0;
1798     cfg.agentfwd = 0;
1799     cfg.portfwd[0] = cfg.portfwd[1] = '\0';
1800
1801     /* Set up subsystem name. */
1802     strcpy(cfg.remote_cmd, "sftp");
1803     cfg.ssh_subsys = TRUE;
1804     cfg.nopty = TRUE;
1805
1806     /*
1807      * Set up fallback option, for SSH1 servers or servers with the
1808      * sftp subsystem not enabled but the server binary installed
1809      * in the usual place. We only support fallback on Unix
1810      * systems, and we use a kludgy piece of shellery which should
1811      * try to find sftp-server in various places (the obvious
1812      * systemwide spots /usr/lib and /usr/local/lib, and then the
1813      * user's PATH) and finally give up.
1814      *
1815      *   test -x /usr/lib/sftp-server && exec /usr/lib/sftp-server
1816      *   test -x /usr/local/lib/sftp-server && exec /usr/local/lib/sftp-server
1817      *   exec sftp-server
1818      *
1819      * the idea being that this will attempt to use either of the
1820      * obvious pathnames and then give up, and when it does give up
1821      * it will print the preferred pathname in the error messages.
1822      */
1823     cfg.remote_cmd_ptr2 =
1824         "test -x /usr/lib/sftp-server && exec /usr/lib/sftp-server\n"
1825         "test -x /usr/local/lib/sftp-server && exec /usr/local/lib/sftp-server\n"
1826         "exec sftp-server";
1827     cfg.ssh_subsys2 = FALSE;
1828
1829     back = &ssh_backend;
1830
1831     err = back->init(NULL, &backhandle, &cfg, cfg.host, cfg.port, &realhost,0);
1832     if (err != NULL) {
1833         fprintf(stderr, "ssh_init: %s\n", err);
1834         return 1;
1835     }
1836     logctx = log_init(NULL);
1837     back->provide_logctx(backhandle, logctx);
1838     ssh_sftp_init();
1839     if (verbose && realhost != NULL)
1840         printf("Connected to %s\n", realhost);
1841     return 0;
1842 }
1843
1844 void cmdline_error(char *p, ...)
1845 {
1846     va_list ap;
1847     fprintf(stderr, "psftp: ");
1848     va_start(ap, p);
1849     vfprintf(stderr, p, ap);
1850     va_end(ap);
1851     fprintf(stderr, "\n       try typing \"psftp -h\" for help\n");
1852     exit(1);
1853 }
1854
1855 /*
1856  * Main program. Parse arguments etc.
1857  */
1858 int main(int argc, char *argv[])
1859 {
1860     int i;
1861     int portnumber = 0;
1862     char *userhost, *user;
1863     int mode = 0;
1864     int modeflags = 0;
1865     char *batchfile = NULL;
1866     int errors = 0;
1867
1868     flags = FLAG_STDERR | FLAG_INTERACTIVE;
1869     cmdline_tooltype = TOOLTYPE_FILETRANSFER;
1870     ssh_get_line = &console_get_line;
1871     init_winsock();
1872     sk_init();
1873
1874     userhost = user = NULL;
1875
1876     errors = 0;
1877     for (i = 1; i < argc; i++) {
1878         int ret;
1879         if (argv[i][0] != '-') {
1880             if (userhost)
1881                 usage();
1882             else
1883                 userhost = dupstr(argv[i]);
1884             continue;
1885         }
1886         ret = cmdline_process_param(argv[i], i+1<argc?argv[i+1]:NULL, 1, &cfg);
1887         if (ret == -2) {
1888             cmdline_error("option \"%s\" requires an argument", argv[i]);
1889         } else if (ret == 2) {
1890             i++;               /* skip next argument */
1891         } else if (ret == 1) {
1892             /* We have our own verbosity in addition to `flags'. */
1893             if (flags & FLAG_VERBOSE)
1894                 verbose = 1;
1895         } else if (strcmp(argv[i], "-h") == 0 ||
1896                    strcmp(argv[i], "-?") == 0) {
1897             usage();
1898         } else if (strcmp(argv[i], "-batch") == 0) {
1899             console_batch_mode = 1;
1900         } else if (strcmp(argv[i], "-b") == 0 && i + 1 < argc) {
1901             mode = 1;
1902             batchfile = argv[++i];
1903         } else if (strcmp(argv[i], "-bc") == 0) {
1904             modeflags = modeflags | 1;
1905         } else if (strcmp(argv[i], "-be") == 0) {
1906             modeflags = modeflags | 2;
1907         } else if (strcmp(argv[i], "--") == 0) {
1908             i++;
1909             break;
1910         } else {
1911             cmdline_error("unknown option \"%s\"", argv[i]);
1912         }
1913     }
1914     argc -= i;
1915     argv += i;
1916     back = NULL;
1917
1918     /*
1919      * If a user@host string has already been provided, connect to
1920      * it now.
1921      */
1922     if (userhost) {
1923         if (psftp_connect(userhost, user, portnumber))
1924             return 1;
1925         if (do_sftp_init())
1926             return 1;
1927     } else {
1928         printf("psftp: no hostname specified; use \"open host.name\""
1929             " to connect\n");
1930     }
1931
1932     do_sftp(mode, modeflags, batchfile);
1933
1934     if (back != NULL && back->socket(backhandle) != NULL) {
1935         char ch;
1936         back->special(backhandle, TS_EOF);
1937         sftp_recvdata(&ch, 1);
1938     }
1939     WSACleanup();
1940     random_save_seed();
1941
1942     return 0;
1943 }