X-Git-Url: https://git.distorted.org.uk/u/mdw/putty/blobdiff_plain/93e86a8b5a53e3d7ea25afdb0eb97ee6a4ed710e..055817455466c8eb60392f30bb7c689763962e17:/psftp.c

diff --git a/psftp.c b/psftp.c
index ac8a938d..ab076795 100644
--- a/psftp.c
+++ b/psftp.c
@@ -41,14 +41,6 @@ static Config cfg;
  */
 
 /*
- * 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).
@@ -208,7 +200,7 @@ int sftp_get_file(char *fname, char *outfname, int recurse, int restart)
     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.
@@ -223,6 +215,7 @@ int sftp_get_file(char *fname, char *outfname, int recurse, int restart)
 	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)) {
@@ -283,8 +276,17 @@ int sftp_get_file(char *fname, char *outfname, int recurse, int restart)
 		    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));
@@ -313,7 +315,11 @@ int sftp_get_file(char *fname, char *outfname, int recurse, int restart)
 	    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)
@@ -334,7 +340,11 @@ int sftp_get_file(char *fname, char *outfname, int recurse, int restart)
 		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);
@@ -415,7 +425,10 @@ int sftp_get_file(char *fname, char *outfname, int recurse, int restart)
 	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;
 	}
 
@@ -493,7 +506,8 @@ int sftp_put_file(char *fname, char *outfname, int recurse, int restart)
 	    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;
 	    }
 	}
@@ -501,13 +515,14 @@ int sftp_put_file(char *fname, char *outfname, int recurse, int restart)
 	/*
 	 * 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;
@@ -559,7 +574,10 @@ int sftp_put_file(char *fname, char *outfname, int recurse, int restart)
 	    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 */
@@ -684,6 +702,146 @@ int sftp_put_file(char *fname, char *outfname, int recurse, int restart)
 }
 
 /* ----------------------------------------------------------------------
+ * 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 {
@@ -708,6 +866,23 @@ int sftp_cmd_quit(struct sftp_command *cmd)
     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].
@@ -718,7 +893,7 @@ int sftp_cmd_ls(struct sftp_command *cmd)
     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;
@@ -733,9 +908,35 @@ int sftp_cmd_ls(struct sftp_command *cmd)
     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;
     }
 
@@ -776,7 +977,8 @@ int sftp_cmd_ls(struct sftp_command *cmd)
 	    }
 
 	    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);
 	}
@@ -802,6 +1004,7 @@ int sftp_cmd_ls(struct sftp_command *cmd)
     }
 
     sfree(cdir);
+    sfree(unwcdir);
 
     return 1;
 }
@@ -870,14 +1073,17 @@ int sftp_cmd_pwd(struct sftp_command *cmd)
 }
 
 /*
- * 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;
 
@@ -895,51 +1101,103 @@ int sftp_general_get(struct sftp_command *cmd, int restart)
 	} 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;
 
@@ -957,39 +1215,83 @@ int sftp_general_put(struct sftp_command *cmd, int restart)
 	} 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)
@@ -1503,6 +1805,14 @@ static struct sftp_cmd_lookup {
 	    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",
@@ -1513,10 +1823,12 @@ static struct sftp_cmd_lookup {
     },
     {
 	"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
     },
     {
@@ -1524,10 +1836,11 @@ static struct sftp_cmd_lookup {
     },
     {
 	"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
     },
     {
@@ -1557,12 +1870,30 @@ static struct sftp_cmd_lookup {
 	    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"
@@ -1579,10 +1910,11 @@ static struct sftp_cmd_lookup {
     },
     {
 	"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
     },
     {
@@ -1597,10 +1929,11 @@ static struct sftp_cmd_lookup {
     },
     {
 	"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
     },
     {
@@ -1613,10 +1946,11 @@ static struct sftp_cmd_lookup {
     },
     {
 	"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
     },
     {
@@ -1721,7 +2055,7 @@ struct sftp_command *sftp_getcmd(FILE *fp, int mode, int modeflags)
 	    printf("psftp> ");
 	line = fgetline(fp);
     } else {
-	line = ssh_sftp_get_cmdline("psftp> ");
+	line = ssh_sftp_get_cmdline("psftp> ", back == NULL);
     }
 
     if (!line || !*line) {
@@ -1859,6 +2193,8 @@ void do_sftp_cleanup()
 	sftp_recvdata(&ch, 1);
 	back->free(backhandle);
 	sftp_cleanup_request();
+	back = NULL;
+	backhandle = NULL;
     }
     if (pwd) {
 	sfree(pwd);
@@ -2110,6 +2446,7 @@ static void usage(void)
     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");
@@ -2432,12 +2769,10 @@ int psftp_main(int argc, char *argv[])
 	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;