2001-02-23 21:21:44 +03:00
|
|
|
/*
|
|
|
|
* psftp.c: front end for PSFTP.
|
|
|
|
*/
|
|
|
|
|
2001-02-24 19:08:56 +03:00
|
|
|
#include <windows.h>
|
|
|
|
|
2001-02-23 21:21:44 +03:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
2001-02-24 15:02:35 +03:00
|
|
|
#include <stdarg.h>
|
2001-02-23 21:21:44 +03:00
|
|
|
#include <assert.h>
|
2001-08-26 15:35:11 +04:00
|
|
|
#include <limits.h>
|
2001-02-23 21:21:44 +03:00
|
|
|
|
2001-02-24 19:08:56 +03:00
|
|
|
#define PUTTY_DO_GLOBALS
|
|
|
|
#include "putty.h"
|
|
|
|
#include "storage.h"
|
|
|
|
#include "ssh.h"
|
2001-02-23 21:21:44 +03:00
|
|
|
#include "sftp.h"
|
|
|
|
#include "int64.h"
|
|
|
|
|
2001-08-25 21:09:23 +04:00
|
|
|
/*
|
|
|
|
* Since SFTP is a request-response oriented protocol, it requires
|
|
|
|
* no buffer management: when we send data, we stop and wait for an
|
|
|
|
* acknowledgement _anyway_, and so we can't possibly overfill our
|
|
|
|
* send buffer.
|
|
|
|
*/
|
|
|
|
|
2001-12-13 21:42:34 +03:00
|
|
|
static int psftp_connect(char *userhost, char *user, int portnumber);
|
|
|
|
static void do_sftp_init(void);
|
|
|
|
|
2001-02-23 21:21:44 +03:00
|
|
|
/* ----------------------------------------------------------------------
|
|
|
|
* sftp client state.
|
|
|
|
*/
|
|
|
|
|
|
|
|
char *pwd, *homedir;
|
|
|
|
|
|
|
|
/* ----------------------------------------------------------------------
|
|
|
|
* Higher-level helper functions used in commands.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
2001-02-24 15:02:35 +03:00
|
|
|
* Attempt to canonify a pathname starting from the pwd. If
|
|
|
|
* canonification fails, at least fall back to returning a _valid_
|
|
|
|
* pathname (though it may be ugly, eg /home/simon/../foobar).
|
2001-02-23 21:21:44 +03:00
|
|
|
*/
|
2001-05-06 18:35:20 +04:00
|
|
|
char *canonify(char *name)
|
|
|
|
{
|
2001-02-24 15:02:35 +03:00
|
|
|
char *fullname, *canonname;
|
2001-02-24 19:08:56 +03:00
|
|
|
|
2001-02-24 15:02:35 +03:00
|
|
|
if (name[0] == '/') {
|
|
|
|
fullname = dupstr(name);
|
|
|
|
} else {
|
2001-02-24 19:08:56 +03:00
|
|
|
char *slash;
|
2001-05-06 18:35:20 +04:00
|
|
|
if (pwd[strlen(pwd) - 1] == '/')
|
2001-02-24 19:08:56 +03:00
|
|
|
slash = "";
|
|
|
|
else
|
|
|
|
slash = "/";
|
|
|
|
fullname = dupcat(pwd, slash, name, NULL);
|
2001-02-24 15:02:35 +03:00
|
|
|
}
|
2001-02-24 19:08:56 +03:00
|
|
|
|
|
|
|
canonname = fxp_realpath(fullname);
|
|
|
|
|
2001-02-24 15:02:35 +03:00
|
|
|
if (canonname) {
|
|
|
|
sfree(fullname);
|
|
|
|
return canonname;
|
2001-02-26 19:39:15 +03:00
|
|
|
} else {
|
2001-05-06 18:35:20 +04:00
|
|
|
/*
|
|
|
|
* Attempt number 2. Some FXP_REALPATH implementations
|
|
|
|
* (glibc-based ones, in particular) require the _whole_
|
|
|
|
* path to point to something that exists, whereas others
|
|
|
|
* (BSD-based) only require all but the last component to
|
|
|
|
* exist. So if the first call failed, we should strip off
|
|
|
|
* everything from the last slash onwards and try again,
|
|
|
|
* then put the final component back on.
|
|
|
|
*
|
|
|
|
* Special cases:
|
|
|
|
*
|
|
|
|
* - if the last component is "/." or "/..", then we don't
|
|
|
|
* bother trying this because there's no way it can work.
|
|
|
|
*
|
|
|
|
* - if the thing actually ends with a "/", we remove it
|
|
|
|
* before we start. Except if the string is "/" itself
|
|
|
|
* (although I can't see why we'd have got here if so,
|
|
|
|
* because surely "/" would have worked the first
|
|
|
|
* time?), in which case we don't bother.
|
|
|
|
*
|
|
|
|
* - if there's no slash in the string at all, give up in
|
|
|
|
* confusion (we expect at least one because of the way
|
|
|
|
* we constructed the string).
|
|
|
|
*/
|
|
|
|
|
|
|
|
int i;
|
|
|
|
char *returnname;
|
|
|
|
|
|
|
|
i = strlen(fullname);
|
|
|
|
if (i > 2 && fullname[i - 1] == '/')
|
|
|
|
fullname[--i] = '\0'; /* strip trailing / unless at pos 0 */
|
|
|
|
while (i > 0 && fullname[--i] != '/');
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Give up on special cases.
|
|
|
|
*/
|
|
|
|
if (fullname[i] != '/' || /* no slash at all */
|
|
|
|
!strcmp(fullname + i, "/.") || /* ends in /. */
|
|
|
|
!strcmp(fullname + i, "/..") || /* ends in /.. */
|
|
|
|
!strcmp(fullname, "/")) {
|
|
|
|
return fullname;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now i points at the slash. Deal with the final special
|
|
|
|
* case i==0 (ie the whole path was "/nonexistentfile").
|
|
|
|
*/
|
|
|
|
fullname[i] = '\0'; /* separate the string */
|
|
|
|
if (i == 0) {
|
|
|
|
canonname = fxp_realpath("/");
|
|
|
|
} else {
|
|
|
|
canonname = fxp_realpath(fullname);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!canonname)
|
|
|
|
return fullname; /* even that failed; give up */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We have a canonical name for all but the last path
|
|
|
|
* component. Concatenate the last component and return.
|
|
|
|
*/
|
|
|
|
returnname = dupcat(canonname,
|
|
|
|
canonname[strlen(canonname) - 1] ==
|
|
|
|
'/' ? "" : "/", fullname + i + 1, NULL);
|
|
|
|
sfree(fullname);
|
|
|
|
sfree(canonname);
|
|
|
|
return returnname;
|
2001-02-26 19:39:15 +03:00
|
|
|
}
|
2001-02-23 21:21:44 +03:00
|
|
|
}
|
|
|
|
|
2001-09-13 00:16:45 +04:00
|
|
|
/*
|
|
|
|
* Return a pointer to the portion of str that comes after the last
|
|
|
|
* slash (or backslash or colon, if `local' is TRUE).
|
|
|
|
*/
|
|
|
|
static char *stripslashes(char *str, int local)
|
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
if (local) {
|
|
|
|
p = strchr(str, ':');
|
|
|
|
if (p) str = p+1;
|
|
|
|
}
|
|
|
|
|
|
|
|
p = strrchr(str, '/');
|
|
|
|
if (p) str = p+1;
|
|
|
|
|
|
|
|
if (local) {
|
|
|
|
p = strrchr(str, '\\');
|
|
|
|
if (p) str = p+1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
2001-02-23 21:21:44 +03:00
|
|
|
/* ----------------------------------------------------------------------
|
|
|
|
* Actual sftp commands.
|
|
|
|
*/
|
|
|
|
struct sftp_command {
|
|
|
|
char **words;
|
|
|
|
int nwords, wordssize;
|
2001-05-06 18:35:20 +04:00
|
|
|
int (*obey) (struct sftp_command *); /* returns <0 to quit */
|
2001-02-23 21:21:44 +03:00
|
|
|
};
|
|
|
|
|
2001-05-06 18:35:20 +04:00
|
|
|
int sftp_cmd_null(struct sftp_command *cmd)
|
|
|
|
{
|
2001-12-13 22:26:51 +03:00
|
|
|
return 1; /* success */
|
2001-02-23 21:21:44 +03:00
|
|
|
}
|
|
|
|
|
2001-05-06 18:35:20 +04:00
|
|
|
int sftp_cmd_unknown(struct sftp_command *cmd)
|
|
|
|
{
|
2001-02-23 21:21:44 +03:00
|
|
|
printf("psftp: unknown command \"%s\"\n", cmd->words[0]);
|
2001-12-13 22:26:51 +03:00
|
|
|
return 0; /* failure */
|
2001-02-23 21:21:44 +03:00
|
|
|
}
|
|
|
|
|
2001-05-06 18:35:20 +04:00
|
|
|
int sftp_cmd_quit(struct sftp_command *cmd)
|
|
|
|
{
|
2001-02-23 21:21:44 +03:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* List a directory. If no arguments are given, list pwd; otherwise
|
|
|
|
* list the directory given in words[1].
|
|
|
|
*/
|
2001-05-06 18:35:20 +04:00
|
|
|
static int sftp_ls_compare(const void *av, const void *bv)
|
|
|
|
{
|
|
|
|
const struct fxp_name *a = (const struct fxp_name *) av;
|
|
|
|
const struct fxp_name *b = (const struct fxp_name *) bv;
|
2001-02-23 21:21:44 +03:00
|
|
|
return strcmp(a->filename, b->filename);
|
|
|
|
}
|
2001-05-06 18:35:20 +04:00
|
|
|
int sftp_cmd_ls(struct sftp_command *cmd)
|
|
|
|
{
|
2001-02-23 21:21:44 +03:00
|
|
|
struct fxp_handle *dirh;
|
|
|
|
struct fxp_names *names;
|
|
|
|
struct fxp_name *ournames;
|
|
|
|
int nnames, namesize;
|
|
|
|
char *dir, *cdir;
|
|
|
|
int i;
|
|
|
|
|
2001-12-13 21:42:34 +03:00
|
|
|
if (back == NULL) {
|
|
|
|
printf("psftp: not connected to a host; use \"open host.name\"\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2001-02-23 21:21:44 +03:00
|
|
|
if (cmd->nwords < 2)
|
|
|
|
dir = ".";
|
|
|
|
else
|
|
|
|
dir = cmd->words[1];
|
|
|
|
|
|
|
|
cdir = canonify(dir);
|
|
|
|
if (!cdir) {
|
|
|
|
printf("%s: %s\n", dir, fxp_error());
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
printf("Listing directory %s\n", cdir);
|
|
|
|
|
|
|
|
dirh = fxp_opendir(cdir);
|
|
|
|
if (dirh == NULL) {
|
|
|
|
printf("Unable to open %s: %s\n", dir, fxp_error());
|
|
|
|
} else {
|
|
|
|
nnames = namesize = 0;
|
|
|
|
ournames = NULL;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
|
|
|
|
names = fxp_readdir(dirh);
|
|
|
|
if (names == NULL) {
|
|
|
|
if (fxp_error_type() == SSH_FX_EOF)
|
|
|
|
break;
|
|
|
|
printf("Reading directory %s: %s\n", dir, fxp_error());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (names->nnames == 0) {
|
|
|
|
fxp_free_names(names);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nnames + names->nnames >= namesize) {
|
|
|
|
namesize += names->nnames + 128;
|
2001-05-06 18:35:20 +04:00
|
|
|
ournames =
|
|
|
|
srealloc(ournames, namesize * sizeof(*ournames));
|
2001-02-23 21:21:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < names->nnames; i++)
|
|
|
|
ournames[nnames++] = names->names[i];
|
|
|
|
|
|
|
|
names->nnames = 0; /* prevent free_names */
|
|
|
|
fxp_free_names(names);
|
|
|
|
}
|
|
|
|
fxp_close(dirh);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now we have our filenames. Sort them by actual file
|
|
|
|
* name, and then output the longname parts.
|
|
|
|
*/
|
|
|
|
qsort(ournames, nnames, sizeof(*ournames), sftp_ls_compare);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* And print them.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < nnames; i++)
|
|
|
|
printf("%s\n", ournames[i].longname);
|
|
|
|
}
|
|
|
|
|
|
|
|
sfree(cdir);
|
|
|
|
|
2001-12-13 22:26:51 +03:00
|
|
|
return 1;
|
2001-02-23 21:21:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Change directories. We do this by canonifying the new name, then
|
|
|
|
* trying to OPENDIR it. Only if that succeeds do we set the new pwd.
|
|
|
|
*/
|
2001-05-06 18:35:20 +04:00
|
|
|
int sftp_cmd_cd(struct sftp_command *cmd)
|
|
|
|
{
|
2001-02-23 21:21:44 +03:00
|
|
|
struct fxp_handle *dirh;
|
|
|
|
char *dir;
|
|
|
|
|
2001-12-13 21:42:34 +03:00
|
|
|
if (back == NULL) {
|
|
|
|
printf("psftp: not connected to a host; use \"open host.name\"\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2001-02-23 21:21:44 +03:00
|
|
|
if (cmd->nwords < 2)
|
2001-02-24 15:02:35 +03:00
|
|
|
dir = dupstr(homedir);
|
2001-02-23 21:21:44 +03:00
|
|
|
else
|
|
|
|
dir = canonify(cmd->words[1]);
|
|
|
|
|
|
|
|
if (!dir) {
|
|
|
|
printf("%s: %s\n", dir, fxp_error());
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
dirh = fxp_opendir(dir);
|
|
|
|
if (!dirh) {
|
|
|
|
printf("Directory %s: %s\n", dir, fxp_error());
|
|
|
|
sfree(dir);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
fxp_close(dirh);
|
|
|
|
|
|
|
|
sfree(pwd);
|
|
|
|
pwd = dir;
|
|
|
|
printf("Remote directory is now %s\n", pwd);
|
|
|
|
|
2001-12-13 22:26:51 +03:00
|
|
|
return 1;
|
2001-02-23 21:21:44 +03:00
|
|
|
}
|
|
|
|
|
2001-09-09 20:31:26 +04:00
|
|
|
/*
|
|
|
|
* Print current directory. Easy as pie.
|
|
|
|
*/
|
|
|
|
int sftp_cmd_pwd(struct sftp_command *cmd)
|
|
|
|
{
|
2001-12-13 21:42:34 +03:00
|
|
|
if (back == NULL) {
|
|
|
|
printf("psftp: not connected to a host; use \"open host.name\"\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2001-09-09 20:31:26 +04:00
|
|
|
printf("Remote directory is %s\n", pwd);
|
2001-12-13 22:26:51 +03:00
|
|
|
return 1;
|
2001-09-09 20:31:26 +04:00
|
|
|
}
|
|
|
|
|
2001-02-23 21:21:44 +03:00
|
|
|
/*
|
2001-08-26 15:35:11 +04:00
|
|
|
* Get a file and save it at the local end. We have two very
|
|
|
|
* similar commands here: `get' and `reget', which differ in that
|
|
|
|
* `reget' checks for the existence of the destination file and
|
|
|
|
* starts from where a previous aborted transfer left off.
|
2001-02-23 21:21:44 +03:00
|
|
|
*/
|
2001-08-26 15:35:11 +04:00
|
|
|
int sftp_general_get(struct sftp_command *cmd, int restart)
|
2001-05-06 18:35:20 +04:00
|
|
|
{
|
2001-02-23 21:21:44 +03:00
|
|
|
struct fxp_handle *fh;
|
|
|
|
char *fname, *outfname;
|
|
|
|
uint64 offset;
|
|
|
|
FILE *fp;
|
2001-12-13 22:26:51 +03:00
|
|
|
int ret;
|
2001-02-23 21:21:44 +03:00
|
|
|
|
2001-12-13 21:42:34 +03:00
|
|
|
if (back == NULL) {
|
|
|
|
printf("psftp: not connected to a host; use \"open host.name\"\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2001-02-23 21:21:44 +03:00
|
|
|
if (cmd->nwords < 2) {
|
|
|
|
printf("get: expects a filename\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
fname = canonify(cmd->words[1]);
|
|
|
|
if (!fname) {
|
|
|
|
printf("%s: %s\n", cmd->words[1], fxp_error());
|
|
|
|
return 0;
|
|
|
|
}
|
2001-09-13 00:16:45 +04:00
|
|
|
outfname = (cmd->nwords == 2 ?
|
|
|
|
stripslashes(cmd->words[1], 0) : cmd->words[2]);
|
2001-02-23 21:21:44 +03:00
|
|
|
|
|
|
|
fh = fxp_open(fname, SSH_FXF_READ);
|
|
|
|
if (!fh) {
|
|
|
|
printf("%s: %s\n", fname, fxp_error());
|
|
|
|
sfree(fname);
|
|
|
|
return 0;
|
|
|
|
}
|
2001-08-26 15:35:11 +04:00
|
|
|
|
|
|
|
if (restart) {
|
|
|
|
fp = fopen(outfname, "rb+");
|
|
|
|
} else {
|
|
|
|
fp = fopen(outfname, "wb");
|
|
|
|
}
|
|
|
|
|
2001-02-23 21:21:44 +03:00
|
|
|
if (!fp) {
|
|
|
|
printf("local: unable to open %s\n", outfname);
|
2001-05-06 18:35:20 +04:00
|
|
|
fxp_close(fh);
|
2001-02-23 21:21:44 +03:00
|
|
|
sfree(fname);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2001-08-26 15:35:11 +04:00
|
|
|
if (restart) {
|
|
|
|
long posn;
|
|
|
|
fseek(fp, 0L, SEEK_END);
|
|
|
|
posn = ftell(fp);
|
|
|
|
printf("reget: restarting at file position %ld\n", posn);
|
|
|
|
offset = uint64_make(0, posn);
|
|
|
|
} else {
|
|
|
|
offset = uint64_make(0, 0);
|
|
|
|
}
|
2001-02-23 21:21:44 +03:00
|
|
|
|
2001-08-26 15:35:11 +04:00
|
|
|
printf("remote:%s => local:%s\n", fname, outfname);
|
2001-02-23 21:21:44 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* FIXME: we can use FXP_FSTAT here to get the file size, and
|
|
|
|
* thus put up a progress bar.
|
|
|
|
*/
|
2001-12-13 22:26:51 +03:00
|
|
|
ret = 1;
|
2001-02-23 21:21:44 +03:00
|
|
|
while (1) {
|
|
|
|
char buffer[4096];
|
|
|
|
int len;
|
|
|
|
int wpos, wlen;
|
|
|
|
|
|
|
|
len = fxp_read(fh, buffer, offset, sizeof(buffer));
|
2001-05-06 18:35:20 +04:00
|
|
|
if ((len == -1 && fxp_error_type() == SSH_FX_EOF) || len == 0)
|
2001-02-23 21:21:44 +03:00
|
|
|
break;
|
|
|
|
if (len == -1) {
|
|
|
|
printf("error while reading: %s\n", fxp_error());
|
2001-12-13 22:26:51 +03:00
|
|
|
ret = 0;
|
2001-02-23 21:21:44 +03:00
|
|
|
break;
|
|
|
|
}
|
2001-05-06 18:35:20 +04:00
|
|
|
|
2001-02-23 21:21:44 +03:00
|
|
|
wpos = 0;
|
|
|
|
while (wpos < len) {
|
2001-05-06 18:35:20 +04:00
|
|
|
wlen = fwrite(buffer, 1, len - wpos, fp);
|
2001-02-23 21:21:44 +03:00
|
|
|
if (wlen <= 0) {
|
|
|
|
printf("error while writing local file\n");
|
2001-12-13 22:26:51 +03:00
|
|
|
ret = 0;
|
2001-02-23 21:21:44 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
wpos += wlen;
|
|
|
|
}
|
2001-12-13 22:26:51 +03:00
|
|
|
if (wpos < len) { /* we had an error */
|
|
|
|
ret = 0;
|
2001-02-23 21:21:44 +03:00
|
|
|
break;
|
2001-12-13 22:26:51 +03:00
|
|
|
}
|
2001-02-23 21:21:44 +03:00
|
|
|
offset = uint64_add32(offset, len);
|
|
|
|
}
|
|
|
|
|
|
|
|
fclose(fp);
|
|
|
|
fxp_close(fh);
|
|
|
|
sfree(fname);
|
|
|
|
|
2001-12-13 22:26:51 +03:00
|
|
|
return ret;
|
2001-02-23 21:21:44 +03:00
|
|
|
}
|
2001-08-26 15:35:11 +04:00
|
|
|
int sftp_cmd_get(struct sftp_command *cmd)
|
|
|
|
{
|
|
|
|
return sftp_general_get(cmd, 0);
|
|
|
|
}
|
|
|
|
int sftp_cmd_reget(struct sftp_command *cmd)
|
|
|
|
{
|
|
|
|
return sftp_general_get(cmd, 1);
|
|
|
|
}
|
2001-02-23 21:21:44 +03:00
|
|
|
|
|
|
|
/*
|
2001-08-26 15:35:11 +04:00
|
|
|
* Send a file and store it at the remote end. We have two very
|
|
|
|
* similar commands here: `put' and `reput', which differ in that
|
|
|
|
* `reput' checks for the existence of the destination file and
|
|
|
|
* starts from where a previous aborted transfer left off.
|
2001-02-23 21:21:44 +03:00
|
|
|
*/
|
2001-08-26 15:35:11 +04:00
|
|
|
int sftp_general_put(struct sftp_command *cmd, int restart)
|
2001-05-06 18:35:20 +04:00
|
|
|
{
|
2001-02-23 21:21:44 +03:00
|
|
|
struct fxp_handle *fh;
|
|
|
|
char *fname, *origoutfname, *outfname;
|
|
|
|
uint64 offset;
|
|
|
|
FILE *fp;
|
2001-12-13 22:26:51 +03:00
|
|
|
int ret;
|
2001-02-23 21:21:44 +03:00
|
|
|
|
2001-12-13 21:42:34 +03:00
|
|
|
if (back == NULL) {
|
|
|
|
printf("psftp: not connected to a host; use \"open host.name\"\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2001-02-23 21:21:44 +03:00
|
|
|
if (cmd->nwords < 2) {
|
|
|
|
printf("put: expects a filename\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
fname = cmd->words[1];
|
2001-09-13 00:16:45 +04:00
|
|
|
origoutfname = (cmd->nwords == 2 ?
|
|
|
|
stripslashes(cmd->words[1], 1) : cmd->words[2]);
|
2001-02-23 21:21:44 +03:00
|
|
|
outfname = canonify(origoutfname);
|
2001-02-24 15:02:35 +03:00
|
|
|
if (!outfname) {
|
2001-02-23 21:21:44 +03:00
|
|
|
printf("%s: %s\n", origoutfname, fxp_error());
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
fp = fopen(fname, "rb");
|
|
|
|
if (!fp) {
|
|
|
|
printf("local: unable to open %s\n", fname);
|
|
|
|
sfree(outfname);
|
|
|
|
return 0;
|
|
|
|
}
|
2001-08-26 15:35:11 +04:00
|
|
|
if (restart) {
|
|
|
|
fh = fxp_open(outfname,
|
|
|
|
SSH_FXF_WRITE);
|
|
|
|
} else {
|
|
|
|
fh = fxp_open(outfname,
|
|
|
|
SSH_FXF_WRITE | SSH_FXF_CREAT | SSH_FXF_TRUNC);
|
|
|
|
}
|
2001-02-23 21:21:44 +03:00
|
|
|
if (!fh) {
|
|
|
|
printf("%s: %s\n", outfname, fxp_error());
|
|
|
|
sfree(outfname);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2001-08-26 15:35:11 +04:00
|
|
|
if (restart) {
|
|
|
|
char decbuf[30];
|
|
|
|
struct fxp_attrs attrs;
|
|
|
|
if (!fxp_fstat(fh, &attrs)) {
|
|
|
|
printf("read size of %s: %s\n", outfname, fxp_error());
|
|
|
|
sfree(outfname);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (!(attrs.flags & SSH_FILEXFER_ATTR_SIZE)) {
|
|
|
|
printf("read size of %s: size was not given\n", outfname);
|
|
|
|
sfree(outfname);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
offset = attrs.size;
|
|
|
|
uint64_decimal(offset, decbuf);
|
|
|
|
printf("reput: restarting at file position %s\n", decbuf);
|
|
|
|
if (uint64_compare(offset, uint64_make(0, LONG_MAX)) > 0) {
|
|
|
|
printf("reput: remote file is larger than we can deal with\n");
|
|
|
|
sfree(outfname);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (fseek(fp, offset.lo, SEEK_SET) != 0)
|
|
|
|
fseek(fp, 0, SEEK_END); /* *shrug* */
|
|
|
|
} else {
|
|
|
|
offset = uint64_make(0, 0);
|
|
|
|
}
|
2001-02-23 21:21:44 +03:00
|
|
|
|
2001-08-26 15:35:11 +04:00
|
|
|
printf("local:%s => remote:%s\n", fname, outfname);
|
2001-02-23 21:21:44 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* FIXME: we can use FXP_FSTAT here to get the file size, and
|
|
|
|
* thus put up a progress bar.
|
|
|
|
*/
|
2001-12-13 22:26:51 +03:00
|
|
|
ret = 1;
|
2001-02-23 21:21:44 +03:00
|
|
|
while (1) {
|
|
|
|
char buffer[4096];
|
|
|
|
int len;
|
|
|
|
|
2001-02-24 15:02:35 +03:00
|
|
|
len = fread(buffer, 1, sizeof(buffer), fp);
|
2001-02-23 21:21:44 +03:00
|
|
|
if (len == -1) {
|
|
|
|
printf("error while reading local file\n");
|
2001-12-13 22:26:51 +03:00
|
|
|
ret = 0;
|
2001-02-23 21:21:44 +03:00
|
|
|
break;
|
|
|
|
} else if (len == 0) {
|
|
|
|
break;
|
|
|
|
}
|
2001-02-24 15:02:35 +03:00
|
|
|
if (!fxp_write(fh, buffer, offset, len)) {
|
2001-02-23 21:21:44 +03:00
|
|
|
printf("error while writing: %s\n", fxp_error());
|
2001-12-13 22:26:51 +03:00
|
|
|
ret = 0;
|
2001-02-23 21:21:44 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
offset = uint64_add32(offset, len);
|
|
|
|
}
|
|
|
|
|
|
|
|
fxp_close(fh);
|
|
|
|
fclose(fp);
|
|
|
|
sfree(outfname);
|
|
|
|
|
2001-12-13 22:26:51 +03:00
|
|
|
return ret;
|
2001-02-23 21:21:44 +03:00
|
|
|
}
|
2001-08-26 15:35:11 +04:00
|
|
|
int sftp_cmd_put(struct sftp_command *cmd)
|
|
|
|
{
|
|
|
|
return sftp_general_put(cmd, 0);
|
|
|
|
}
|
|
|
|
int sftp_cmd_reput(struct sftp_command *cmd)
|
|
|
|
{
|
|
|
|
return sftp_general_put(cmd, 1);
|
|
|
|
}
|
2001-02-23 21:21:44 +03:00
|
|
|
|
2001-08-04 18:19:51 +04:00
|
|
|
int sftp_cmd_mkdir(struct sftp_command *cmd)
|
|
|
|
{
|
|
|
|
char *dir;
|
|
|
|
int result;
|
|
|
|
|
2001-12-13 21:42:34 +03:00
|
|
|
if (back == NULL) {
|
|
|
|
printf("psftp: not connected to a host; use \"open host.name\"\n");
|
|
|
|
return 0;
|
|
|
|
}
|
2001-08-04 18:19:51 +04:00
|
|
|
|
|
|
|
if (cmd->nwords < 2) {
|
|
|
|
printf("mkdir: expects a directory\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
dir = canonify(cmd->words[1]);
|
|
|
|
if (!dir) {
|
|
|
|
printf("%s: %s\n", dir, fxp_error());
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
result = fxp_mkdir(dir);
|
|
|
|
if (!result) {
|
|
|
|
printf("mkdir %s: %s\n", dir, fxp_error());
|
|
|
|
sfree(dir);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2001-08-26 15:35:11 +04:00
|
|
|
sfree(dir);
|
2001-12-13 22:26:51 +03:00
|
|
|
return 1;
|
2001-08-04 18:19:51 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
int sftp_cmd_rmdir(struct sftp_command *cmd)
|
|
|
|
{
|
|
|
|
char *dir;
|
|
|
|
int result;
|
|
|
|
|
2001-12-13 21:42:34 +03:00
|
|
|
if (back == NULL) {
|
|
|
|
printf("psftp: not connected to a host; use \"open host.name\"\n");
|
|
|
|
return 0;
|
|
|
|
}
|
2001-08-04 18:19:51 +04:00
|
|
|
|
|
|
|
if (cmd->nwords < 2) {
|
|
|
|
printf("rmdir: expects a directory\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
dir = canonify(cmd->words[1]);
|
|
|
|
if (!dir) {
|
|
|
|
printf("%s: %s\n", dir, fxp_error());
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
result = fxp_rmdir(dir);
|
|
|
|
if (!result) {
|
|
|
|
printf("rmdir %s: %s\n", dir, fxp_error());
|
|
|
|
sfree(dir);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2001-08-26 15:35:11 +04:00
|
|
|
sfree(dir);
|
2001-12-13 22:26:51 +03:00
|
|
|
return 1;
|
2001-08-04 18:19:51 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
int sftp_cmd_rm(struct sftp_command *cmd)
|
|
|
|
{
|
|
|
|
char *fname;
|
|
|
|
int result;
|
|
|
|
|
2001-12-13 21:42:34 +03:00
|
|
|
if (back == NULL) {
|
|
|
|
printf("psftp: not connected to a host; use \"open host.name\"\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2001-08-04 18:19:51 +04:00
|
|
|
if (cmd->nwords < 2) {
|
|
|
|
printf("rm: expects a filename\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
fname = canonify(cmd->words[1]);
|
|
|
|
if (!fname) {
|
|
|
|
printf("%s: %s\n", fname, fxp_error());
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2001-08-26 15:35:11 +04:00
|
|
|
result = fxp_remove(fname);
|
2001-08-04 18:19:51 +04:00
|
|
|
if (!result) {
|
|
|
|
printf("rm %s: %s\n", fname, fxp_error());
|
|
|
|
sfree(fname);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2001-08-26 15:35:11 +04:00
|
|
|
sfree(fname);
|
2001-12-13 22:26:51 +03:00
|
|
|
return 1;
|
2001-08-26 15:35:11 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
int sftp_cmd_mv(struct sftp_command *cmd)
|
|
|
|
{
|
|
|
|
char *srcfname, *dstfname;
|
|
|
|
int result;
|
|
|
|
|
2001-12-13 21:42:34 +03:00
|
|
|
if (back == NULL) {
|
|
|
|
printf("psftp: not connected to a host; use \"open host.name\"\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2001-08-26 15:35:11 +04:00
|
|
|
if (cmd->nwords < 3) {
|
|
|
|
printf("mv: expects two filenames\n");
|
2001-08-04 18:19:51 +04:00
|
|
|
return 0;
|
2001-08-26 15:35:11 +04:00
|
|
|
}
|
|
|
|
srcfname = canonify(cmd->words[1]);
|
|
|
|
if (!srcfname) {
|
|
|
|
printf("%s: %s\n", srcfname, fxp_error());
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
dstfname = canonify(cmd->words[2]);
|
|
|
|
if (!dstfname) {
|
|
|
|
printf("%s: %s\n", dstfname, fxp_error());
|
|
|
|
return 0;
|
|
|
|
}
|
2001-08-04 18:19:51 +04:00
|
|
|
|
2001-08-26 15:35:11 +04:00
|
|
|
result = fxp_rename(srcfname, dstfname);
|
|
|
|
if (!result) {
|
|
|
|
char const *error = fxp_error();
|
|
|
|
struct fxp_attrs attrs;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The move might have failed because dstfname pointed at a
|
|
|
|
* directory. We check this possibility now: if dstfname
|
|
|
|
* _is_ a directory, we re-attempt the move by appending
|
|
|
|
* the basename of srcfname to dstfname.
|
|
|
|
*/
|
|
|
|
result = fxp_stat(dstfname, &attrs);
|
|
|
|
if (result &&
|
|
|
|
(attrs.flags & SSH_FILEXFER_ATTR_PERMISSIONS) &&
|
|
|
|
(attrs.permissions & 0040000)) {
|
|
|
|
char *p;
|
|
|
|
char *newname, *newcanon;
|
|
|
|
printf("(destination %s is a directory)\n", dstfname);
|
|
|
|
p = srcfname + strlen(srcfname);
|
|
|
|
while (p > srcfname && p[-1] != '/') p--;
|
|
|
|
newname = dupcat(dstfname, "/", p, NULL);
|
|
|
|
newcanon = canonify(newname);
|
|
|
|
sfree(newname);
|
|
|
|
if (newcanon) {
|
|
|
|
sfree(dstfname);
|
|
|
|
dstfname = newcanon;
|
|
|
|
result = fxp_rename(srcfname, dstfname);
|
|
|
|
error = result ? NULL : fxp_error();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (error) {
|
|
|
|
printf("mv %s %s: %s\n", srcfname, dstfname, error);
|
|
|
|
sfree(srcfname);
|
|
|
|
sfree(dstfname);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
printf("%s -> %s\n", srcfname, dstfname);
|
|
|
|
|
|
|
|
sfree(srcfname);
|
|
|
|
sfree(dstfname);
|
2001-12-13 22:26:51 +03:00
|
|
|
return 1;
|
2001-08-04 18:19:51 +04:00
|
|
|
}
|
|
|
|
|
2001-08-26 15:35:11 +04:00
|
|
|
int sftp_cmd_chmod(struct sftp_command *cmd)
|
|
|
|
{
|
|
|
|
char *fname, *mode;
|
|
|
|
int result;
|
|
|
|
struct fxp_attrs attrs;
|
|
|
|
unsigned attrs_clr, attrs_xor, oldperms, newperms;
|
|
|
|
|
2001-12-13 21:42:34 +03:00
|
|
|
if (back == NULL) {
|
|
|
|
printf("psftp: not connected to a host; use \"open host.name\"\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2001-08-26 15:35:11 +04:00
|
|
|
if (cmd->nwords < 3) {
|
|
|
|
printf("chmod: expects a mode specifier and a filename\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Attempt to parse the mode specifier in cmd->words[1]. We
|
|
|
|
* don't support the full horror of Unix chmod; instead we
|
|
|
|
* support a much simpler syntax in which the user can either
|
|
|
|
* specify an octal number, or a comma-separated sequence of
|
|
|
|
* [ugoa]*[-+=][rwxst]+. (The initial [ugoa] sequence may
|
|
|
|
* _only_ be omitted if the only attribute mentioned is t,
|
|
|
|
* since all others require a user/group/other specification.
|
|
|
|
* Additionally, the s attribute may not be specified for any
|
|
|
|
* [ugoa] specifications other than exactly u or exactly g.
|
|
|
|
*/
|
|
|
|
attrs_clr = attrs_xor = 0;
|
|
|
|
mode = cmd->words[1];
|
|
|
|
if (mode[0] >= '0' && mode[0] <= '9') {
|
|
|
|
if (mode[strspn(mode, "01234567")]) {
|
|
|
|
printf("chmod: numeric file modes should"
|
|
|
|
" contain digits 0-7 only\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
attrs_clr = 07777;
|
|
|
|
sscanf(mode, "%o", &attrs_xor);
|
|
|
|
attrs_xor &= attrs_clr;
|
|
|
|
} else {
|
|
|
|
while (*mode) {
|
|
|
|
char *modebegin = mode;
|
|
|
|
unsigned subset, perms;
|
|
|
|
int action;
|
|
|
|
|
|
|
|
subset = 0;
|
|
|
|
while (*mode && *mode != ',' &&
|
|
|
|
*mode != '+' && *mode != '-' && *mode != '=') {
|
|
|
|
switch (*mode) {
|
|
|
|
case 'u': subset |= 04700; break; /* setuid, user perms */
|
|
|
|
case 'g': subset |= 02070; break; /* setgid, group perms */
|
|
|
|
case 'o': subset |= 00007; break; /* just other perms */
|
|
|
|
case 'a': subset |= 06777; break; /* all of the above */
|
|
|
|
default:
|
|
|
|
printf("chmod: file mode '%.*s' contains unrecognised"
|
|
|
|
" user/group/other specifier '%c'\n",
|
|
|
|
strcspn(modebegin, ","), modebegin, *mode);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
mode++;
|
|
|
|
}
|
|
|
|
if (!*mode || *mode == ',') {
|
|
|
|
printf("chmod: file mode '%.*s' is incomplete\n",
|
|
|
|
strcspn(modebegin, ","), modebegin);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
action = *mode++;
|
|
|
|
if (!*mode || *mode == ',') {
|
|
|
|
printf("chmod: file mode '%.*s' is incomplete\n",
|
|
|
|
strcspn(modebegin, ","), modebegin);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
perms = 0;
|
|
|
|
while (*mode && *mode != ',') {
|
|
|
|
switch (*mode) {
|
|
|
|
case 'r': perms |= 00444; break;
|
|
|
|
case 'w': perms |= 00222; break;
|
|
|
|
case 'x': perms |= 00111; break;
|
|
|
|
case 't': perms |= 01000; subset |= 01000; break;
|
|
|
|
case 's':
|
|
|
|
if ((subset & 06777) != 04700 &&
|
|
|
|
(subset & 06777) != 02070) {
|
|
|
|
printf("chmod: file mode '%.*s': set[ug]id bit should"
|
|
|
|
" be used with exactly one of u or g only\n",
|
|
|
|
strcspn(modebegin, ","), modebegin);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
perms |= 06000;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printf("chmod: file mode '%.*s' contains unrecognised"
|
|
|
|
" permission specifier '%c'\n",
|
|
|
|
strcspn(modebegin, ","), modebegin, *mode);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
mode++;
|
|
|
|
}
|
|
|
|
if (!(subset & 06777) && (perms &~ subset)) {
|
|
|
|
printf("chmod: file mode '%.*s' contains no user/group/other"
|
|
|
|
" specifier and permissions other than 't' \n",
|
|
|
|
strcspn(modebegin, ","), modebegin, *mode);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
perms &= subset;
|
|
|
|
switch (action) {
|
|
|
|
case '+':
|
|
|
|
attrs_clr |= perms;
|
|
|
|
attrs_xor |= perms;
|
|
|
|
break;
|
|
|
|
case '-':
|
|
|
|
attrs_clr |= perms;
|
|
|
|
attrs_xor &= ~perms;
|
|
|
|
break;
|
|
|
|
case '=':
|
|
|
|
attrs_clr |= subset;
|
|
|
|
attrs_xor |= perms;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (*mode) mode++; /* eat comma */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fname = canonify(cmd->words[2]);
|
|
|
|
if (!fname) {
|
|
|
|
printf("%s: %s\n", fname, fxp_error());
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
result = fxp_stat(fname, &attrs);
|
|
|
|
if (!result || !(attrs.flags & SSH_FILEXFER_ATTR_PERMISSIONS)) {
|
|
|
|
printf("get attrs for %s: %s\n", fname,
|
|
|
|
result ? "file permissions not provided" : fxp_error());
|
|
|
|
sfree(fname);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
attrs.flags = SSH_FILEXFER_ATTR_PERMISSIONS; /* perms _only_ */
|
|
|
|
oldperms = attrs.permissions & 07777;
|
|
|
|
attrs.permissions &= ~attrs_clr;
|
|
|
|
attrs.permissions ^= attrs_xor;
|
|
|
|
newperms = attrs.permissions & 07777;
|
|
|
|
|
|
|
|
result = fxp_setstat(fname, attrs);
|
|
|
|
|
|
|
|
if (!result) {
|
|
|
|
printf("set attrs for %s: %s\n", fname, fxp_error());
|
|
|
|
sfree(fname);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
printf("%s: %04o -> %04o\n", fname, oldperms, newperms);
|
|
|
|
|
|
|
|
sfree(fname);
|
2001-12-13 22:26:51 +03:00
|
|
|
return 1;
|
2001-08-26 15:35:11 +04:00
|
|
|
}
|
2001-08-04 18:19:51 +04:00
|
|
|
|
2001-12-13 21:42:34 +03:00
|
|
|
static int sftp_cmd_open(struct sftp_command *cmd)
|
|
|
|
{
|
|
|
|
if (back != NULL) {
|
|
|
|
printf("psftp: already connected\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cmd->nwords < 2) {
|
|
|
|
printf("open: expects a host name\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (psftp_connect(cmd->words[1], NULL, 0)) {
|
|
|
|
back = NULL; /* connection is already closed */
|
|
|
|
return -1; /* this is fatal */
|
|
|
|
}
|
|
|
|
do_sftp_init();
|
2001-12-13 22:26:51 +03:00
|
|
|
return 1;
|
2001-12-13 21:42:34 +03:00
|
|
|
}
|
|
|
|
|
2001-09-09 20:29:51 +04:00
|
|
|
static int sftp_cmd_help(struct sftp_command *cmd);
|
|
|
|
|
2001-02-23 21:21:44 +03:00
|
|
|
static struct sftp_cmd_lookup {
|
|
|
|
char *name;
|
2001-09-09 20:29:51 +04:00
|
|
|
/*
|
|
|
|
* For help purposes, there are two kinds of command:
|
|
|
|
*
|
|
|
|
* - primary commands, in which `longhelp' is non-NULL. In
|
|
|
|
* this case `shorthelp' is descriptive text, and `longhelp'
|
|
|
|
* is longer descriptive text intended to be printed after
|
|
|
|
* the command name.
|
|
|
|
*
|
|
|
|
* - alias commands, in which `longhelp' is NULL. In this case
|
|
|
|
* `shorthelp' is the name of a primary command, which
|
|
|
|
* contains the help that should double up for this command.
|
|
|
|
*/
|
|
|
|
char *shorthelp;
|
|
|
|
char *longhelp;
|
2001-05-06 18:35:20 +04:00
|
|
|
int (*obey) (struct sftp_command *);
|
2001-02-23 21:21:44 +03:00
|
|
|
} sftp_lookup[] = {
|
|
|
|
/*
|
|
|
|
* List of sftp commands. This is binary-searched so it MUST be
|
|
|
|
* in ASCII order.
|
|
|
|
*/
|
2001-05-06 18:35:20 +04:00
|
|
|
{
|
2001-09-09 20:29:51 +04:00
|
|
|
"bye", "finish your SFTP session",
|
|
|
|
"\n"
|
|
|
|
" Terminates your SFTP session and quits the PSFTP program.\n",
|
|
|
|
sftp_cmd_quit
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"cd", "change your remote working directory",
|
|
|
|
" [ <New working directory> ]\n"
|
|
|
|
" Change the remote working directory for your SFTP session.\n"
|
|
|
|
" If a new working directory is not supplied, you will be\n"
|
|
|
|
" returned to your home directory.\n",
|
|
|
|
sftp_cmd_cd
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"chmod", "change file permissions and modes",
|
|
|
|
" ( <octal-digits> | <modifiers> ) <filename>\n"
|
|
|
|
" Change the file permissions on a file or directory.\n"
|
|
|
|
" <octal-digits> can be any octal Unix permission specifier.\n"
|
|
|
|
" Alternatively, <modifiers> can include:\n"
|
|
|
|
" u+r make file readable by owning user\n"
|
|
|
|
" u+w make file writable by owning user\n"
|
|
|
|
" u+x make file executable by owning user\n"
|
|
|
|
" u-r make file not readable by owning user\n"
|
|
|
|
" [also u-w, u-x]\n"
|
|
|
|
" g+r make file readable by members of owning group\n"
|
|
|
|
" [also g+w, g+x, g-r, g-w, g-x]\n"
|
|
|
|
" o+r make file readable by all other users\n"
|
|
|
|
" [also o+w, o+x, o-r, o-w, o-x]\n"
|
|
|
|
" a+r make file readable by absolutely everybody\n"
|
|
|
|
" [also a+w, a+x, a-r, a-w, a-x]\n"
|
|
|
|
" u+s enable the Unix set-user-ID bit\n"
|
|
|
|
" u-s disable the Unix set-user-ID bit\n"
|
|
|
|
" g+s enable the Unix set-group-ID bit\n"
|
|
|
|
" g-s disable the Unix set-group-ID bit\n"
|
|
|
|
" +t enable the Unix \"sticky bit\"\n"
|
|
|
|
" You can give more than one modifier for the same user (\"g-rwx\"), and\n"
|
|
|
|
" more than one user for the same modifier (\"ug+w\"). You can\n"
|
|
|
|
" use commas to separate different modifiers (\"u+rwx,g+s\").\n",
|
|
|
|
sftp_cmd_chmod
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"del", "delete a file",
|
|
|
|
" <filename>\n"
|
|
|
|
" Delete a file.\n",
|
|
|
|
sftp_cmd_rm
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"delete", "delete a file",
|
|
|
|
"\n"
|
|
|
|
" Delete a file.\n",
|
|
|
|
sftp_cmd_rm
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"dir", "list contents of a remote directory",
|
|
|
|
" [ <directory-name> ]\n"
|
|
|
|
" List the contents of a specified directory on the server.\n"
|
|
|
|
" If <directory-name> is not given, the current working directory\n"
|
|
|
|
" will be listed.\n",
|
|
|
|
sftp_cmd_ls
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"exit", "bye", NULL, sftp_cmd_quit
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"get", "download a file from the server to your local machine",
|
|
|
|
" <filename> [ <local-filename> ]\n"
|
|
|
|
" Downloads a file on the server and stores it locally under\n"
|
|
|
|
" the same name, or under a different one if you supply the\n"
|
|
|
|
" argument <local-filename>.\n",
|
|
|
|
sftp_cmd_get
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"help", "give help",
|
|
|
|
" [ <command> [ <command> ... ] ]\n"
|
|
|
|
" Give general help if no commands are specified.\n"
|
|
|
|
" If one or more commands are specified, give specific help on\n"
|
|
|
|
" those particular commands.\n",
|
|
|
|
sftp_cmd_help
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"ls", "dir", NULL,
|
|
|
|
sftp_cmd_ls
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"mkdir", "create a directory on the remote server",
|
|
|
|
" <directory-name>\n"
|
|
|
|
" Creates a directory with the given name on the server.\n",
|
|
|
|
sftp_cmd_mkdir
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"mv", "move or rename a file on the remote server",
|
|
|
|
" <source-filename> <destination-filename>\n"
|
|
|
|
" Moves or renames the file <source-filename> on the server,\n"
|
|
|
|
" so that it is accessible under the name <destination-filename>.\n",
|
|
|
|
sftp_cmd_mv
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"put", "upload a file from your local machine to the server",
|
|
|
|
" <filename> [ <remote-filename> ]\n"
|
|
|
|
" Uploads a file to the server and stores it there under\n"
|
|
|
|
" the same name, or under a different one if you supply the\n"
|
|
|
|
" argument <remote-filename>.\n",
|
|
|
|
sftp_cmd_put
|
|
|
|
},
|
2001-12-13 21:42:34 +03:00
|
|
|
{
|
|
|
|
"open", "connect to a host",
|
|
|
|
" [<user>@]<hostname>\n"
|
|
|
|
" Establishes an SFTP connection to a given host. Only usable\n"
|
|
|
|
" when you did not already specify a host name on the command\n"
|
|
|
|
" line.\n",
|
|
|
|
sftp_cmd_open
|
|
|
|
},
|
2001-09-09 20:31:26 +04:00
|
|
|
{
|
|
|
|
"pwd", "print your remote working directory",
|
|
|
|
"\n"
|
|
|
|
" Print the current remote working directory for your SFTP session.\n",
|
|
|
|
sftp_cmd_pwd
|
|
|
|
},
|
2001-09-09 20:29:51 +04:00
|
|
|
{
|
|
|
|
"quit", "bye", NULL,
|
|
|
|
sftp_cmd_quit
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"reget", "continue downloading a file",
|
|
|
|
" <filename> [ <local-filename> ]\n"
|
|
|
|
" Works exactly like the \"get\" command, but the local file\n"
|
|
|
|
" must already exist. The download will begin at the end of the\n"
|
|
|
|
" file. This is for resuming a download that was interrupted.\n",
|
|
|
|
sftp_cmd_reget
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"ren", "mv", NULL,
|
|
|
|
sftp_cmd_mv
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"rename", "mv", NULL,
|
|
|
|
sftp_cmd_mv
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"reput", "continue uploading a file",
|
|
|
|
" <filename> [ <remote-filename> ]\n"
|
|
|
|
" Works exactly like the \"put\" command, but the remote file\n"
|
|
|
|
" must already exist. The upload will begin at the end of the\n"
|
|
|
|
" file. This is for resuming an upload that was interrupted.\n",
|
|
|
|
sftp_cmd_reput
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"rm", "del", NULL,
|
|
|
|
sftp_cmd_rm
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"rmdir", "remove a directory on the remote server",
|
|
|
|
" <directory-name>\n"
|
|
|
|
" Removes the directory with the given name on the server.\n"
|
|
|
|
" The directory will not be removed unless it is empty.\n",
|
|
|
|
sftp_cmd_rmdir
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
const struct sftp_cmd_lookup *lookup_command(char *name)
|
|
|
|
{
|
|
|
|
int i, j, k, cmp;
|
|
|
|
|
|
|
|
i = -1;
|
|
|
|
j = sizeof(sftp_lookup) / sizeof(*sftp_lookup);
|
|
|
|
while (j - i > 1) {
|
|
|
|
k = (j + i) / 2;
|
|
|
|
cmp = strcmp(name, sftp_lookup[k].name);
|
|
|
|
if (cmp < 0)
|
|
|
|
j = k;
|
|
|
|
else if (cmp > 0)
|
|
|
|
i = k;
|
|
|
|
else {
|
|
|
|
return &sftp_lookup[k];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sftp_cmd_help(struct sftp_command *cmd)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
if (cmd->nwords == 1) {
|
|
|
|
/*
|
|
|
|
* Give short help on each command.
|
|
|
|
*/
|
|
|
|
int maxlen;
|
|
|
|
maxlen = 0;
|
|
|
|
for (i = 0; i < sizeof(sftp_lookup) / sizeof(*sftp_lookup); i++) {
|
|
|
|
int len = strlen(sftp_lookup[i].name);
|
|
|
|
if (maxlen < len)
|
|
|
|
maxlen = len;
|
|
|
|
}
|
|
|
|
for (i = 0; i < sizeof(sftp_lookup) / sizeof(*sftp_lookup); i++) {
|
|
|
|
const struct sftp_cmd_lookup *lookup;
|
|
|
|
lookup = &sftp_lookup[i];
|
|
|
|
printf("%-*s", maxlen+2, lookup->name);
|
|
|
|
if (lookup->longhelp == NULL)
|
|
|
|
lookup = lookup_command(lookup->shorthelp);
|
|
|
|
printf("%s\n", lookup->shorthelp);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Give long help on specific commands.
|
|
|
|
*/
|
|
|
|
for (i = 1; i < cmd->nwords; i++) {
|
|
|
|
const struct sftp_cmd_lookup *lookup;
|
|
|
|
lookup = lookup_command(cmd->words[i]);
|
|
|
|
if (!lookup) {
|
|
|
|
printf("help: %s: command not found\n", cmd->words[i]);
|
|
|
|
} else {
|
|
|
|
printf("%s", lookup->name);
|
|
|
|
if (lookup->longhelp == NULL)
|
|
|
|
lookup = lookup_command(lookup->shorthelp);
|
|
|
|
printf("%s", lookup->longhelp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2001-12-13 22:26:51 +03:00
|
|
|
return 1;
|
2001-09-09 20:29:51 +04:00
|
|
|
}
|
2001-02-23 21:21:44 +03:00
|
|
|
|
|
|
|
/* ----------------------------------------------------------------------
|
|
|
|
* Command line reading and parsing.
|
|
|
|
*/
|
2001-08-04 18:19:51 +04:00
|
|
|
struct sftp_command *sftp_getcmd(FILE *fp, int mode, int modeflags)
|
2001-05-06 18:35:20 +04:00
|
|
|
{
|
2001-02-23 21:21:44 +03:00
|
|
|
char *line;
|
|
|
|
int linelen, linesize;
|
|
|
|
struct sftp_command *cmd;
|
|
|
|
char *p, *q, *r;
|
|
|
|
int quoting;
|
|
|
|
|
2001-12-13 22:26:51 +03:00
|
|
|
if ((mode == 0) || (modeflags & 1)) {
|
|
|
|
printf("psftp> ");
|
|
|
|
}
|
2001-02-23 21:21:44 +03:00
|
|
|
fflush(stdout);
|
|
|
|
|
|
|
|
cmd = smalloc(sizeof(struct sftp_command));
|
|
|
|
cmd->words = NULL;
|
|
|
|
cmd->nwords = 0;
|
|
|
|
cmd->wordssize = 0;
|
|
|
|
|
|
|
|
line = NULL;
|
|
|
|
linesize = linelen = 0;
|
|
|
|
while (1) {
|
|
|
|
int len;
|
|
|
|
char *ret;
|
|
|
|
|
|
|
|
linesize += 512;
|
|
|
|
line = srealloc(line, linesize);
|
2001-08-04 18:19:51 +04:00
|
|
|
ret = fgets(line + linelen, linesize - linelen, fp);
|
2001-02-23 21:21:44 +03:00
|
|
|
|
|
|
|
if (!ret || (linelen == 0 && line[0] == '\0')) {
|
|
|
|
cmd->obey = sftp_cmd_quit;
|
2001-12-14 13:06:09 +03:00
|
|
|
if ((mode == 0) || (modeflags & 1))
|
|
|
|
printf("quit\n");
|
2001-02-23 21:21:44 +03:00
|
|
|
return cmd; /* eof */
|
|
|
|
}
|
2001-05-06 18:35:20 +04:00
|
|
|
len = linelen + strlen(line + linelen);
|
2001-02-23 21:21:44 +03:00
|
|
|
linelen += len;
|
2001-05-06 18:35:20 +04:00
|
|
|
if (line[linelen - 1] == '\n') {
|
2001-02-23 21:21:44 +03:00
|
|
|
linelen--;
|
|
|
|
line[linelen] = '\0';
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2001-12-13 22:26:51 +03:00
|
|
|
if (modeflags & 1) {
|
|
|
|
printf("%s\n", line);
|
|
|
|
}
|
2001-02-23 21:21:44 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Parse the command line into words. The syntax is:
|
|
|
|
* - double quotes are removed, but cause spaces within to be
|
|
|
|
* treated as non-separating.
|
|
|
|
* - a double-doublequote pair is a literal double quote, inside
|
|
|
|
* _or_ outside quotes. Like this:
|
|
|
|
*
|
|
|
|
* firstword "second word" "this has ""quotes"" in" sodoes""this""
|
|
|
|
*
|
|
|
|
* becomes
|
|
|
|
*
|
|
|
|
* >firstword<
|
|
|
|
* >second word<
|
|
|
|
* >this has "quotes" in<
|
|
|
|
* >sodoes"this"<
|
|
|
|
*/
|
|
|
|
p = line;
|
|
|
|
while (*p) {
|
|
|
|
/* skip whitespace */
|
2001-05-06 18:35:20 +04:00
|
|
|
while (*p && (*p == ' ' || *p == '\t'))
|
|
|
|
p++;
|
2001-02-23 21:21:44 +03:00
|
|
|
/* mark start of word */
|
|
|
|
q = r = p; /* q sits at start, r writes word */
|
|
|
|
quoting = 0;
|
|
|
|
while (*p) {
|
|
|
|
if (!quoting && (*p == ' ' || *p == '\t'))
|
|
|
|
break; /* reached end of word */
|
|
|
|
else if (*p == '"' && p[1] == '"')
|
2001-05-06 18:35:20 +04:00
|
|
|
p += 2, *r++ = '"'; /* a literal quote */
|
2001-02-23 21:21:44 +03:00
|
|
|
else if (*p == '"')
|
|
|
|
p++, quoting = !quoting;
|
|
|
|
else
|
|
|
|
*r++ = *p++;
|
|
|
|
}
|
2001-05-06 18:35:20 +04:00
|
|
|
if (*p)
|
|
|
|
p++; /* skip over the whitespace */
|
2001-02-23 21:21:44 +03:00
|
|
|
*r = '\0';
|
|
|
|
if (cmd->nwords >= cmd->wordssize) {
|
|
|
|
cmd->wordssize = cmd->nwords + 16;
|
2001-05-06 18:35:20 +04:00
|
|
|
cmd->words =
|
|
|
|
srealloc(cmd->words, cmd->wordssize * sizeof(char *));
|
2001-02-23 21:21:44 +03:00
|
|
|
}
|
|
|
|
cmd->words[cmd->nwords++] = q;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now parse the first word and assign a function.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (cmd->nwords == 0)
|
|
|
|
cmd->obey = sftp_cmd_null;
|
|
|
|
else {
|
2001-09-09 20:29:51 +04:00
|
|
|
const struct sftp_cmd_lookup *lookup;
|
|
|
|
lookup = lookup_command(cmd->words[0]);
|
|
|
|
if (!lookup)
|
|
|
|
cmd->obey = sftp_cmd_unknown;
|
|
|
|
else
|
|
|
|
cmd->obey = lookup->obey;
|
2001-02-23 21:21:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return cmd;
|
|
|
|
}
|
|
|
|
|
2001-12-13 21:42:34 +03:00
|
|
|
static void do_sftp_init(void)
|
2001-05-06 18:35:20 +04:00
|
|
|
{
|
2001-02-23 21:21:44 +03:00
|
|
|
/*
|
|
|
|
* Do protocol initialisation.
|
|
|
|
*/
|
|
|
|
if (!fxp_init()) {
|
|
|
|
fprintf(stderr,
|
2001-05-06 18:35:20 +04:00
|
|
|
"Fatal: unable to initialise SFTP: %s\n", fxp_error());
|
2001-02-27 12:11:42 +03:00
|
|
|
return;
|
2001-02-23 21:21:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find out where our home directory is.
|
|
|
|
*/
|
2001-02-24 15:02:35 +03:00
|
|
|
homedir = fxp_realpath(".");
|
2001-02-23 21:21:44 +03:00
|
|
|
if (!homedir) {
|
|
|
|
fprintf(stderr,
|
|
|
|
"Warning: failed to resolve home directory: %s\n",
|
|
|
|
fxp_error());
|
|
|
|
homedir = dupstr(".");
|
|
|
|
} else {
|
|
|
|
printf("Remote working directory is %s\n", homedir);
|
|
|
|
}
|
|
|
|
pwd = dupstr(homedir);
|
2001-12-13 21:42:34 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void do_sftp(int mode, int modeflags, char *batchfile)
|
|
|
|
{
|
|
|
|
FILE *fp;
|
2001-12-13 22:26:51 +03:00
|
|
|
int ret;
|
2001-02-23 21:21:44 +03:00
|
|
|
|
2001-08-04 18:19:51 +04:00
|
|
|
/*
|
|
|
|
* Batch mode?
|
2001-02-23 21:21:44 +03:00
|
|
|
*/
|
2001-08-04 18:19:51 +04:00
|
|
|
if (mode == 0) {
|
|
|
|
|
|
|
|
/* ------------------------------------------------------------------
|
|
|
|
* Now we're ready to do Real Stuff.
|
|
|
|
*/
|
|
|
|
while (1) {
|
2001-12-13 22:26:51 +03:00
|
|
|
struct sftp_command *cmd;
|
|
|
|
cmd = sftp_getcmd(stdin, 0, 0);
|
|
|
|
if (!cmd)
|
|
|
|
break;
|
|
|
|
if (cmd->obey(cmd) < 0)
|
|
|
|
break;
|
2001-09-09 20:29:51 +04:00
|
|
|
}
|
2001-08-04 18:19:51 +04:00
|
|
|
} else {
|
|
|
|
fp = fopen(batchfile, "r");
|
|
|
|
if (!fp) {
|
2001-09-09 20:29:51 +04:00
|
|
|
printf("Fatal: unable to open %s\n", batchfile);
|
|
|
|
return;
|
2001-08-04 18:19:51 +04:00
|
|
|
}
|
|
|
|
while (1) {
|
2001-09-09 20:29:51 +04:00
|
|
|
struct sftp_command *cmd;
|
|
|
|
cmd = sftp_getcmd(fp, mode, modeflags);
|
|
|
|
if (!cmd)
|
|
|
|
break;
|
2001-12-13 22:26:51 +03:00
|
|
|
ret = cmd->obey(cmd);
|
|
|
|
if (ret < 0)
|
2001-09-09 20:29:51 +04:00
|
|
|
break;
|
2001-12-13 22:26:51 +03:00
|
|
|
if (ret == 0) {
|
2001-09-09 20:29:51 +04:00
|
|
|
if (!(modeflags & 2))
|
2001-08-04 18:19:51 +04:00
|
|
|
break;
|
2001-09-09 20:29:51 +04:00
|
|
|
}
|
2001-08-04 18:19:51 +04:00
|
|
|
}
|
2001-09-09 20:29:51 +04:00
|
|
|
fclose(fp);
|
2001-08-04 18:19:51 +04:00
|
|
|
|
2001-02-23 21:21:44 +03:00
|
|
|
}
|
2001-02-24 19:08:56 +03:00
|
|
|
}
|
2001-02-23 21:21:44 +03:00
|
|
|
|
2001-02-24 19:08:56 +03:00
|
|
|
/* ----------------------------------------------------------------------
|
|
|
|
* Dirty bits: integration with PuTTY.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int verbose = 0;
|
|
|
|
|
|
|
|
void verify_ssh_host_key(char *host, int port, char *keytype,
|
2001-05-06 18:35:20 +04:00
|
|
|
char *keystr, char *fingerprint)
|
|
|
|
{
|
2001-02-24 19:08:56 +03:00
|
|
|
int ret;
|
2001-05-13 18:11:49 +04:00
|
|
|
HANDLE hin;
|
|
|
|
DWORD savemode, i;
|
2001-02-24 19:08:56 +03:00
|
|
|
|
|
|
|
static const char absentmsg[] =
|
2001-05-06 18:35:20 +04:00
|
|
|
"The server's host key is not cached in the registry. You\n"
|
|
|
|
"have no guarantee that the server is the computer you\n"
|
|
|
|
"think it is.\n"
|
|
|
|
"The server's key fingerprint is:\n"
|
|
|
|
"%s\n"
|
|
|
|
"If you trust this host, enter \"y\" to add the key to\n"
|
|
|
|
"PuTTY's cache and carry on connecting.\n"
|
2001-05-13 18:11:49 +04:00
|
|
|
"If you want to carry on connecting just once, without\n"
|
|
|
|
"adding the key to the cache, enter \"n\".\n"
|
|
|
|
"If you do not trust this host, press Return to abandon the\n"
|
|
|
|
"connection.\n"
|
|
|
|
"Store key in cache? (y/n) ";
|
2001-02-24 19:08:56 +03:00
|
|
|
|
|
|
|
static const char wrongmsg[] =
|
2001-05-06 18:35:20 +04:00
|
|
|
"WARNING - POTENTIAL SECURITY BREACH!\n"
|
|
|
|
"The server's host key does not match the one PuTTY has\n"
|
|
|
|
"cached in the registry. This means that either the\n"
|
|
|
|
"server administrator has changed the host key, or you\n"
|
|
|
|
"have actually connected to another computer pretending\n"
|
|
|
|
"to be the server.\n"
|
|
|
|
"The new key fingerprint is:\n"
|
|
|
|
"%s\n"
|
|
|
|
"If you were expecting this change and trust the new key,\n"
|
2001-05-13 18:11:49 +04:00
|
|
|
"enter \"y\" to update PuTTY's cache and continue connecting.\n"
|
2001-05-06 18:35:20 +04:00
|
|
|
"If you want to carry on connecting but without updating\n"
|
2001-05-13 18:11:49 +04:00
|
|
|
"the cache, enter \"n\".\n"
|
2001-05-06 18:35:20 +04:00
|
|
|
"If you want to abandon the connection completely, press\n"
|
|
|
|
"Return to cancel. Pressing Return is the ONLY guaranteed\n"
|
|
|
|
"safe choice.\n"
|
|
|
|
"Update cached key? (y/n, Return cancels connection) ";
|
2001-02-24 19:08:56 +03:00
|
|
|
|
|
|
|
static const char abandoned[] = "Connection abandoned.\n";
|
|
|
|
|
|
|
|
char line[32];
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Verify the key against the registry.
|
|
|
|
*/
|
|
|
|
ret = verify_host_key(host, port, keytype, keystr);
|
|
|
|
|
2001-05-06 18:35:20 +04:00
|
|
|
if (ret == 0) /* success - key matched OK */
|
|
|
|
return;
|
2001-05-13 18:11:49 +04:00
|
|
|
|
2001-05-06 18:35:20 +04:00
|
|
|
if (ret == 2) { /* key was different */
|
|
|
|
fprintf(stderr, wrongmsg, fingerprint);
|
2001-05-13 18:11:49 +04:00
|
|
|
fflush(stderr);
|
2001-02-24 19:08:56 +03:00
|
|
|
}
|
2001-05-06 18:35:20 +04:00
|
|
|
if (ret == 1) { /* key was absent */
|
|
|
|
fprintf(stderr, absentmsg, fingerprint);
|
2001-05-13 18:11:49 +04:00
|
|
|
fflush(stderr);
|
|
|
|
}
|
|
|
|
|
|
|
|
hin = GetStdHandle(STD_INPUT_HANDLE);
|
|
|
|
GetConsoleMode(hin, &savemode);
|
|
|
|
SetConsoleMode(hin, (savemode | ENABLE_ECHO_INPUT |
|
|
|
|
ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT));
|
|
|
|
ReadFile(hin, line, sizeof(line) - 1, &i, NULL);
|
|
|
|
SetConsoleMode(hin, savemode);
|
|
|
|
|
|
|
|
if (line[0] != '\0' && line[0] != '\r' && line[0] != '\n') {
|
|
|
|
if (line[0] == 'y' || line[0] == 'Y')
|
2001-05-06 18:35:20 +04:00
|
|
|
store_host_key(host, port, keytype, keystr);
|
2001-05-13 18:11:49 +04:00
|
|
|
} else {
|
|
|
|
fprintf(stderr, abandoned);
|
|
|
|
exit(0);
|
2001-02-24 19:08:56 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-08-25 23:33:33 +04:00
|
|
|
/*
|
|
|
|
* Ask whether the selected cipher is acceptable (since it was
|
|
|
|
* below the configured 'warn' threshold).
|
|
|
|
* cs: 0 = both ways, 1 = client->server, 2 = server->client
|
|
|
|
*/
|
|
|
|
void askcipher(char *ciphername, int cs)
|
|
|
|
{
|
|
|
|
HANDLE hin;
|
|
|
|
DWORD savemode, i;
|
|
|
|
|
|
|
|
static const char msg[] =
|
|
|
|
"The first %scipher supported by the server is\n"
|
|
|
|
"%s, which is below the configured warning threshold.\n"
|
|
|
|
"Continue with connection? (y/n) ";
|
|
|
|
static const char abandoned[] = "Connection abandoned.\n";
|
|
|
|
|
|
|
|
char line[32];
|
|
|
|
|
|
|
|
fprintf(stderr, msg,
|
|
|
|
(cs == 0) ? "" :
|
|
|
|
(cs == 1) ? "client-to-server " :
|
|
|
|
"server-to-client ",
|
|
|
|
ciphername);
|
|
|
|
fflush(stderr);
|
|
|
|
|
|
|
|
hin = GetStdHandle(STD_INPUT_HANDLE);
|
|
|
|
GetConsoleMode(hin, &savemode);
|
|
|
|
SetConsoleMode(hin, (savemode | ENABLE_ECHO_INPUT |
|
|
|
|
ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT));
|
|
|
|
ReadFile(hin, line, sizeof(line) - 1, &i, NULL);
|
|
|
|
SetConsoleMode(hin, savemode);
|
|
|
|
|
|
|
|
if (line[0] == 'y' || line[0] == 'Y') {
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
fprintf(stderr, abandoned);
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-11-25 17:31:46 +03:00
|
|
|
/*
|
|
|
|
* Warn about the obsolescent key file format.
|
|
|
|
*/
|
|
|
|
void old_keyfile_warning(void)
|
|
|
|
{
|
|
|
|
static const char message[] =
|
|
|
|
"You are loading an SSH 2 private key which has an\n"
|
|
|
|
"old version of the file format. This means your key\n"
|
|
|
|
"file is not fully tamperproof. Future versions of\n"
|
|
|
|
"PuTTY may stop supporting this private key format,\n"
|
|
|
|
"so we recommend you convert your key to the new\n"
|
|
|
|
"format.\n"
|
|
|
|
"\n"
|
|
|
|
"Once the key is loaded into PuTTYgen, you can perform\n"
|
|
|
|
"this conversion simply by saving it again.\n";
|
|
|
|
|
|
|
|
fputs(message, stderr);
|
|
|
|
}
|
|
|
|
|
2001-02-24 19:08:56 +03:00
|
|
|
/*
|
|
|
|
* Print an error message and perform a fatal exit.
|
|
|
|
*/
|
|
|
|
void fatalbox(char *fmt, ...)
|
|
|
|
{
|
2001-05-06 18:35:20 +04:00
|
|
|
char str[0x100]; /* Make the size big enough */
|
2001-02-24 19:08:56 +03:00
|
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
|
|
strcpy(str, "Fatal:");
|
2001-05-06 18:35:20 +04:00
|
|
|
vsprintf(str + strlen(str), fmt, ap);
|
2001-02-24 19:08:56 +03:00
|
|
|
va_end(ap);
|
|
|
|
strcat(str, "\n");
|
2001-12-13 21:42:34 +03:00
|
|
|
fputs(stderr, str);
|
2001-02-24 19:08:56 +03:00
|
|
|
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
void connection_fatal(char *fmt, ...)
|
|
|
|
{
|
2001-05-06 18:35:20 +04:00
|
|
|
char str[0x100]; /* Make the size big enough */
|
2001-02-24 19:08:56 +03:00
|
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
|
|
strcpy(str, "Fatal:");
|
2001-05-06 18:35:20 +04:00
|
|
|
vsprintf(str + strlen(str), fmt, ap);
|
2001-02-24 19:08:56 +03:00
|
|
|
va_end(ap);
|
|
|
|
strcat(str, "\n");
|
2001-12-13 21:42:34 +03:00
|
|
|
fputs(stderr, str);
|
2001-02-24 19:08:56 +03:00
|
|
|
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2001-05-06 18:35:20 +04:00
|
|
|
void logevent(char *string)
|
|
|
|
{
|
|
|
|
}
|
2001-02-24 19:08:56 +03:00
|
|
|
|
2001-09-20 00:07:15 +04:00
|
|
|
void ldisc_send(char *buf, int len, int interactive)
|
2001-05-06 18:35:20 +04:00
|
|
|
{
|
2001-02-24 19:08:56 +03:00
|
|
|
/*
|
|
|
|
* This is only here because of the calls to ldisc_send(NULL,
|
|
|
|
* 0) in ssh.c. Nothing in PSFTP actually needs to use the
|
|
|
|
* ldisc as an ldisc. So if we get called with any real data, I
|
|
|
|
* want to know about it.
|
2001-02-23 21:21:44 +03:00
|
|
|
*/
|
2001-02-24 19:08:56 +03:00
|
|
|
assert(len == 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Be told what socket we're supposed to be using.
|
|
|
|
*/
|
|
|
|
static SOCKET sftp_ssh_socket;
|
2001-05-06 18:35:20 +04:00
|
|
|
char *do_select(SOCKET skt, int startup)
|
|
|
|
{
|
2001-02-24 19:08:56 +03:00
|
|
|
if (startup)
|
|
|
|
sftp_ssh_socket = skt;
|
|
|
|
else
|
|
|
|
sftp_ssh_socket = INVALID_SOCKET;
|
|
|
|
return NULL;
|
2001-02-23 21:21:44 +03:00
|
|
|
}
|
2001-02-24 19:08:56 +03:00
|
|
|
extern int select_result(WPARAM, LPARAM);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Receive a block of data from the SSH link. Block until all data
|
|
|
|
* is available.
|
|
|
|
*
|
|
|
|
* To do this, we repeatedly call the SSH protocol module, with our
|
|
|
|
* own trap in from_backend() to catch the data that comes back. We
|
|
|
|
* do this until we have enough data.
|
|
|
|
*/
|
|
|
|
|
2001-05-06 18:35:20 +04:00
|
|
|
static unsigned char *outptr; /* where to put the data */
|
|
|
|
static unsigned outlen; /* how much data required */
|
2001-02-24 19:08:56 +03:00
|
|
|
static unsigned char *pending = NULL; /* any spare data */
|
2001-05-06 18:35:20 +04:00
|
|
|
static unsigned pendlen = 0, pendsize = 0; /* length and phys. size of buffer */
|
2001-08-25 21:09:23 +04:00
|
|
|
int from_backend(int is_stderr, char *data, int datalen)
|
2001-05-06 18:35:20 +04:00
|
|
|
{
|
|
|
|
unsigned char *p = (unsigned char *) data;
|
|
|
|
unsigned len = (unsigned) datalen;
|
2001-02-24 19:08:56 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* stderr data is just spouted to local stderr and otherwise
|
|
|
|
* ignored.
|
|
|
|
*/
|
|
|
|
if (is_stderr) {
|
|
|
|
fwrite(data, 1, len, stderr);
|
2001-08-25 21:09:23 +04:00
|
|
|
return 0;
|
2001-02-24 19:08:56 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If this is before the real session begins, just return.
|
|
|
|
*/
|
|
|
|
if (!outptr)
|
2001-08-25 21:09:23 +04:00
|
|
|
return 0;
|
2001-02-24 19:08:56 +03:00
|
|
|
|
|
|
|
if (outlen > 0) {
|
2001-05-06 18:35:20 +04:00
|
|
|
unsigned used = outlen;
|
|
|
|
if (used > len)
|
|
|
|
used = len;
|
|
|
|
memcpy(outptr, p, used);
|
|
|
|
outptr += used;
|
|
|
|
outlen -= used;
|
|
|
|
p += used;
|
|
|
|
len -= used;
|
2001-02-24 19:08:56 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (len > 0) {
|
2001-05-06 18:35:20 +04:00
|
|
|
if (pendsize < pendlen + len) {
|
|
|
|
pendsize = pendlen + len + 4096;
|
|
|
|
pending = (pending ? srealloc(pending, pendsize) :
|
|
|
|
smalloc(pendsize));
|
|
|
|
if (!pending)
|
|
|
|
fatalbox("Out of memory");
|
|
|
|
}
|
|
|
|
memcpy(pending + pendlen, p, len);
|
|
|
|
pendlen += len;
|
2001-02-24 19:08:56 +03:00
|
|
|
}
|
2001-08-25 21:09:23 +04:00
|
|
|
|
|
|
|
return 0;
|
2001-02-24 19:08:56 +03:00
|
|
|
}
|
2001-05-06 18:35:20 +04:00
|
|
|
int sftp_recvdata(char *buf, int len)
|
|
|
|
{
|
|
|
|
outptr = (unsigned char *) buf;
|
2001-02-24 19:08:56 +03:00
|
|
|
outlen = len;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* See if the pending-input block contains some of what we
|
|
|
|
* need.
|
|
|
|
*/
|
|
|
|
if (pendlen > 0) {
|
2001-05-06 18:35:20 +04:00
|
|
|
unsigned pendused = pendlen;
|
|
|
|
if (pendused > outlen)
|
|
|
|
pendused = outlen;
|
2001-02-24 19:08:56 +03:00
|
|
|
memcpy(outptr, pending, pendused);
|
2001-05-06 18:35:20 +04:00
|
|
|
memmove(pending, pending + pendused, pendlen - pendused);
|
2001-02-24 19:08:56 +03:00
|
|
|
outptr += pendused;
|
|
|
|
outlen -= pendused;
|
2001-05-06 18:35:20 +04:00
|
|
|
pendlen -= pendused;
|
|
|
|
if (pendlen == 0) {
|
|
|
|
pendsize = 0;
|
|
|
|
sfree(pending);
|
|
|
|
pending = NULL;
|
|
|
|
}
|
|
|
|
if (outlen == 0)
|
|
|
|
return 1;
|
2001-02-24 19:08:56 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
while (outlen > 0) {
|
2001-05-06 18:35:20 +04:00
|
|
|
fd_set readfds;
|
2001-02-24 19:08:56 +03:00
|
|
|
|
2001-05-06 18:35:20 +04:00
|
|
|
FD_ZERO(&readfds);
|
|
|
|
FD_SET(sftp_ssh_socket, &readfds);
|
|
|
|
if (select(1, &readfds, NULL, NULL, NULL) < 0)
|
|
|
|
return 0; /* doom */
|
|
|
|
select_result((WPARAM) sftp_ssh_socket, (LPARAM) FD_READ);
|
2001-02-24 19:08:56 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
2001-05-06 18:35:20 +04:00
|
|
|
int sftp_senddata(char *buf, int len)
|
|
|
|
{
|
|
|
|
back->send((unsigned char *) buf, len);
|
2001-02-24 19:08:56 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Loop through the ssh connection and authentication process.
|
|
|
|
*/
|
2001-05-06 18:35:20 +04:00
|
|
|
static void ssh_sftp_init(void)
|
|
|
|
{
|
2001-02-24 19:08:56 +03:00
|
|
|
if (sftp_ssh_socket == INVALID_SOCKET)
|
|
|
|
return;
|
|
|
|
while (!back->sendok()) {
|
2001-05-06 18:35:20 +04:00
|
|
|
fd_set readfds;
|
|
|
|
FD_ZERO(&readfds);
|
|
|
|
FD_SET(sftp_ssh_socket, &readfds);
|
|
|
|
if (select(1, &readfds, NULL, NULL, NULL) < 0)
|
|
|
|
return; /* doom */
|
|
|
|
select_result((WPARAM) sftp_ssh_socket, (LPARAM) FD_READ);
|
2001-02-24 19:08:56 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *password = NULL;
|
2001-03-12 18:31:53 +03:00
|
|
|
static int get_line(const char *prompt, char *str, int maxlen, int is_pw)
|
2001-02-24 19:08:56 +03:00
|
|
|
{
|
|
|
|
HANDLE hin, hout;
|
2001-03-12 18:31:53 +03:00
|
|
|
DWORD savemode, newmode, i;
|
2001-02-24 19:08:56 +03:00
|
|
|
|
|
|
|
if (password) {
|
2001-05-06 18:35:20 +04:00
|
|
|
static int tried_once = 0;
|
|
|
|
|
|
|
|
if (tried_once) {
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
strncpy(str, password, maxlen);
|
|
|
|
str[maxlen - 1] = '\0';
|
|
|
|
tried_once = 1;
|
|
|
|
return 1;
|
|
|
|
}
|
2001-02-24 19:08:56 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
hin = GetStdHandle(STD_INPUT_HANDLE);
|
|
|
|
hout = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
|
|
if (hin == INVALID_HANDLE_VALUE || hout == INVALID_HANDLE_VALUE) {
|
|
|
|
fprintf(stderr, "Cannot get standard input/output handles\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
GetConsoleMode(hin, &savemode);
|
2001-03-12 18:31:53 +03:00
|
|
|
newmode = savemode | ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT;
|
|
|
|
if (is_pw)
|
2001-05-06 18:35:20 +04:00
|
|
|
newmode &= ~ENABLE_ECHO_INPUT;
|
2001-03-12 18:31:53 +03:00
|
|
|
else
|
2001-05-06 18:35:20 +04:00
|
|
|
newmode |= ENABLE_ECHO_INPUT;
|
2001-03-12 18:31:53 +03:00
|
|
|
SetConsoleMode(hin, newmode);
|
2001-02-24 19:08:56 +03:00
|
|
|
|
|
|
|
WriteFile(hout, prompt, strlen(prompt), &i, NULL);
|
2001-05-06 18:35:20 +04:00
|
|
|
ReadFile(hin, str, maxlen - 1, &i, NULL);
|
2001-02-24 19:08:56 +03:00
|
|
|
|
|
|
|
SetConsoleMode(hin, savemode);
|
|
|
|
|
2001-05-06 18:35:20 +04:00
|
|
|
if ((int) i > maxlen)
|
|
|
|
i = maxlen - 1;
|
|
|
|
else
|
|
|
|
i = i - 2;
|
2001-02-24 19:08:56 +03:00
|
|
|
str[i] = '\0';
|
|
|
|
|
2001-03-12 18:31:53 +03:00
|
|
|
if (is_pw)
|
2001-05-06 18:35:20 +04:00
|
|
|
WriteFile(hout, "\r\n", 2, &i, NULL);
|
2001-02-24 19:08:56 +03:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize the Win$ock driver.
|
|
|
|
*/
|
|
|
|
static void init_winsock(void)
|
|
|
|
{
|
|
|
|
WORD winsock_ver;
|
|
|
|
WSADATA wsadata;
|
|
|
|
|
|
|
|
winsock_ver = MAKEWORD(1, 1);
|
|
|
|
if (WSAStartup(winsock_ver, &wsadata)) {
|
|
|
|
fprintf(stderr, "Unable to initialise WinSock");
|
|
|
|
exit(1);
|
|
|
|
}
|
2001-05-06 18:35:20 +04:00
|
|
|
if (LOBYTE(wsadata.wVersion) != 1 || HIBYTE(wsadata.wVersion) != 1) {
|
2001-02-24 19:08:56 +03:00
|
|
|
fprintf(stderr, "WinSock version is incompatible with 1.1");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Short description of parameters.
|
|
|
|
*/
|
|
|
|
static void usage(void)
|
|
|
|
{
|
|
|
|
printf("PuTTY Secure File Transfer (SFTP) client\n");
|
|
|
|
printf("%s\n", ver);
|
|
|
|
printf("Usage: psftp [options] user@host\n");
|
|
|
|
printf("Options:\n");
|
2001-08-04 18:19:51 +04:00
|
|
|
printf(" -b file use specified batchfile\n");
|
|
|
|
printf(" -bc output batchfile commands\n");
|
|
|
|
printf(" -be don't stop batchfile processing if errors\n");
|
2001-02-24 19:08:56 +03:00
|
|
|
printf(" -v show verbose messages\n");
|
|
|
|
printf(" -P port connect to specified port\n");
|
|
|
|
printf(" -pw passw login with specified password\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2001-12-13 21:42:34 +03:00
|
|
|
* Connect to a host.
|
2001-02-24 19:08:56 +03:00
|
|
|
*/
|
2001-12-13 21:42:34 +03:00
|
|
|
static int psftp_connect(char *userhost, char *user, int portnumber)
|
2001-02-24 19:08:56 +03:00
|
|
|
{
|
2001-12-13 21:42:34 +03:00
|
|
|
char *host, *realhost;
|
2001-02-24 19:08:56 +03:00
|
|
|
char *err;
|
|
|
|
|
|
|
|
/* Separate host and username */
|
|
|
|
host = userhost;
|
|
|
|
host = strrchr(host, '@');
|
|
|
|
if (host == NULL) {
|
|
|
|
host = userhost;
|
|
|
|
} else {
|
|
|
|
*host++ = '\0';
|
|
|
|
if (user) {
|
2001-05-06 18:35:20 +04:00
|
|
|
printf("psftp: multiple usernames specified; using \"%s\"\n",
|
|
|
|
user);
|
2001-02-24 19:08:56 +03:00
|
|
|
} else
|
|
|
|
user = userhost;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Try to load settings for this host */
|
|
|
|
do_defaults(host, &cfg);
|
|
|
|
if (cfg.host[0] == '\0') {
|
|
|
|
/* No settings for this host; use defaults */
|
2001-05-06 18:35:20 +04:00
|
|
|
do_defaults(NULL, &cfg);
|
|
|
|
strncpy(cfg.host, host, sizeof(cfg.host) - 1);
|
|
|
|
cfg.host[sizeof(cfg.host) - 1] = '\0';
|
2001-02-24 19:08:56 +03:00
|
|
|
cfg.port = 22;
|
|
|
|
}
|
|
|
|
|
2001-10-31 00:45:27 +03:00
|
|
|
/*
|
|
|
|
* Trim leading whitespace off the hostname if it's there.
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
int space = strspn(cfg.host, " \t");
|
|
|
|
memmove(cfg.host, cfg.host+space, 1+strlen(cfg.host)-space);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* See if host is of the form user@host */
|
|
|
|
if (cfg.host[0] != '\0') {
|
|
|
|
char *atsign = strchr(cfg.host, '@');
|
|
|
|
/* Make sure we're not overflowing the user field */
|
|
|
|
if (atsign) {
|
|
|
|
if (atsign - cfg.host < sizeof cfg.username) {
|
|
|
|
strncpy(cfg.username, cfg.host, atsign - cfg.host);
|
|
|
|
cfg.username[atsign - cfg.host] = '\0';
|
|
|
|
}
|
|
|
|
memmove(cfg.host, atsign + 1, 1 + strlen(atsign + 1));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Trim a colon suffix off the hostname if it's there.
|
|
|
|
*/
|
|
|
|
cfg.host[strcspn(cfg.host, ":")] = '\0';
|
|
|
|
|
2001-02-24 19:08:56 +03:00
|
|
|
/* Set username */
|
|
|
|
if (user != NULL && user[0] != '\0') {
|
2001-05-06 18:35:20 +04:00
|
|
|
strncpy(cfg.username, user, sizeof(cfg.username) - 1);
|
|
|
|
cfg.username[sizeof(cfg.username) - 1] = '\0';
|
2001-02-24 19:08:56 +03:00
|
|
|
}
|
|
|
|
if (!cfg.username[0]) {
|
|
|
|
printf("login as: ");
|
|
|
|
if (!fgets(cfg.username, sizeof(cfg.username), stdin)) {
|
|
|
|
fprintf(stderr, "psftp: aborting\n");
|
|
|
|
exit(1);
|
|
|
|
} else {
|
|
|
|
int len = strlen(cfg.username);
|
2001-05-06 18:35:20 +04:00
|
|
|
if (cfg.username[len - 1] == '\n')
|
|
|
|
cfg.username[len - 1] = '\0';
|
2001-02-24 19:08:56 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cfg.protocol != PROT_SSH)
|
|
|
|
cfg.port = 22;
|
|
|
|
|
|
|
|
if (portnumber)
|
|
|
|
cfg.port = portnumber;
|
|
|
|
|
|
|
|
/* SFTP uses SSH2 by default always */
|
|
|
|
cfg.sshprot = 2;
|
|
|
|
|
2001-09-13 00:11:48 +04:00
|
|
|
/*
|
|
|
|
* Disable scary things which shouldn't be enabled for simple
|
|
|
|
* things like SCP and SFTP: agent forwarding, port forwarding,
|
|
|
|
* X forwarding.
|
|
|
|
*/
|
|
|
|
cfg.x11_forward = 0;
|
|
|
|
cfg.agentfwd = 0;
|
|
|
|
cfg.portfwd[0] = cfg.portfwd[1] = '\0';
|
|
|
|
|
2001-09-05 23:48:52 +04:00
|
|
|
/* Set up subsystem name. */
|
2001-02-24 19:08:56 +03:00
|
|
|
strcpy(cfg.remote_cmd, "sftp");
|
|
|
|
cfg.ssh_subsys = TRUE;
|
|
|
|
cfg.nopty = TRUE;
|
|
|
|
|
2001-09-05 23:48:52 +04:00
|
|
|
/*
|
|
|
|
* Set up fallback option, for SSH1 servers or servers with the
|
|
|
|
* sftp subsystem not enabled but the server binary installed
|
|
|
|
* in the usual place. We only support fallback on Unix
|
2001-09-05 23:58:25 +04:00
|
|
|
* systems, and we use a kludgy piece of shellery which should
|
|
|
|
* try to find sftp-server in various places (the obvious
|
|
|
|
* systemwide spots /usr/lib and /usr/local/lib, and then the
|
|
|
|
* user's PATH) and finally give up.
|
2001-09-05 23:48:52 +04:00
|
|
|
*
|
2001-09-05 23:58:25 +04:00
|
|
|
* test -x /usr/lib/sftp-server && exec /usr/lib/sftp-server
|
|
|
|
* test -x /usr/local/lib/sftp-server && exec /usr/local/lib/sftp-server
|
|
|
|
* exec sftp-server
|
2001-09-05 23:48:52 +04:00
|
|
|
*
|
|
|
|
* the idea being that this will attempt to use either of the
|
|
|
|
* obvious pathnames and then give up, and when it does give up
|
|
|
|
* it will print the preferred pathname in the error messages.
|
|
|
|
*/
|
|
|
|
cfg.remote_cmd_ptr2 =
|
2001-09-05 23:58:25 +04:00
|
|
|
"test -x /usr/lib/sftp-server && exec /usr/lib/sftp-server\n"
|
|
|
|
"test -x /usr/local/lib/sftp-server && exec /usr/local/lib/sftp-server\n"
|
|
|
|
"exec sftp-server";
|
2001-09-05 23:48:52 +04:00
|
|
|
cfg.ssh_subsys2 = FALSE;
|
|
|
|
|
2001-02-24 19:08:56 +03:00
|
|
|
back = &ssh_backend;
|
|
|
|
|
2001-11-30 00:47:11 +03:00
|
|
|
err = back->init(cfg.host, cfg.port, &realhost, 0);
|
2001-02-24 19:08:56 +03:00
|
|
|
if (err != NULL) {
|
2001-12-13 21:42:34 +03:00
|
|
|
fprintf(stderr, "ssh_init: %s\n", err);
|
2001-02-24 19:08:56 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
ssh_sftp_init();
|
|
|
|
if (verbose && realhost != NULL)
|
|
|
|
printf("Connected to %s\n", realhost);
|
2001-12-13 21:42:34 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Main program. Parse arguments etc.
|
|
|
|
*/
|
|
|
|
int main(int argc, char *argv[])
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int portnumber = 0;
|
|
|
|
char *userhost, *user;
|
|
|
|
int mode = 0;
|
|
|
|
int modeflags = 0;
|
|
|
|
char *batchfile = NULL;
|
|
|
|
|
|
|
|
flags = FLAG_STDERR | FLAG_INTERACTIVE;
|
|
|
|
ssh_get_line = &get_line;
|
|
|
|
init_winsock();
|
|
|
|
sk_init();
|
|
|
|
|
|
|
|
userhost = user = NULL;
|
|
|
|
|
|
|
|
for (i = 1; i < argc; i++) {
|
|
|
|
if (argv[i][0] != '-') {
|
|
|
|
if (userhost)
|
|
|
|
usage();
|
|
|
|
else
|
|
|
|
userhost = dupstr(argv[i]);
|
|
|
|
} else if (strcmp(argv[i], "-v") == 0) {
|
|
|
|
verbose = 1, flags |= FLAG_VERBOSE;
|
|
|
|
} else if (strcmp(argv[i], "-h") == 0 ||
|
|
|
|
strcmp(argv[i], "-?") == 0) {
|
|
|
|
usage();
|
|
|
|
} else if (strcmp(argv[i], "-l") == 0 && i + 1 < argc) {
|
|
|
|
user = argv[++i];
|
|
|
|
} else if (strcmp(argv[i], "-P") == 0 && i + 1 < argc) {
|
|
|
|
portnumber = atoi(argv[++i]);
|
|
|
|
} else if (strcmp(argv[i], "-pw") == 0 && i + 1 < argc) {
|
|
|
|
password = argv[++i];
|
|
|
|
} else if (strcmp(argv[i], "-b") == 0 && i + 1 < argc) {
|
|
|
|
mode = 1;
|
|
|
|
batchfile = argv[++i];
|
2001-12-14 13:06:09 +03:00
|
|
|
} else if (strcmp(argv[i], "-bc") == 0) {
|
2001-12-13 21:42:34 +03:00
|
|
|
modeflags = modeflags | 1;
|
2001-12-14 13:06:09 +03:00
|
|
|
} else if (strcmp(argv[i], "-be") == 0) {
|
2001-12-13 21:42:34 +03:00
|
|
|
modeflags = modeflags | 2;
|
|
|
|
} else if (strcmp(argv[i], "--") == 0) {
|
|
|
|
i++;
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
usage();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
argc -= i;
|
|
|
|
argv += i;
|
|
|
|
back = NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If a user@host string has already been provided, connect to
|
|
|
|
* it now.
|
|
|
|
*/
|
|
|
|
if (userhost) {
|
|
|
|
if (psftp_connect(userhost, user, portnumber))
|
|
|
|
return 1;
|
|
|
|
do_sftp_init();
|
|
|
|
} else {
|
|
|
|
printf("psftp: no hostname specified; use \"open host.name\""
|
|
|
|
" to connect\n");
|
|
|
|
}
|
2001-02-23 21:21:44 +03:00
|
|
|
|
2001-08-04 18:19:51 +04:00
|
|
|
do_sftp(mode, modeflags, batchfile);
|
2001-02-24 19:08:56 +03:00
|
|
|
|
|
|
|
if (back != NULL && back->socket() != NULL) {
|
|
|
|
char ch;
|
|
|
|
back->special(TS_EOF);
|
|
|
|
sftp_recvdata(&ch, 1);
|
|
|
|
}
|
|
|
|
WSACleanup();
|
|
|
|
random_save_seed();
|
|
|
|
|
2001-02-23 21:21:44 +03:00
|
|
|
return 0;
|
|
|
|
}
|