contrib/putty/PSFTP.C

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