static int main_cmd_is_sftp = 0;
static int fallback_cmd_is_sftp = 0;
static int using_sftp = 0;
+static int uploading = 0;
static Backend *back;
static void *backhandle;
static Conf *conf;
int sent_eof = FALSE;
-static void source(char *src);
-static void rsource(char *src);
-static void sink(char *targ, char *src);
+static void source(const char *src);
+static void rsource(const char *src);
+static void sink(const char *targ, const char *src);
const char *const appname = "PSCP";
*/
#define MAX_SCP_BUFSIZE 16384
-void ldisc_send(void *handle, char *buf, int len, int interactive)
-{
- /*
- * This is only here because of the calls to ldisc_send(NULL,
- * 0) in ssh.c. Nothing in PSCP actually needs to use the ldisc
- * as an ldisc. So if we get called with any real data, I want
- * to know about it.
- */
- assert(len == 0);
-}
+void ldisc_echoedit_update(void *handle) { }
-static void tell_char(FILE * stream, char c)
+static void tell_char(FILE *stream, char c)
{
fputc(c, stream);
}
-static void tell_str(FILE * stream, char *str)
+static void tell_str(FILE *stream, const char *str)
{
unsigned int i;
tell_char(stream, str[i]);
}
-static void tell_user(FILE * stream, char *fmt, ...)
+static void tell_user(FILE *stream, const char *fmt, ...)
{
char *str, *str2;
va_list ap;
/*
* Print an error message and perform a fatal exit.
*/
-void fatalbox(char *fmt, ...)
+void fatalbox(const char *fmt, ...)
{
char *str, *str2;
va_list ap;
cleanup_exit(1);
}
-void modalfatalbox(char *fmt, ...)
+void modalfatalbox(const char *fmt, ...)
{
char *str, *str2;
va_list ap;
cleanup_exit(1);
}
-void connection_fatal(void *frontend, char *fmt, ...)
+void nonfatal(const char *fmt, ...)
+{
+ char *str, *str2;
+ va_list ap;
+ va_start(ap, fmt);
+ str = dupvprintf(fmt, ap);
+ str2 = dupcat("Error: ", str, "\n", NULL);
+ sfree(str);
+ va_end(ap);
+ tell_str(stderr, str2);
+ sfree(str2);
+ errs++;
+}
+void connection_fatal(void *frontend, const char *fmt, ...)
{
char *str, *str2;
va_list ap;
int from_backend_eof(void *frontend)
{
/*
- * We expect to be the party deciding when to close the
+ * We usually expect to be the party deciding when to close the
* connection, so if we see EOF before we sent it ourselves, we
- * should panic.
+ * should panic. The exception is if we're using old-style scp and
+ * downloading rather than uploading.
*/
- if (!sent_eof) {
+ if ((using_sftp || uploading) && !sent_eof) {
connection_fatal(frontend,
"Received unexpected end-of-file from server");
}
/*
* Print an error message and exit after closing the SSH link.
*/
-static void bump(char *fmt, ...)
+static void bump(const char *fmt, ...)
{
char *str, *str2;
va_list ap;
bump("Empty host name");
/*
- * Remove fiddly bits of address: remove a colon suffix, and
- * the square brackets around an IPv6 literal address.
+ * Remove a colon suffix.
*/
- if (host[0] == '[') {
- host++;
- host[strcspn(host, "]")] = '\0';
- } else {
- host[strcspn(host, ":")] = '\0';
- }
+ host[host_strcspn(host, ":")] = '\0';
/*
* If we haven't loaded session details already (e.g., from -load),
console_provide_logctx(logctx);
ssh_scp_init();
if (verbose && realhost != NULL && errs == 0)
- tell_user(stderr, "Connected to %s\n", realhost);
+ tell_user(stderr, "Connected to %s", realhost);
sfree(realhost);
}
/*
* Update statistic information about current file.
*/
-static void print_stats(char *name, uint64 size, uint64 done,
+static void print_stats(const char *name, uint64 size, uint64 done,
time_t start, time_t now)
{
float ratebs;
if (str[0] == '\0' || str[0] == ':' ||
(str[0] != '[' && str[1] == ':'))
return (NULL);
- while (*str != '\0' && *str != ':' && *str != '/' && *str != '\\') {
- if (*str == '[') {
- /* Skip over IPv6 literal addresses
- * (eg: 'jeroen@[2001:db8::1]:myfile.txt') */
- char *ipv6_end = strchr(str, ']');
- if (ipv6_end) {
- str = ipv6_end;
- }
- }
- str++;
- }
+ str += host_strcspn(str, ":/\\");
if (*str == ':')
return (str);
else
/*
* Return a pointer to the portion of str that comes after the last
* slash (or backslash or colon, if `local' is TRUE).
+ *
+ * This function has the annoying strstr() property of taking a const
+ * char * and returning a char *. You should treat it as if it was a
+ * pair of overloaded functions, one mapping mutable->mutable and the
+ * other const->const :-(
*/
-static char *stripslashes(char *str, int local)
+static char *stripslashes(const char *str, int local)
{
char *p;
if (p) str = p+1;
}
- return str;
+ return (char *)str;
}
/*
} while (p < sizeof(rbuf) && ch != '\n');
rbuf[p - 1] = '\0';
if (resp == 1)
- tell_user(stderr, "%s\n", rbuf);
+ tell_user(stderr, "%s", rbuf);
else
bump("%s", rbuf);
errs++;
const struct fxp_name *b = (const struct fxp_name *) bv;
return strcmp(a->filename, b->filename);
}
-void scp_sftp_listdir(char *dirname)
+void scp_sftp_listdir(const char *dirname)
{
struct fxp_handle *dirh;
struct fxp_names *names;
*/
for (i = 0; i < nnames; i++)
printf("%s\n", ournames[i].longname);
+
+ sfree(ournames);
}
}
static struct fxp_xfer *scp_sftp_xfer;
static uint64 scp_sftp_fileoffset;
-int scp_source_setup(char *target, int shouldbedir)
+int scp_source_setup(const char *target, int shouldbedir)
{
if (using_sftp) {
/*
}
}
-int scp_send_filename(char *name, uint64 size, int permissions)
+int scp_send_filename(const char *name, uint64 size, int permissions)
{
if (using_sftp) {
char *fullname;
if (!scp_sftp_filehandle) {
tell_user(stderr, "pscp: unable to open %s: %s",
fullname, fxp_error());
+ sfree(fullname);
errs++;
return 1;
}
pktin = sftp_recv();
ret = xfer_upload_gotpkt(scp_sftp_xfer, pktin);
if (ret <= 0) {
- tell_user(stderr, "error while writing: %s\n", fxp_error());
+ tell_user(stderr, "error while writing: %s", fxp_error());
+ if (ret == INT_MIN) /* pktin not even freed */
+ sfree(pktin);
errs++;
return 1;
}
pktin = sftp_recv();
ret = xfer_upload_gotpkt(scp_sftp_xfer, pktin);
if (ret <= 0) {
- tell_user(stderr, "error while writing: %s\n", fxp_error());
+ tell_user(stderr, "error while writing: %s", fxp_error());
+ if (ret == INT_MIN) /* pktin not even freed */
+ sfree(pktin);
errs++;
return 1;
}
pktin = sftp_wait_for_reply(req);
ret = fxp_fsetstat_recv(pktin, req);
if (!ret) {
- tell_user(stderr, "unable to set file times: %s\n", fxp_error());
+ tell_user(stderr, "unable to set file times: %s", fxp_error());
errs++;
}
}
scp_sftp_remotepath = data;
}
-int scp_send_dirname(char *name, int modes)
+int scp_send_dirname(const char *name, int modes)
{
if (using_sftp) {
char *fullname;
!(attrs.permissions & 0040000)) {
tell_user(stderr, "unable to create directory %s: %s",
fullname, err);
+ sfree(fullname);
errs++;
return 1;
}
* right at the start, whereas scp_sink_init is called to
* initialise every level of recursion in the protocol.
*/
-int scp_sink_setup(char *source, int preserve, int recursive)
+int scp_sink_setup(const char *source, int preserve, int recursive)
{
if (using_sftp) {
char *newsource;
if (!wc_unescape(newsource, source)) {
/* Yes, here we go; it's a wildcard. Bah. */
char *dupsource, *lastpart, *dirpart, *wildcard;
+
+ sfree(newsource);
+
dupsource = dupstr(source);
lastpart = stripslashes(dupsource, 0);
wildcard = dupstr(lastpart);
if (!ret || !(attrs.flags & SSH_FILEXFER_ATTR_PERMISSIONS)) {
tell_user(stderr, "unable to identify %s: %s", fname,
ret ? "file type not supplied" : fxp_error());
+ if (must_free_fname) sfree(fname);
errs++;
return 1;
}
dirhandle = fxp_opendir_recv(pktin, req);
if (!dirhandle) {
- tell_user(stderr, "scp: unable to open directory %s: %s",
+ tell_user(stderr, "pscp: unable to open directory %s: %s",
fname, fxp_error());
if (must_free_fname) sfree(fname);
errs++;
if (names == NULL) {
if (fxp_error_type() == SSH_FX_EOF)
break;
- tell_user(stderr, "scp: reading directory %s: %s\n",
+ tell_user(stderr, "pscp: reading directory %s: %s",
fname, fxp_error());
req = fxp_close_send(dirhandle);
*/
} else if (!vet_filename(names->names[i].filename)) {
tell_user(stderr, "ignoring potentially dangerous server-"
- "supplied filename '%s'\n",
+ "supplied filename '%s'",
names->names[i].filename);
} else
ournames[nnames++] = names->names[i];
act->buf[i - 1] = '\0';
switch (action) {
case '\01': /* error */
- tell_user(stderr, "%s\n", act->buf);
+ tell_user(stderr, "%s", act->buf);
errs++;
continue; /* go round again */
case '\02': /* fatal error */
ret = xfer_download_gotpkt(scp_sftp_xfer, pktin);
if (ret <= 0) {
tell_user(stderr, "pscp: error while reading: %s", fxp_error());
+ if (ret == INT_MIN) /* pktin not even freed */
+ sfree(pktin);
errs++;
return -1;
}
ret = xfer_download_gotpkt(scp_sftp_xfer, pktin);
if (ret <= 0) {
tell_user(stderr, "pscp: error while reading: %s", fxp_error());
+ if (ret == INT_MIN) /* pktin not even freed */
+ sfree(pktin);
errs++;
return -1;
}
va_start(ap, fmt);
errs++;
str = dupvprintf(fmt, ap);
- str2 = dupcat("scp: ", str, "\n", NULL);
+ str2 = dupcat("pscp: ", str, "\n", NULL);
sfree(str);
scp_send_errmsg(str2);
tell_user(stderr, "%s", str2);
/*
* Execute the source part of the SCP protocol.
*/
-static void source(char *src)
+static void source(const char *src)
{
uint64 size;
unsigned long mtime, atime;
long permissions;
- char *last;
+ const char *last;
RFile *f;
int attr;
uint64 i;
/*
* Avoid . and .. directories.
*/
- char *p;
+ const char *p;
p = strrchr(src, '/');
if (!p)
p = strrchr(src, '\\');
return;
}
if (preserve) {
- if (scp_send_filetimes(mtime, atime))
+ if (scp_send_filetimes(mtime, atime)) {
+ close_rfile(f);
return;
+ }
}
if (verbose) {
uint64_decimal(size, sizestr);
tell_user(stderr, "Sending file %s, size=%s", last, sizestr);
}
- if (scp_send_filename(last, size, permissions))
+ if (scp_send_filename(last, size, permissions)) {
+ close_rfile(f);
return;
+ }
stat_bytes = uint64_make(0,0);
stat_starttime = time(NULL);
/*
* Recursively send the contents of a directory.
*/
-static void rsource(char *src)
+static void rsource(const char *src)
{
- char *last;
+ const char *last;
char *save_target;
DirHandle *dir;
/*
* Execute the sink part of the SCP protocol.
*/
-static void sink(char *targ, char *src)
+static void sink(const char *targ, const char *src)
{
char *destfname;
int targisdir = 0;
if (act.action == SCP_SINK_DIR) {
if (exists && attr != FILE_TYPE_DIRECTORY) {
run_err("%s: Not a directory", destfname);
+ sfree(destfname);
continue;
}
if (!exists) {
if (!create_directory(destfname)) {
run_err("%s: Cannot create directory", destfname);
+ sfree(destfname);
continue;
}
}
sink(destfname, NULL);
/* can we set the timestamp for directories ? */
+ sfree(destfname);
continue;
}
f = open_new_file(destfname, act.permissions);
if (f == NULL) {
run_err("%s: Cannot create file", destfname);
+ sfree(destfname);
continue;
}
- if (scp_accept_filexfer())
+ if (scp_accept_filexfer()) {
+ sfree(destfname);
+ close_wfile(f);
return;
+ }
stat_bytes = uint64_make(0, 0);
stat_starttime = time(NULL);
close_wfile(f);
if (wrerror) {
run_err("%s: Write error", destfname);
+ sfree(destfname);
continue;
}
(void) scp_finish_filerecv();
*/
static void toremote(int argc, char *argv[])
{
- char *src, *targ, *host, *user;
+ char *src, *wtarg, *host, *user;
+ const char *targ;
char *cmd;
int i, wc_type;
- targ = argv[argc - 1];
+ uploading = 1;
+
+ wtarg = argv[argc - 1];
/* Separate host from filename */
- host = targ;
- targ = colon(targ);
- if (targ == NULL)
- bump("targ == NULL in toremote()");
- *targ++ = '\0';
- if (*targ == '\0')
- targ = ".";
+ host = wtarg;
+ wtarg = colon(wtarg);
+ if (wtarg == NULL)
+ bump("wtarg == NULL in toremote()");
+ *wtarg++ = '\0';
/* Substitute "." for empty target */
+ if (*wtarg == '\0')
+ targ = ".";
+ else
+ targ = wtarg;
/* Separate host and username */
user = host;
*/
static void tolocal(int argc, char *argv[])
{
- char *src, *targ, *host, *user;
+ char *wsrc, *host, *user;
+ const char *src, *targ;
char *cmd;
+ uploading = 0;
+
if (argc != 2)
bump("More than one remote source not supported");
- src = argv[0];
+ wsrc = argv[0];
targ = argv[1];
/* Separate host from filename */
- host = src;
- src = colon(src);
- if (src == NULL)
+ host = wsrc;
+ wsrc = colon(wsrc);
+ if (wsrc == NULL)
bump("Local to local copy not supported");
- *src++ = '\0';
- if (*src == '\0')
- src = ".";
+ *wsrc++ = '\0';
/* Substitute "." for empty filename */
+ if (*wsrc == '\0')
+ src = ".";
+ else
+ src = wsrc;
/* Separate username and hostname */
user = host;
*/
static void get_dir_list(int argc, char *argv[])
{
- char *src, *host, *user;
- char *cmd, *p, *q;
+ char *wsrc, *host, *user;
+ const char *src;
+ char *cmd, *p;
+ const char *q;
char c;
- src = argv[0];
+ wsrc = argv[0];
/* Separate host from filename */
- host = src;
- src = colon(src);
- if (src == NULL)
+ host = wsrc;
+ wsrc = colon(wsrc);
+ if (wsrc == NULL)
bump("Local file listing not supported");
- *src++ = '\0';
- if (*src == '\0')
- src = ".";
+ *wsrc++ = '\0';
/* Substitute "." for empty filename */
+ if (*wsrc == '\0')
+ src = ".";
+ else
+ src = wsrc;
/* Separate username and hostname */
user = host;
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(" -i key private key file for user authentication\n");
printf(" -noagent disable use of Pageant\n");
printf(" -agent enable use of Pageant\n");
+ printf(" -hostkey aa:bb:cc:...\n");
+ printf(" manually specify a host key (may be repeated)\n");
printf(" -batch disable all interactive prompts\n");
printf(" -unsafe allow server-side wildcards (DANGEROUS)\n");
printf(" -sftp force use of SFTP protocol\n");
cleanup_exit(1);
}
-void cmdline_error(char *p, ...)
+void cmdline_error(const char *p, ...)
{
va_list ap;
fprintf(stderr, "pscp: ");
exit(1);
}
+const int share_can_be_downstream = TRUE;
+const int share_can_be_upstream = FALSE;
+
/*
* Main program. (Called `psftp_main' because it gets called from
* *sftp.c; bit silly, I know, but it had to be called _something_.)