*/
/*
- * Determine whether a string is entirely composed of dots.
- */
-static int is_dots(char *str)
-{
- return str[strspn(str, ".")] == '\0';
-}
-
-/*
* 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).
struct fxp_xfer *xfer;
uint64 offset;
FILE *fp;
- int ret;
+ int ret, shown_err = FALSE;
/*
* In recursive mode, see if we're dealing with a directory.
rreq = sftp_find_request(pktin = sftp_recv());
assert(rreq == req);
result = fxp_stat_recv(pktin, rreq, &attrs);
+
if (result &&
(attrs.flags & SSH_FILEXFER_ATTR_PERMISSIONS) &&
(attrs.permissions & 0040000)) {
ournames = sresize(ournames, namesize, struct fxp_name *);
}
for (i = 0; i < names->nnames; i++)
- if (!is_dots(names->names[i].filename))
- ournames[nnames++] = fxp_dup_name(&names->names[i]);
+ if (strcmp(names->names[i].filename, ".") &&
+ strcmp(names->names[i].filename, "..")) {
+ if (!vet_filename(names->names[i].filename)) {
+ printf("ignoring potentially dangerous server-"
+ "supplied filename '%s'\n",
+ names->names[i].filename);
+ } else {
+ ournames[nnames++] =
+ fxp_dup_name(&names->names[i]);
+ }
+ }
fxp_free_names(names);
}
sftp_register(req = fxp_close_send(dirhandle));
while (i < nnames) {
char *nextoutfname;
int ret;
- nextoutfname = dir_file_cat(outfname, ournames[i]->filename);
+ if (outfname)
+ nextoutfname = dir_file_cat(outfname,
+ ournames[i]->filename);
+ else
+ nextoutfname = dupstr(ournames[i]->filename);
ret = (file_type(nextoutfname) == FILE_TYPE_NONEXISTENT);
sfree(nextoutfname);
if (ret)
int ret;
nextfname = dupcat(fname, "/", ournames[i]->filename, NULL);
- nextoutfname = dir_file_cat(outfname, ournames[i]->filename);
+ if (outfname)
+ nextoutfname = dir_file_cat(outfname,
+ ournames[i]->filename);
+ else
+ nextoutfname = dupstr(ournames[i]->filename);
ret = sftp_get_file(nextfname, nextoutfname, recurse, restart);
restart = FALSE; /* after first partial file, do full */
sfree(nextoutfname);
ret = xfer_download_gotpkt(xfer, pktin);
if (ret < 0) {
- printf("error while reading: %s\n", fxp_error());
+ if (!shown_err) {
+ printf("error while reading: %s\n", fxp_error());
+ shown_err = TRUE;
+ }
ret = 0;
}
result = fxp_mkdir_recv(pktin, rreq);
if (!result) {
- printf("%s: create directory: %s\n", outfname, fxp_error());
+ printf("%s: create directory: %s\n",
+ outfname, fxp_error());
return 0;
}
}
/*
* Now get the list of filenames in the local directory.
*/
+ nnames = namesize = 0;
+ ournames = NULL;
+
dh = open_directory(fname);
if (!dh) {
printf("%s: unable to open directory\n", fname);
return 0;
}
- nnames = namesize = 0;
- ournames = NULL;
while ((name = read_filename(dh)) != NULL) {
if (nnames >= namesize) {
namesize += 128;
char *nextfname, *nextoutfname;
int ret;
- nextfname = dir_file_cat(fname, ournames[i]);
+ if (fname)
+ nextfname = dir_file_cat(fname, ournames[i]);
+ else
+ nextfname = dupstr(ournames[i]);
nextoutfname = dupcat(outfname, "/", ournames[i], NULL);
ret = sftp_put_file(nextfname, nextoutfname, recurse, restart);
restart = FALSE; /* after first partial file, do full */
}
/* ----------------------------------------------------------------------
+ * A remote wildcard matcher, providing a similar interface to the
+ * local one in psftp.h.
+ */
+
+typedef struct SftpWildcardMatcher {
+ struct fxp_handle *dirh;
+ struct fxp_names *names;
+ int namepos;
+ char *wildcard, *prefix;
+} SftpWildcardMatcher;
+
+SftpWildcardMatcher *sftp_begin_wildcard_matching(char *name)
+{
+ struct sftp_packet *pktin;
+ struct sftp_request *req, *rreq;
+ char *wildcard;
+ char *unwcdir, *tmpdir, *cdir;
+ int len, check;
+ SftpWildcardMatcher *swcm;
+ struct fxp_handle *dirh;
+
+ /*
+ * We don't handle multi-level wildcards; so we expect to find
+ * a fully specified directory part, followed by a wildcard
+ * after that.
+ */
+ wildcard = stripslashes(name, 0);
+
+ unwcdir = dupstr(name);
+ len = wildcard - name;
+ unwcdir[len] = '\0';
+ if (len > 0 && unwcdir[len-1] == '/')
+ unwcdir[len-1] = '\0';
+ tmpdir = snewn(1 + len, char);
+ check = wc_unescape(tmpdir, unwcdir);
+ sfree(tmpdir);
+
+ if (!check) {
+ printf("Multiple-level wildcards are not supported\n");
+ sfree(unwcdir);
+ return NULL;
+ }
+
+ cdir = canonify(unwcdir);
+
+ sftp_register(req = fxp_opendir_send(cdir));
+ rreq = sftp_find_request(pktin = sftp_recv());
+ assert(rreq == req);
+ dirh = fxp_opendir_recv(pktin, rreq);
+
+ if (dirh) {
+ swcm = snew(SftpWildcardMatcher);
+ swcm->dirh = dirh;
+ swcm->names = NULL;
+ swcm->wildcard = dupstr(wildcard);
+ swcm->prefix = unwcdir;
+ } else {
+ printf("Unable to open %s: %s\n", cdir, fxp_error());
+ swcm = NULL;
+ sfree(unwcdir);
+ }
+
+ sfree(cdir);
+
+ return swcm;
+}
+
+char *sftp_wildcard_get_filename(SftpWildcardMatcher *swcm)
+{
+ struct fxp_name *name;
+ struct sftp_packet *pktin;
+ struct sftp_request *req, *rreq;
+
+ while (1) {
+ if (swcm->names && swcm->namepos >= swcm->names->nnames) {
+ fxp_free_names(swcm->names);
+ swcm->names = NULL;
+ }
+
+ if (!swcm->names) {
+ sftp_register(req = fxp_readdir_send(swcm->dirh));
+ rreq = sftp_find_request(pktin = sftp_recv());
+ assert(rreq == req);
+ swcm->names = fxp_readdir_recv(pktin, rreq);
+
+ if (!swcm->names) {
+ if (fxp_error_type() != SSH_FX_EOF)
+ printf("%s: reading directory: %s\n", swcm->prefix,
+ fxp_error());
+ return NULL;
+ }
+
+ swcm->namepos = 0;
+ }
+
+ assert(swcm->names && swcm->namepos < swcm->names->nnames);
+
+ name = &swcm->names->names[swcm->namepos++];
+
+ if (!strcmp(name->filename, ".") || !strcmp(name->filename, ".."))
+ continue; /* expected bad filenames */
+
+ if (!vet_filename(name->filename)) {
+ printf("ignoring potentially dangerous server-"
+ "supplied filename '%s'\n", name->filename);
+ continue; /* unexpected bad filename */
+ }
+
+ if (!wc_match(swcm->wildcard, name->filename))
+ continue; /* doesn't match the wildcard */
+
+ /*
+ * We have a working filename. Return it.
+ */
+ return dupprintf("%s%s%s", swcm->prefix,
+ swcm->prefix[strlen(swcm->prefix)-1]=='/' ? "" : "/",
+ name->filename);
+ }
+}
+
+void sftp_finish_wildcard_matching(SftpWildcardMatcher *swcm)
+{
+ struct sftp_packet *pktin;
+ struct sftp_request *req, *rreq;
+
+ sftp_register(req = fxp_close_send(swcm->dirh));
+ rreq = sftp_find_request(pktin = sftp_recv());
+ assert(rreq == req);
+ fxp_close_recv(pktin, rreq);
+
+ if (swcm->names)
+ fxp_free_names(swcm->names);
+
+ sfree(swcm->prefix);
+ sfree(swcm->wildcard);
+
+ sfree(swcm);
+}
+
+/* ----------------------------------------------------------------------
* Actual sftp commands.
*/
struct sftp_command {
return -1;
}
+int sftp_cmd_close(struct sftp_command *cmd)
+{
+ if (back == NULL) {
+ printf("psftp: not connected to a host; use \"open host.name\"\n");
+ return 0;
+ }
+
+ if (back != NULL && back->socket(backhandle) != NULL) {
+ char ch;
+ back->special(backhandle, TS_EOF);
+ sftp_recvdata(&ch, 1);
+ }
+ do_sftp_cleanup();
+
+ return 0;
+}
+
/*
* List a directory. If no arguments are given, list pwd; otherwise
* list the directory given in words[1].
struct fxp_names *names;
struct fxp_name **ournames;
int nnames, namesize;
- char *dir, *cdir;
+ char *dir, *cdir, *unwcdir, *wildcard;
struct sftp_packet *pktin;
struct sftp_request *req, *rreq;
int i;
else
dir = cmd->words[1];
+ unwcdir = snewn(1 + strlen(dir), char);
+ if (wc_unescape(unwcdir, dir)) {
+ dir = unwcdir;
+ wildcard = NULL;
+ } else {
+ char *tmpdir;
+ int len, check;
+
+ wildcard = stripslashes(dir, 0);
+ unwcdir = dupstr(dir);
+ len = wildcard - dir;
+ unwcdir[len] = '\0';
+ if (len > 0 && unwcdir[len-1] == '/')
+ unwcdir[len-1] = '\0';
+ tmpdir = snewn(1 + len, char);
+ check = wc_unescape(tmpdir, unwcdir);
+ sfree(tmpdir);
+ if (!check) {
+ printf("Multiple-level wildcards are not supported\n");
+ sfree(unwcdir);
+ return 0;
+ }
+ dir = unwcdir;
+ }
+
cdir = canonify(dir);
if (!cdir) {
printf("%s: %s\n", dir, fxp_error());
+ sfree(unwcdir);
return 0;
}
}
for (i = 0; i < names->nnames; i++)
- ournames[nnames++] = fxp_dup_name(&names->names[i]);
+ if (!wildcard || wc_match(wildcard, names->names[i].filename))
+ ournames[nnames++] = fxp_dup_name(&names->names[i]);
fxp_free_names(names);
}
}
sfree(cdir);
+ sfree(unwcdir);
return 1;
}
}
/*
- * 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.
+ * Get a file and save it at the local end. We have three very
+ * similar commands here. The basic one is `get'; `reget' differs
+ * in that it checks for the existence of the destination file and
+ * starts from where a previous aborted transfer left off; `mget'
+ * differs in that it interprets all its arguments as files to
+ * transfer (never as a different local name for a remote file) and
+ * can handle wildcards.
*/
-int sftp_general_get(struct sftp_command *cmd, int restart)
+int sftp_general_get(struct sftp_command *cmd, int restart, int multiple)
{
- char *fname, *origfname, *outfname;
+ char *fname, *unwcfname, *origfname, *origwfname, *outfname;
int i, ret;
int recurse = FALSE;
} else if (!strcmp(cmd->words[i], "-r")) {
recurse = TRUE;
} else {
- printf("get: unrecognised option '%s'\n", cmd->words[i]);
+ printf("%s: unrecognised option '%s'\n", cmd->words[0], cmd->words[i]);
return 0;
}
i++;
}
if (i >= cmd->nwords) {
- printf("get: expects a filename\n");
+ printf("%s: expects a filename\n", cmd->words[0]);
return 0;
}
- origfname = cmd->words[i++];
- fname = canonify(origfname);
- if (!fname) {
- printf("%s: %s\n", origfname, fxp_error());
- return 0;
- }
+ ret = 1;
+ do {
+ SftpWildcardMatcher *swcm;
- outfname = (i >= cmd->nwords ?
- stripslashes(origfname, 0) : cmd->words[i++]);
+ origfname = cmd->words[i++];
+ unwcfname = snewn(strlen(origfname)+1, char);
- ret = sftp_get_file(fname, outfname, recurse, restart);
+ if (multiple && !wc_unescape(unwcfname, origfname)) {
+ swcm = sftp_begin_wildcard_matching(origfname);
+ if (!swcm) {
+ sfree(unwcfname);
+ continue;
+ }
+ origwfname = sftp_wildcard_get_filename(swcm);
+ if (!origwfname) {
+ /* Politely warn the user that nothing matched. */
+ printf("%s: nothing matched\n", origfname);
+ sftp_finish_wildcard_matching(swcm);
+ sfree(unwcfname);
+ continue;
+ }
+ } else {
+ origwfname = origfname;
+ swcm = NULL;
+ }
- sfree(fname);
+ while (origwfname) {
+ fname = canonify(origwfname);
+
+ if (!fname) {
+ printf("%s: %s\n", origwfname, fxp_error());
+ sfree(unwcfname);
+ return 0;
+ }
+
+ if (!multiple && i < cmd->nwords)
+ outfname = cmd->words[i++];
+ else
+ outfname = stripslashes(origwfname, 0);
+
+ ret = sftp_get_file(fname, outfname, recurse, restart);
+
+ sfree(fname);
+
+ if (swcm) {
+ sfree(origwfname);
+ origwfname = sftp_wildcard_get_filename(swcm);
+ } else {
+ origwfname = NULL;
+ }
+ }
+ sfree(unwcfname);
+ if (swcm)
+ sftp_finish_wildcard_matching(swcm);
+ if (!ret)
+ return ret;
+
+ } while (multiple && i < cmd->nwords);
return ret;
}
int sftp_cmd_get(struct sftp_command *cmd)
{
- return sftp_general_get(cmd, 0);
+ return sftp_general_get(cmd, 0, 0);
+}
+int sftp_cmd_mget(struct sftp_command *cmd)
+{
+ return sftp_general_get(cmd, 0, 1);
}
int sftp_cmd_reget(struct sftp_command *cmd)
{
- return sftp_general_get(cmd, 1);
+ return sftp_general_get(cmd, 1, 0);
}
/*
- * 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.
+ * Send a file and store it at the remote end. We have three very
+ * similar commands here. The basic one is `put'; `reput' differs
+ * in that it checks for the existence of the destination file and
+ * starts from where a previous aborted transfer left off; `mput'
+ * differs in that it interprets all its arguments as files to
+ * transfer (never as a different remote name for a local file) and
+ * can handle wildcards.
*/
-int sftp_general_put(struct sftp_command *cmd, int restart)
+int sftp_general_put(struct sftp_command *cmd, int restart, int multiple)
{
- char *fname, *origoutfname, *outfname;
+ char *fname, *wfname, *origoutfname, *outfname;
int i, ret;
int recurse = FALSE;
} else if (!strcmp(cmd->words[i], "-r")) {
recurse = TRUE;
} else {
- printf("put: unrecognised option '%s'\n", cmd->words[i]);
+ printf("%s: unrecognised option '%s'\n", cmd->words[0], cmd->words[i]);
return 0;
}
i++;
}
if (i >= cmd->nwords) {
- printf("put: expects a filename\n");
+ printf("%s: expects a filename\n", cmd->words[0]);
return 0;
}
- fname = cmd->words[i++];
- origoutfname = (i >= cmd->nwords ?
- stripslashes(fname, 1) : cmd->words[i++]);
- outfname = canonify(origoutfname);
- if (!outfname) {
- printf("%s: %s\n", origoutfname, fxp_error());
- return 0;
- }
+ ret = 1;
+ do {
+ WildcardMatcher *wcm;
+ fname = cmd->words[i++];
+
+ if (multiple && test_wildcard(fname, FALSE) == WCTYPE_WILDCARD) {
+ wcm = begin_wildcard_matching(fname);
+ wfname = wildcard_get_filename(wcm);
+ if (!wfname) {
+ /* Politely warn the user that nothing matched. */
+ printf("%s: nothing matched\n", fname);
+ finish_wildcard_matching(wcm);
+ continue;
+ }
+ } else {
+ wfname = fname;
+ wcm = NULL;
+ }
+
+ while (wfname) {
+ if (!multiple && i < cmd->nwords)
+ origoutfname = cmd->words[i++];
+ else
+ origoutfname = stripslashes(wfname, 1);
+
+ outfname = canonify(origoutfname);
+ if (!outfname) {
+ printf("%s: %s\n", origoutfname, fxp_error());
+ if (wcm) {
+ sfree(wfname);
+ finish_wildcard_matching(wcm);
+ }
+ return 0;
+ }
+ ret = sftp_put_file(wfname, outfname, recurse, restart);
+ sfree(outfname);
+
+ if (wcm) {
+ sfree(wfname);
+ wfname = wildcard_get_filename(wcm);
+ } else {
+ wfname = NULL;
+ }
+ }
+
+ if (wcm)
+ finish_wildcard_matching(wcm);
- ret = sftp_put_file(fname, outfname, recurse, restart);
+ if (!ret)
+ return ret;
- sfree(outfname);
+ } while (multiple && i < cmd->nwords);
return ret;
}
int sftp_cmd_put(struct sftp_command *cmd)
{
- return sftp_general_put(cmd, 0);
+ return sftp_general_put(cmd, 0, 0);
+}
+int sftp_cmd_mput(struct sftp_command *cmd)
+{
+ return sftp_general_put(cmd, 0, 1);
}
int sftp_cmd_reput(struct sftp_command *cmd)
{
- return sftp_general_put(cmd, 1);
+ return sftp_general_put(cmd, 1, 0);
}
int sftp_cmd_mkdir(struct sftp_command *cmd)
sftp_cmd_chmod
},
{
+ "close", TRUE, "finish your SFTP session but do not quit PSFTP",
+ "\n"
+ " Terminates your SFTP session, but does not quit the PSFTP\n"
+ " program. You can then use \"open\" to start another SFTP\n"
+ " session, to the same server or to a different one.\n",
+ sftp_cmd_close
+ },
+ {
"del", TRUE, "delete a file",
" <filename>\n"
" Delete a file.\n",
},
{
"dir", TRUE, "list contents of a remote directory",
- " [ <directory-name> ]\n"
+ " [ <directory-name> ]/[ <wildcard> ]\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",
+ " is assumed.\n"
+ " If <wildcard> is given, it is treated as a set of files to\n"
+ " list; otherwise, all files are listed.\n",
sftp_cmd_ls
},
{
},
{
"get", TRUE, "download a file from the server to your local machine",
- " <filename> [ <local-filename> ]\n"
+ " [ -r ] [ -- ] <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",
+ " argument <local-filename>.\n"
+ " If -r specified, recursively fetch a directory.\n",
sftp_cmd_get
},
{
sftp_cmd_ls
},
{
+ "mget", TRUE, "download multiple files at once",
+ " [ -r ] [ -- ] <filename-or-wildcard> [ <filename-or-wildcard>... ]\n"
+ " Downloads many files from the server, storing each one under\n"
+ " the same name it has on the server side. You can use wildcards\n"
+ " such as \"*.c\" to specify lots of files at once.\n"
+ " If -r specified, recursively fetch files and directories.\n",
+ sftp_cmd_mget
+ },
+ {
"mkdir", TRUE, "create a directory on the remote server",
" <directory-name>\n"
" Creates a directory with the given name on the server.\n",
sftp_cmd_mkdir
},
{
+ "mput", TRUE, "upload multiple files at once",
+ " [ -r ] [ -- ] <filename-or-wildcard> [ <filename-or-wildcard>... ]\n"
+ " Uploads many files to the server, storing each one under the\n"
+ " same name it has on the client side. You can use wildcards\n"
+ " such as \"*.c\" to specify lots of files at once.\n"
+ " If -r specified, recursively store files and directories.\n",
+ sftp_cmd_mput
+ },
+ {
"mv", TRUE, "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"
},
{
"put", TRUE, "upload a file from your local machine to the server",
- " <filename> [ <remote-filename> ]\n"
+ " [ -r ] [ -- ] <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",
+ " argument <remote-filename>.\n"
+ " If -r specified, recursively store a directory.\n",
sftp_cmd_put
},
{
},
{
"reget", TRUE, "continue downloading a file",
- " <filename> [ <local-filename> ]\n"
+ " [ -r ] [ -- ] <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",
+ " file. This is for resuming a download that was interrupted.\n"
+ " If -r specified, resume interrupted \"get -r\".\n",
sftp_cmd_reget
},
{
},
{
"reput", TRUE, "continue uploading a file",
- " <filename> [ <remote-filename> ]\n"
+ " [ -r ] [ -- ] <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",
+ " file. This is for resuming an upload that was interrupted.\n"
+ " If -r specified, resume interrupted \"put -r\".\n",
sftp_cmd_reput
},
{
printf("psftp> ");
line = fgetline(fp);
} else {
- line = ssh_sftp_get_cmdline("psftp> ");
+ line = ssh_sftp_get_cmdline("psftp> ", back == NULL);
}
if (!line || !*line) {
sftp_recvdata(&ch, 1);
back->free(backhandle);
sftp_cleanup_request();
+ back = NULL;
+ backhandle = NULL;
}
if (pwd) {
sfree(pwd);
printf(" -P port connect to specified port\n");
printf(" -pw passw login with specified password\n");
printf(" -1 -2 force use of particular SSH protocol version\n");
+ printf(" -4 -6 force use of IPv4 or IPv6\n");
printf(" -C enable compression\n");
printf(" -i key private key file for authentication\n");
printf(" -batch disable all interactive prompts\n");
back->special(backhandle, TS_EOF);
sftp_recvdata(&ch, 1);
}
+ do_sftp_cleanup();
random_save_seed();
cmdline_cleanup();
console_provide_logctx(NULL);
- do_sftp_cleanup();
- backhandle = NULL;
- back = NULL;
sk_cleanup();
return 0;