2 * scp.c - Scp (Secure Copy) client for PuTTY.
3 * Joris van Rantwijk, Simon Tatham
5 * This is mainly based on ssh-1.2.26/scp.c by Timo Rinne & Tatu Ylonen.
6 * They, in turn, used stuff from BSD rcp.
8 * Adaptations to enable connecting a GUI by L. Gunnarsson - Sept 2000
25 /* GUI Adaptation - Sept 2000 */
29 #define PUTTY_DO_GLOBALS
36 #define TIME_POSIX_TO_WIN(t, ft) (*(LONGLONG*)&(ft) = \
37 ((LONGLONG) (t) + (LONGLONG) 11644473600) * (LONGLONG) 10000000)
38 #define TIME_WIN_TO_POSIX(ft, t) ((t) = (unsigned long) \
39 ((*(LONGLONG*)&(ft)) / (LONGLONG) 10000000 - (LONGLONG) 11644473600))
41 /* GUI Adaptation - Sept 2000 */
42 #define WM_APP_BASE 0x8000
43 #define WM_STD_OUT_CHAR ( WM_APP_BASE+400 )
44 #define WM_STD_ERR_CHAR ( WM_APP_BASE+401 )
45 #define WM_STATS_CHAR ( WM_APP_BASE+402 )
46 #define WM_STATS_SIZE ( WM_APP_BASE+403 )
47 #define WM_STATS_PERCENT ( WM_APP_BASE+404 )
48 #define WM_STATS_ELAPSED ( WM_APP_BASE+405 )
49 #define WM_RET_ERR_CNT ( WM_APP_BASE+406 )
50 #define WM_LS_RET_ERR_CNT ( WM_APP_BASE+407 )
53 static int verbose = 0;
54 static int recursive = 0;
55 static int preserve = 0;
56 static int targetshouldbedirectory = 0;
57 static int statistics = 1;
58 static int portnumber = 0;
59 static int prev_stats_len = 0;
60 static int scp_unsafe_mode = 0;
61 static char *password = NULL;
63 /* GUI Adaptation - Sept 2000 */
64 #define NAME_STR_MAX 2048
65 static char statname[NAME_STR_MAX + 1];
66 static unsigned long statsize = 0;
67 static int statperct = 0;
68 static unsigned long statelapsed = 0;
69 static int gui_mode = 0;
70 static char *gui_hwnd = NULL;
71 static int using_sftp = 0;
73 static void source(char *src);
74 static void rsource(char *src);
75 static void sink(char *targ, char *src);
76 /* GUI Adaptation - Sept 2000 */
77 static void tell_char(FILE * stream, char c);
78 static void tell_str(FILE * stream, char *str);
79 static void tell_user(FILE * stream, char *fmt, ...);
80 static void gui_update_stats(char *name, unsigned long size,
81 int percentage, unsigned long elapsed);
84 * The maximum amount of queued data we accept before we stop and
85 * wait for the server to process some.
87 #define MAX_SCP_BUFSIZE 16384
89 void logevent(char *string)
93 void ldisc_send(char *buf, int len)
96 * This is only here because of the calls to ldisc_send(NULL,
97 * 0) in ssh.c. Nothing in PSCP actually needs to use the ldisc
98 * as an ldisc. So if we get called with any real data, I want
104 void verify_ssh_host_key(char *host, int port, char *keytype,
105 char *keystr, char *fingerprint)
111 static const char absentmsg[] =
112 "The server's host key is not cached in the registry. You\n"
113 "have no guarantee that the server is the computer you\n"
115 "The server's key fingerprint is:\n"
117 "If you trust this host, enter \"y\" to add the key to\n"
118 "PuTTY's cache and carry on connecting.\n"
119 "If you want to carry on connecting just once, without\n"
120 "adding the key to the cache, enter \"n\".\n"
121 "If you do not trust this host, press Return to abandon the\n"
123 "Store key in cache? (y/n) ";
125 static const char wrongmsg[] =
126 "WARNING - POTENTIAL SECURITY BREACH!\n"
127 "The server's host key does not match the one PuTTY has\n"
128 "cached in the registry. This means that either the\n"
129 "server administrator has changed the host key, or you\n"
130 "have actually connected to another computer pretending\n"
131 "to be the server.\n"
132 "The new key fingerprint is:\n"
134 "If you were expecting this change and trust the new key,\n"
135 "enter \"y\" to update PuTTY's cache and continue connecting.\n"
136 "If you want to carry on connecting but without updating\n"
137 "the cache, enter \"n\".\n"
138 "If you want to abandon the connection completely, press\n"
139 "Return to cancel. Pressing Return is the ONLY guaranteed\n"
141 "Update cached key? (y/n, Return cancels connection) ";
143 static const char abandoned[] = "Connection abandoned.\n";
148 * Verify the key against the registry.
150 ret = verify_host_key(host, port, keytype, keystr);
152 if (ret == 0) /* success - key matched OK */
155 if (ret == 2) { /* key was different */
156 fprintf(stderr, wrongmsg, fingerprint);
159 if (ret == 1) { /* key was absent */
160 fprintf(stderr, absentmsg, fingerprint);
164 hin = GetStdHandle(STD_INPUT_HANDLE);
165 GetConsoleMode(hin, &savemode);
166 SetConsoleMode(hin, (savemode | ENABLE_ECHO_INPUT |
167 ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT));
168 ReadFile(hin, line, sizeof(line) - 1, &i, NULL);
169 SetConsoleMode(hin, savemode);
171 if (line[0] != '\0' && line[0] != '\r' && line[0] != '\n') {
172 if (line[0] == 'y' || line[0] == 'Y')
173 store_host_key(host, port, keytype, keystr);
175 fprintf(stderr, abandoned);
181 * Ask whether the selected cipher is acceptable (since it was
182 * below the configured 'warn' threshold).
183 * cs: 0 = both ways, 1 = client->server, 2 = server->client
185 void askcipher(char *ciphername, int cs)
190 static const char msg[] =
191 "The first %scipher supported by the server is\n"
192 "%s, which is below the configured warning threshold.\n"
193 "Continue with connection? (y/n) ";
194 static const char abandoned[] = "Connection abandoned.\n";
200 (cs == 1) ? "client-to-server " :
205 hin = GetStdHandle(STD_INPUT_HANDLE);
206 GetConsoleMode(hin, &savemode);
207 SetConsoleMode(hin, (savemode | ENABLE_ECHO_INPUT |
208 ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT));
209 ReadFile(hin, line, sizeof(line) - 1, &i, NULL);
210 SetConsoleMode(hin, savemode);
212 if (line[0] == 'y' || line[0] == 'Y') {
215 fprintf(stderr, abandoned);
220 /* GUI Adaptation - Sept 2000 */
221 static void send_msg(HWND h, UINT message, WPARAM wParam)
223 while (!PostMessage(h, message, wParam, 0))
227 static void tell_char(FILE * stream, char c)
232 unsigned int msg_id = WM_STD_OUT_CHAR;
233 if (stream == stderr)
234 msg_id = WM_STD_ERR_CHAR;
235 send_msg((HWND) atoi(gui_hwnd), msg_id, (WPARAM) c);
239 static void tell_str(FILE * stream, char *str)
243 for (i = 0; i < strlen(str); ++i)
244 tell_char(stream, str[i]);
247 static void tell_user(FILE * stream, char *fmt, ...)
249 char str[0x100]; /* Make the size big enough */
252 vsprintf(str, fmt, ap);
255 tell_str(stream, str);
258 static void gui_update_stats(char *name, unsigned long size,
259 int percentage, unsigned long elapsed)
263 if (strcmp(name, statname) != 0) {
264 for (i = 0; i < strlen(name); ++i)
265 send_msg((HWND) atoi(gui_hwnd), WM_STATS_CHAR,
267 send_msg((HWND) atoi(gui_hwnd), WM_STATS_CHAR, (WPARAM) '\n');
268 strcpy(statname, name);
270 if (statsize != size) {
271 send_msg((HWND) atoi(gui_hwnd), WM_STATS_SIZE, (WPARAM) size);
274 if (statelapsed != elapsed) {
275 send_msg((HWND) atoi(gui_hwnd), WM_STATS_ELAPSED,
277 statelapsed = elapsed;
279 if (statperct != percentage) {
280 send_msg((HWND) atoi(gui_hwnd), WM_STATS_PERCENT,
281 (WPARAM) percentage);
282 statperct = percentage;
287 * Print an error message and perform a fatal exit.
289 void fatalbox(char *fmt, ...)
291 char str[0x100]; /* Make the size big enough */
294 strcpy(str, "Fatal: ");
295 vsprintf(str + strlen(str), fmt, ap);
298 tell_str(stderr, str);
302 unsigned int msg_id = WM_RET_ERR_CNT;
304 msg_id = WM_LS_RET_ERR_CNT;
306 ((HWND) atoi(gui_hwnd), msg_id, (WPARAM) errs,
307 0 /*lParam */ ))SleepEx(1000, TRUE);
312 void connection_fatal(char *fmt, ...)
314 char str[0x100]; /* Make the size big enough */
317 strcpy(str, "Fatal: ");
318 vsprintf(str + strlen(str), fmt, ap);
321 tell_str(stderr, str);
325 unsigned int msg_id = WM_RET_ERR_CNT;
327 msg_id = WM_LS_RET_ERR_CNT;
329 ((HWND) atoi(gui_hwnd), msg_id, (WPARAM) errs,
330 0 /*lParam */ ))SleepEx(1000, TRUE);
337 * Be told what socket we're supposed to be using.
339 static SOCKET scp_ssh_socket;
340 char *do_select(SOCKET skt, int startup)
343 scp_ssh_socket = skt;
345 scp_ssh_socket = INVALID_SOCKET;
348 extern int select_result(WPARAM, LPARAM);
351 * Receive a block of data from the SSH link. Block until all data
354 * To do this, we repeatedly call the SSH protocol module, with our
355 * own trap in from_backend() to catch the data that comes back. We
356 * do this until we have enough data.
359 static unsigned char *outptr; /* where to put the data */
360 static unsigned outlen; /* how much data required */
361 static unsigned char *pending = NULL; /* any spare data */
362 static unsigned pendlen = 0, pendsize = 0; /* length and phys. size of buffer */
363 int from_backend(int is_stderr, char *data, int datalen)
365 unsigned char *p = (unsigned char *) data;
366 unsigned len = (unsigned) datalen;
369 * stderr data is just spouted to local stderr and otherwise
373 fwrite(data, 1, len, stderr);
380 * If this is before the real session begins, just return.
386 unsigned used = outlen;
389 memcpy(outptr, p, used);
397 if (pendsize < pendlen + len) {
398 pendsize = pendlen + len + 4096;
399 pending = (pending ? srealloc(pending, pendsize) :
402 fatalbox("Out of memory");
404 memcpy(pending + pendlen, p, len);
410 static int scp_process_network_event(void)
415 FD_SET(scp_ssh_socket, &readfds);
416 if (select(1, &readfds, NULL, NULL, NULL) < 0)
418 select_result((WPARAM) scp_ssh_socket, (LPARAM) FD_READ);
421 static int ssh_scp_recv(unsigned char *buf, int len)
427 * See if the pending-input block contains some of what we
431 unsigned pendused = pendlen;
432 if (pendused > outlen)
434 memcpy(outptr, pending, pendused);
435 memmove(pending, pending + pendused, pendlen - pendused);
449 if (!scp_process_network_event())
457 * Loop through the ssh connection and authentication process.
459 static void ssh_scp_init(void)
461 if (scp_ssh_socket == INVALID_SOCKET)
463 while (!back->sendok()) {
466 FD_SET(scp_ssh_socket, &readfds);
467 if (select(1, &readfds, NULL, NULL, NULL) < 0)
469 select_result((WPARAM) scp_ssh_socket, (LPARAM) FD_READ);
471 using_sftp = !ssh_fallback_cmd;
475 * Print an error message and exit after closing the SSH link.
477 static void bump(char *fmt, ...)
479 char str[0x100]; /* Make the size big enough */
482 strcpy(str, "Fatal: ");
483 vsprintf(str + strlen(str), fmt, ap);
486 tell_str(stderr, str);
489 if (back != NULL && back->socket() != NULL) {
491 back->special(TS_EOF);
492 ssh_scp_recv(&ch, 1);
496 unsigned int msg_id = WM_RET_ERR_CNT;
498 msg_id = WM_LS_RET_ERR_CNT;
500 ((HWND) atoi(gui_hwnd), msg_id, (WPARAM) errs,
501 0 /*lParam */ ))SleepEx(1000, TRUE);
507 static int get_line(const char *prompt, char *str, int maxlen, int is_pw)
510 DWORD savemode, newmode, i;
512 if (is_pw && password) {
513 static int tried_once = 0;
518 strncpy(str, password, maxlen);
519 str[maxlen - 1] = '\0';
525 /* GUI Adaptation - Sept 2000 */
530 hin = GetStdHandle(STD_INPUT_HANDLE);
531 hout = GetStdHandle(STD_OUTPUT_HANDLE);
532 if (hin == INVALID_HANDLE_VALUE || hout == INVALID_HANDLE_VALUE)
533 bump("Cannot get standard input/output handles");
535 GetConsoleMode(hin, &savemode);
536 newmode = savemode | ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT;
538 newmode &= ~ENABLE_ECHO_INPUT;
540 newmode |= ENABLE_ECHO_INPUT;
541 SetConsoleMode(hin, newmode);
543 WriteFile(hout, prompt, strlen(prompt), &i, NULL);
544 ReadFile(hin, str, maxlen - 1, &i, NULL);
546 SetConsoleMode(hin, savemode);
548 if ((int) i > maxlen)
555 WriteFile(hout, "\r\n", 2, &i, NULL);
562 * Open an SSH connection to user@host and execute cmd.
564 static void do_cmd(char *host, char *user, char *cmd)
566 char *err, *realhost;
569 if (host == NULL || host[0] == '\0')
570 bump("Empty host name");
572 /* Try to load settings for this host */
573 do_defaults(host, &cfg);
574 if (cfg.host[0] == '\0') {
575 /* No settings for this host; use defaults */
576 do_defaults(NULL, &cfg);
577 strncpy(cfg.host, host, sizeof(cfg.host) - 1);
578 cfg.host[sizeof(cfg.host) - 1] = '\0';
583 if (user != NULL && user[0] != '\0') {
584 strncpy(cfg.username, user, sizeof(cfg.username) - 1);
585 cfg.username[sizeof(cfg.username) - 1] = '\0';
586 } else if (cfg.username[0] == '\0') {
588 if (GetUserName(user, &namelen) == FALSE)
589 bump("Empty user name");
590 user = smalloc(namelen * sizeof(char));
591 GetUserName(user, &namelen);
593 tell_user(stderr, "Guessing user name: %s", user);
594 strncpy(cfg.username, user, sizeof(cfg.username) - 1);
595 cfg.username[sizeof(cfg.username) - 1] = '\0';
599 if (cfg.protocol != PROT_SSH)
603 cfg.port = portnumber;
606 * Attempt to start the SFTP subsystem as a first choice,
607 * falling back to the provided scp command if that fails.
609 strcpy(cfg.remote_cmd, "sftp");
610 cfg.ssh_subsys = TRUE;
611 cfg.remote_cmd_ptr2 = cmd;
612 cfg.ssh_subsys2 = FALSE;
617 err = back->init(cfg.host, cfg.port, &realhost);
619 bump("ssh_init: %s", err);
621 if (verbose && realhost != NULL)
622 tell_user(stderr, "Connected to %s\n", realhost);
627 * Update statistic information about current file.
629 static void print_stats(char *name, unsigned long size, unsigned long done,
630 time_t start, time_t now)
638 /* GUI Adaptation - Sept 2000 */
640 gui_update_stats(name, size, (int) (100 * (done * 1.0 / size)),
641 (unsigned long) difftime(now, start));
644 ratebs = (float) done / (now - start);
646 ratebs = (float) done;
651 eta = (unsigned long) ((size - done) / ratebs);
652 sprintf(etastr, "%02ld:%02ld:%02ld",
653 eta / 3600, (eta % 3600) / 60, eta % 60);
655 pct = (int) (100.0 * (float) done / size);
657 len = printf("\r%-25.25s | %10ld kB | %5.1f kB/s | ETA: %8s | %3d%%",
658 name, done / 1024, ratebs / 1024.0, etastr, pct);
659 if (len < prev_stats_len)
660 printf("%*s", prev_stats_len - len, "");
661 prev_stats_len = len;
669 * Find a colon in str and return a pointer to the colon.
670 * This is used to separate hostname from filename.
672 static char *colon(char *str)
674 /* We ignore a leading colon, since the hostname cannot be
675 empty. We also ignore a colon as second character because
676 of filenames like f:myfile.txt. */
677 if (str[0] == '\0' || str[0] == ':' || str[1] == ':')
679 while (*str != '\0' && *str != ':' && *str != '/' && *str != '\\')
688 * Return a pointer to the portion of str that comes after the last
689 * slash (or backslash, if `local' is TRUE).
691 static char *stripslashes(char *str, int local)
695 p = strrchr(str, '/');
699 p = strrchr(str, '\\');
707 * Determine whether a string is entirely composed of dots.
709 static int is_dots(char *str)
711 return str[strspn(str, ".")] == '\0';
715 * Wait for a response from the other side.
716 * Return 0 if ok, -1 if error.
718 static int response(void)
720 char ch, resp, rbuf[2048];
723 if (ssh_scp_recv(&resp, 1) <= 0)
724 bump("Lost connection");
734 case 2: /* fatal error */
736 if (ssh_scp_recv(&ch, 1) <= 0)
737 bump("Protocol error: Lost connection");
739 } while (p < sizeof(rbuf) && ch != '\n');
742 tell_user(stderr, "%s\n", rbuf);
750 int sftp_recvdata(char *buf, int len)
752 return ssh_scp_recv(buf, len);
754 int sftp_senddata(char *buf, int len)
756 back->send((unsigned char *) buf, len);
760 /* ----------------------------------------------------------------------
761 * sftp-based replacement for the hacky `pscp -ls'.
763 static int sftp_ls_compare(const void *av, const void *bv)
765 const struct fxp_name *a = (const struct fxp_name *) av;
766 const struct fxp_name *b = (const struct fxp_name *) bv;
767 return strcmp(a->filename, b->filename);
769 void scp_sftp_listdir(char *dirname)
771 struct fxp_handle *dirh;
772 struct fxp_names *names;
773 struct fxp_name *ournames;
774 int nnames, namesize;
778 printf("Listing directory %s\n", dirname);
780 dirh = fxp_opendir(dirname);
782 printf("Unable to open %s: %s\n", dir, fxp_error());
784 nnames = namesize = 0;
789 names = fxp_readdir(dirh);
791 if (fxp_error_type() == SSH_FX_EOF)
793 printf("Reading directory %s: %s\n", dir, fxp_error());
796 if (names->nnames == 0) {
797 fxp_free_names(names);
801 if (nnames + names->nnames >= namesize) {
802 namesize += names->nnames + 128;
804 srealloc(ournames, namesize * sizeof(*ournames));
807 for (i = 0; i < names->nnames; i++)
808 ournames[nnames++] = names->names[i];
810 names->nnames = 0; /* prevent free_names */
811 fxp_free_names(names);
816 * Now we have our filenames. Sort them by actual file
817 * name, and then output the longname parts.
819 qsort(ournames, nnames, sizeof(*ournames), sftp_ls_compare);
824 for (i = 0; i < nnames; i++)
825 printf("%s\n", ournames[i].longname);
829 /* ----------------------------------------------------------------------
830 * Helper routines that contain the actual SCP protocol elements,
831 * implemented both as SCP1 and SFTP.
834 static struct scp_sftp_dirstack {
835 struct scp_sftp_dirstack *next;
836 struct fxp_name *names;
837 int namepos, namelen;
840 } *scp_sftp_dirstack_head;
841 static char *scp_sftp_remotepath, *scp_sftp_currentname;
842 static char *scp_sftp_wildcard;
843 static int scp_sftp_targetisdir, scp_sftp_donethistarget;
844 static int scp_sftp_preserve, scp_sftp_recursive;
845 static unsigned long scp_sftp_mtime, scp_sftp_atime;
846 static int scp_has_times;
847 static struct fxp_handle *scp_sftp_filehandle;
848 static uint64 scp_sftp_fileoffset;
850 void scp_source_setup(char *target, int shouldbedir)
854 * Find out whether the target filespec is in fact a
857 struct fxp_attrs attrs;
859 if (!fxp_stat(target, &attrs) ||
860 !(attrs.flags & SSH_FILEXFER_ATTR_PERMISSIONS))
861 scp_sftp_targetisdir = 0;
863 scp_sftp_targetisdir = (attrs.permissions & 0040000) != 0;
865 if (shouldbedir && !scp_sftp_targetisdir) {
866 bump("pscp: remote filespec %s: not a directory\n", target);
869 scp_sftp_remotepath = dupstr(target);
877 int scp_send_errmsg(char *str)
880 /* do nothing; we never need to send our errors to the server */
882 back->send("\001", 1); /* scp protocol error prefix */
883 back->send(str, strlen(str));
885 return 0; /* can't fail */
888 int scp_send_filetimes(unsigned long mtime, unsigned long atime)
891 scp_sftp_mtime = mtime;
892 scp_sftp_atime = atime;
897 sprintf(buf, "T%lu 0 %lu 0\n", mtime, atime);
898 back->send(buf, strlen(buf));
903 int scp_send_filename(char *name, unsigned long size, int modes)
907 if (scp_sftp_targetisdir) {
908 fullname = dupcat(scp_sftp_remotepath, "/", name, NULL);
910 fullname = dupstr(scp_sftp_remotepath);
912 scp_sftp_filehandle =
913 fxp_open(fullname, SSH_FXF_WRITE | SSH_FXF_CREAT | SSH_FXF_TRUNC);
914 if (!scp_sftp_filehandle) {
915 tell_user(stderr, "pscp: unable to open %s: %s",
916 fullname, fxp_error());
920 scp_sftp_fileoffset = uint64_make(0, 0);
925 sprintf(buf, "C%04o %lu ", modes, size);
926 back->send(buf, strlen(buf));
927 back->send(name, strlen(name));
933 int scp_send_filedata(char *data, int len)
936 if (!scp_sftp_filehandle) {
939 if (!fxp_write(scp_sftp_filehandle, data, scp_sftp_fileoffset, len)) {
940 tell_user(stderr, "error while writing: %s\n", fxp_error());
944 scp_sftp_fileoffset = uint64_add32(scp_sftp_fileoffset, len);
947 int bufsize = back->send(data, len);
950 * If the network transfer is backing up - that is, the
951 * remote site is not accepting data as fast as we can
952 * produce it - then we must loop on network events until
953 * we have space in the buffer again.
955 while (bufsize > MAX_SCP_BUFSIZE) {
956 if (!scp_process_network_event())
958 bufsize = back->sendbuffer();
965 int scp_send_finish(void)
968 struct fxp_attrs attrs;
969 if (!scp_sftp_filehandle) {
973 attrs.flags = SSH_FILEXFER_ATTR_ACMODTIME;
974 attrs.atime = scp_sftp_atime;
975 attrs.mtime = scp_sftp_mtime;
976 if (!fxp_fsetstat(scp_sftp_filehandle, attrs)) {
977 tell_user(stderr, "unable to set file times: %s\n", fxp_error());
981 fxp_close(scp_sftp_filehandle);
990 char *scp_save_remotepath(void)
993 return scp_sftp_remotepath;
998 void scp_restore_remotepath(char *data)
1001 scp_sftp_remotepath = data;
1004 int scp_send_dirname(char *name, int modes)
1009 struct fxp_attrs attrs;
1010 if (scp_sftp_targetisdir) {
1011 fullname = dupcat(scp_sftp_remotepath, "/", name, NULL);
1013 fullname = dupstr(scp_sftp_remotepath);
1017 * We don't worry about whether we managed to create the
1018 * directory, because if it exists already it's OK just to
1019 * use it. Instead, we will stat it afterwards, and if it
1020 * exists and is a directory we will assume we were either
1021 * successful or it didn't matter.
1023 if (!fxp_mkdir(fullname))
1026 err = "server reported no error";
1027 if (!fxp_stat(fullname, &attrs) ||
1028 !(attrs.flags & SSH_FILEXFER_ATTR_PERMISSIONS) ||
1029 !(attrs.permissions & 0040000)) {
1030 tell_user(stderr, "unable to create directory %s: %s",
1036 scp_sftp_remotepath = fullname;
1041 sprintf(buf, "D%04o 0 ", modes);
1042 back->send(buf, strlen(buf));
1043 back->send(name, strlen(name));
1044 back->send("\n", 1);
1049 int scp_send_enddir(void)
1052 sfree(scp_sftp_remotepath);
1055 back->send("E\n", 2);
1061 * Yes, I know; I have an scp_sink_setup _and_ an scp_sink_init.
1062 * That's bad. The difference is that scp_sink_setup is called once
1063 * right at the start, whereas scp_sink_init is called to
1064 * initialise every level of recursion in the protocol.
1066 int scp_sink_setup(char *source, int preserve, int recursive)
1071 * It's possible that the source string we've been given
1072 * contains a wildcard. If so, we must split the directory
1073 * away from the wildcard itself (throwing an error if any
1074 * wildcardness comes before the final slash) and arrange
1075 * things so that a dirstack entry will be set up.
1077 newsource = smalloc(1+strlen(source));
1078 if (!wc_unescape(newsource, source)) {
1079 /* Yes, here we go; it's a wildcard. Bah. */
1080 char *dupsource, *lastpart, *dirpart, *wildcard;
1081 dupsource = dupstr(source);
1082 lastpart = stripslashes(dupsource, 0);
1083 wildcard = dupstr(lastpart);
1085 if (*dupsource && dupsource[1]) {
1087 * The remains of dupsource are at least two
1088 * characters long, meaning the pathname wasn't
1089 * empty or just `/'. Hence, we remove the trailing
1092 lastpart[-1] = '\0';
1093 } else if (!*dupsource) {
1095 * The remains of dupsource are _empty_ - the whole
1096 * pathname was a wildcard. Hence we need to
1097 * replace it with ".".
1100 dupsource = dupstr(".");
1104 * Now we have separated our string into dupsource (the
1105 * directory part) and wildcard. Both of these will
1106 * need freeing at some point. Next step is to remove
1107 * wildcard escapes from the directory part, throwing
1108 * an error if it contains a real wildcard.
1110 dirpart = smalloc(1+strlen(dupsource));
1111 if (!wc_unescape(dirpart, dupsource)) {
1112 tell_user(stderr, "%s: multiple-level wildcards unsupported",
1122 * Now we have dirpart (unescaped, ie a valid remote
1123 * path), and wildcard (a wildcard). This will be
1124 * sufficient to arrange a dirstack entry.
1126 scp_sftp_remotepath = dirpart;
1127 scp_sftp_wildcard = wildcard;
1130 scp_sftp_remotepath = newsource;
1131 scp_sftp_wildcard = NULL;
1133 scp_sftp_preserve = preserve;
1134 scp_sftp_recursive = recursive;
1135 scp_sftp_donethistarget = 0;
1136 scp_sftp_dirstack_head = NULL;
1141 int scp_sink_init(void)
1149 #define SCP_SINK_FILE 1
1150 #define SCP_SINK_DIR 2
1151 #define SCP_SINK_ENDDIR 3
1152 #define SCP_SINK_RETRY 4 /* not an action; just try again */
1153 struct scp_sink_action {
1154 int action; /* FILE, DIR, ENDDIR */
1155 char *buf; /* will need freeing after use */
1156 char *name; /* filename or dirname (not ENDDIR) */
1157 int mode; /* access mode (not ENDDIR) */
1158 unsigned long size; /* file size (not ENDDIR) */
1159 int settime; /* 1 if atime and mtime are filled */
1160 unsigned long atime, mtime; /* access times for the file */
1163 int scp_get_sink_action(struct scp_sink_action *act)
1167 int must_free_fname;
1168 struct fxp_attrs attrs;
1171 if (!scp_sftp_dirstack_head) {
1172 if (!scp_sftp_donethistarget) {
1174 * Simple case: we are only dealing with one file.
1176 fname = scp_sftp_remotepath;
1177 must_free_fname = 0;
1178 scp_sftp_donethistarget = 1;
1181 * Even simpler case: one file _which we've done_.
1182 * Return 1 (finished).
1188 * We're now in the middle of stepping through a list
1189 * of names returned from fxp_readdir(); so let's carry
1192 struct scp_sftp_dirstack *head = scp_sftp_dirstack_head;
1193 while (head->namepos < head->namelen &&
1194 (is_dots(head->names[head->namepos].filename) ||
1196 !wc_match(head->wildcard,
1197 head->names[head->namepos].filename))))
1198 head->namepos++; /* skip . and .. */
1199 if (head->namepos < head->namelen) {
1200 fname = dupcat(head->dirpath, "/",
1201 head->names[head->namepos++].filename,
1203 must_free_fname = 1;
1206 * We've come to the end of the list; pop it off
1207 * the stack and return an ENDDIR action (or RETRY
1208 * if this was a wildcard match).
1210 if (head->wildcard) {
1211 act->action = SCP_SINK_RETRY;
1212 sfree(head->wildcard);
1214 act->action = SCP_SINK_ENDDIR;
1217 sfree(head->dirpath);
1219 scp_sftp_dirstack_head = head->next;
1227 * Now we have a filename. Stat it, and see if it's a file
1230 ret = fxp_stat(fname, &attrs);
1231 if (!ret || !(attrs.flags & SSH_FILEXFER_ATTR_PERMISSIONS)) {
1232 tell_user(stderr, "unable to identify %s: %s", fname,
1233 ret ? "file type not supplied" : fxp_error());
1238 if (attrs.permissions & 0040000) {
1239 struct scp_sftp_dirstack *newitem;
1240 struct fxp_handle *dirhandle;
1241 int nnames, namesize;
1242 struct fxp_name *ournames;
1243 struct fxp_names *names;
1246 * It's a directory. If we're not in recursive mode,
1247 * this merits a complaint (which is fatal if the name
1248 * was specified directly, but not if it was matched by
1251 * We skip this complaint completely if
1252 * scp_sftp_wildcard is set, because that's an
1253 * indication that we're not actually supposed to
1254 * _recursively_ transfer the dir, just scan it for
1255 * things matching the wildcard.
1257 if (!scp_sftp_recursive && !scp_sftp_wildcard) {
1258 tell_user(stderr, "pscp: %s: is a directory", fname);
1260 if (must_free_fname) sfree(fname);
1261 if (scp_sftp_dirstack_head) {
1262 act->action = SCP_SINK_RETRY;
1270 * Otherwise, the fun begins. We must fxp_opendir() the
1271 * directory, slurp the filenames into memory, return
1272 * SCP_SINK_DIR (unless this is a wildcard match), and
1273 * set targetisdir. The next time we're called, we will
1274 * run through the list of filenames one by one,
1275 * matching them against a wildcard if present.
1277 * If targetisdir is _already_ set (meaning we're
1278 * already in the middle of going through another such
1279 * list), we must push the other (target,namelist) pair
1282 dirhandle = fxp_opendir(fname);
1284 tell_user(stderr, "scp: unable to open directory %s: %s",
1285 fname, fxp_error());
1286 if (must_free_fname) sfree(fname);
1290 nnames = namesize = 0;
1295 names = fxp_readdir(dirhandle);
1296 if (names == NULL) {
1297 if (fxp_error_type() == SSH_FX_EOF)
1299 tell_user(stderr, "scp: reading directory %s: %s\n",
1300 fname, fxp_error());
1301 if (must_free_fname) sfree(fname);
1306 if (names->nnames == 0) {
1307 fxp_free_names(names);
1310 if (nnames + names->nnames >= namesize) {
1311 namesize += names->nnames + 128;
1313 srealloc(ournames, namesize * sizeof(*ournames));
1315 for (i = 0; i < names->nnames; i++)
1316 ournames[nnames++] = names->names[i];
1317 names->nnames = 0; /* prevent free_names */
1318 fxp_free_names(names);
1320 fxp_close(dirhandle);
1322 newitem = smalloc(sizeof(struct scp_sftp_dirstack));
1323 newitem->next = scp_sftp_dirstack_head;
1324 newitem->names = ournames;
1325 newitem->namepos = 0;
1326 newitem->namelen = nnames;
1327 if (must_free_fname)
1328 newitem->dirpath = fname;
1330 newitem->dirpath = dupstr(fname);
1331 if (scp_sftp_wildcard) {
1332 newitem->wildcard = scp_sftp_wildcard;
1333 scp_sftp_wildcard = NULL;
1335 newitem->wildcard = NULL;
1337 scp_sftp_dirstack_head = newitem;
1339 if (newitem->wildcard) {
1340 act->action = SCP_SINK_RETRY;
1342 act->action = SCP_SINK_DIR;
1343 act->buf = dupstr(stripslashes(fname, 0));
1344 act->name = act->buf;
1345 act->size = 0; /* duhh, it's a directory */
1346 act->mode = 07777 & attrs.permissions;
1347 if (scp_sftp_preserve &&
1348 (attrs.flags & SSH_FILEXFER_ATTR_ACMODTIME)) {
1349 act->atime = attrs.atime;
1350 act->mtime = attrs.mtime;
1359 * It's a file. Return SCP_SINK_FILE.
1361 act->action = SCP_SINK_FILE;
1362 act->buf = dupstr(stripslashes(fname, 0));
1363 act->name = act->buf;
1364 if (attrs.flags & SSH_FILEXFER_ATTR_SIZE) {
1365 if (uint64_compare(attrs.size,
1366 uint64_make(0, ULONG_MAX)) > 0) {
1367 act->size = ULONG_MAX; /* *boggle* */
1369 act->size = attrs.size.lo;
1371 act->size = ULONG_MAX; /* no idea */
1372 act->mode = 07777 & attrs.permissions;
1373 if (scp_sftp_preserve &&
1374 (attrs.flags & SSH_FILEXFER_ATTR_ACMODTIME)) {
1375 act->atime = attrs.atime;
1376 act->mtime = attrs.mtime;
1380 if (must_free_fname)
1381 scp_sftp_currentname = fname;
1383 scp_sftp_currentname = dupstr(fname);
1398 if (ssh_scp_recv(&ch, 1) <= 0)
1401 bump("Protocol error: Unexpected newline");
1405 if (ssh_scp_recv(&ch, 1) <= 0)
1406 bump("Lost connection");
1409 act->buf = srealloc(act->buf, bufsize);
1412 } while (ch != '\n');
1413 act->buf[i - 1] = '\0';
1415 case '\01': /* error */
1416 tell_user(stderr, "%s\n", act->buf);
1418 continue; /* go round again */
1419 case '\02': /* fatal error */
1420 bump("%s", act->buf);
1423 act->action = SCP_SINK_ENDDIR;
1426 if (sscanf(act->buf, "%ld %*d %ld %*d",
1427 &act->mtime, &act->atime) == 2) {
1430 continue; /* go round again */
1432 bump("Protocol error: Illegal time format");
1435 act->action = (action == 'C' ? SCP_SINK_FILE : SCP_SINK_DIR);
1438 bump("Protocol error: Expected control record");
1441 * We will go round this loop only once, unless we hit
1448 * If we get here, we must have seen SCP_SINK_FILE or
1451 if (sscanf(act->buf, "%o %lu %n", &act->mode, &act->size, &i) != 2)
1452 bump("Protocol error: Illegal file descriptor format");
1453 act->name = act->buf + i;
1458 int scp_accept_filexfer(void)
1461 scp_sftp_filehandle =
1462 fxp_open(scp_sftp_currentname, SSH_FXF_READ);
1463 if (!scp_sftp_filehandle) {
1464 tell_user(stderr, "pscp: unable to open %s: %s",
1465 scp_sftp_currentname, fxp_error());
1469 scp_sftp_fileoffset = uint64_make(0, 0);
1470 sfree(scp_sftp_currentname);
1474 return 0; /* can't fail */
1478 int scp_recv_filedata(char *data, int len)
1481 int actuallen = fxp_read(scp_sftp_filehandle, data,
1482 scp_sftp_fileoffset, len);
1483 if (actuallen == -1 && fxp_error_type() != SSH_FX_EOF) {
1484 tell_user(stderr, "pscp: error while reading: %s", fxp_error());
1491 scp_sftp_fileoffset = uint64_add32(scp_sftp_fileoffset, actuallen);
1495 return ssh_scp_recv(data, len);
1499 int scp_finish_filerecv(void)
1502 fxp_close(scp_sftp_filehandle);
1510 /* ----------------------------------------------------------------------
1511 * Send an error message to the other side and to the screen.
1512 * Increment error counter.
1514 static void run_err(const char *fmt, ...)
1520 strcpy(str, "scp: ");
1521 vsprintf(str + strlen(str), fmt, ap);
1523 scp_send_errmsg(str);
1524 tell_user(stderr, "%s", str);
1529 * Execute the source part of the SCP protocol.
1531 static void source(char *src)
1538 unsigned long stat_bytes;
1539 time_t stat_starttime, stat_lasttime;
1541 attr = GetFileAttributes(src);
1542 if (attr == (DWORD) - 1) {
1543 run_err("%s: No such file or directory", src);
1547 if ((attr & FILE_ATTRIBUTE_DIRECTORY) != 0) {
1550 * Avoid . and .. directories.
1553 p = strrchr(src, '/');
1555 p = strrchr(src, '\\');
1560 if (!strcmp(p, ".") || !strcmp(p, ".."))
1561 /* skip . and .. */ ;
1565 run_err("%s: not a regular file", src);
1570 if ((last = strrchr(src, '/')) == NULL)
1574 if (strrchr(last, '\\') != NULL)
1575 last = strrchr(last, '\\') + 1;
1576 if (last == src && strchr(src, ':') != NULL)
1577 last = strchr(src, ':') + 1;
1579 f = CreateFile(src, GENERIC_READ, FILE_SHARE_READ, NULL,
1580 OPEN_EXISTING, 0, 0);
1581 if (f == INVALID_HANDLE_VALUE) {
1582 run_err("%s: Cannot open file", src);
1587 FILETIME actime, wrtime;
1588 unsigned long mtime, atime;
1589 GetFileTime(f, NULL, &actime, &wrtime);
1590 TIME_WIN_TO_POSIX(actime, atime);
1591 TIME_WIN_TO_POSIX(wrtime, mtime);
1592 if (scp_send_filetimes(mtime, atime))
1596 size = GetFileSize(f, NULL);
1598 tell_user(stderr, "Sending file %s, size=%lu", last, size);
1599 if (scp_send_filename(last, size, 0644))
1603 stat_starttime = time(NULL);
1606 for (i = 0; i < size; i += 4096) {
1607 char transbuf[4096];
1612 if (!ReadFile(f, transbuf, k, &j, NULL) || j != k) {
1615 bump("%s: Read error", src);
1617 if (scp_send_filedata(transbuf, k))
1618 bump("%s: Network error occurred", src);
1622 if (time(NULL) != stat_lasttime || i + k == size) {
1623 stat_lasttime = time(NULL);
1624 print_stats(last, size, stat_bytes,
1625 stat_starttime, stat_lasttime);
1632 (void) scp_send_finish();
1636 * Recursively send the contents of a directory.
1638 static void rsource(char *src)
1640 char *last, *findfile;
1643 WIN32_FIND_DATA fdat;
1646 if ((last = strrchr(src, '/')) == NULL)
1650 if (strrchr(last, '\\') != NULL)
1651 last = strrchr(last, '\\') + 1;
1652 if (last == src && strchr(src, ':') != NULL)
1653 last = strchr(src, ':') + 1;
1655 /* maybe send filetime */
1657 save_target = scp_save_remotepath();
1660 tell_user(stderr, "Entering directory: %s", last);
1661 if (scp_send_dirname(last, 0755))
1664 findfile = dupcat(src, "/*", NULL);
1665 dir = FindFirstFile(findfile, &fdat);
1666 ok = (dir != INVALID_HANDLE_VALUE);
1668 if (strcmp(fdat.cFileName, ".") == 0 ||
1669 strcmp(fdat.cFileName, "..") == 0) {
1670 /* ignore . and .. */
1672 char *foundfile = dupcat(src, "/", fdat.cFileName, NULL);
1676 ok = FindNextFile(dir, &fdat);
1681 (void) scp_send_enddir();
1683 scp_restore_remotepath(save_target);
1687 * Execute the sink part of the SCP protocol.
1689 static void sink(char *targ, char *src)
1698 unsigned long received;
1700 unsigned long stat_bytes;
1701 time_t stat_starttime, stat_lasttime;
1704 attr = GetFileAttributes(targ);
1705 if (attr != (DWORD) - 1 && (attr & FILE_ATTRIBUTE_DIRECTORY) != 0)
1708 if (targetshouldbedirectory && !targisdir)
1709 bump("%s: Not a directory", targ);
1713 struct scp_sink_action act;
1714 if (scp_get_sink_action(&act))
1717 if (act.action == SCP_SINK_ENDDIR)
1720 if (act.action == SCP_SINK_RETRY)
1725 * Prevent the remote side from maliciously writing to
1726 * files outside the target area by sending a filename
1727 * containing `../'. In fact, it shouldn't be sending
1728 * filenames with any slashes in at all; so we'll find
1729 * the last slash or backslash in the filename and use
1730 * only the part after that. (And warn!)
1732 * In addition, we also ensure here that if we're
1733 * copying a single file and the target is a directory
1734 * (common usage: `pscp host:filename .') the remote
1735 * can't send us a _different_ file name. We can
1736 * distinguish this case because `src' will be non-NULL
1737 * and the last component of that will fail to match
1738 * (the last component of) the name sent.
1740 * Well, not always; if `src' is a wildcard, we do
1741 * expect to get back filenames that don't correspond
1742 * exactly to it. Ideally in this case, we would like
1743 * to ensure that the returned filename actually
1744 * matches the wildcard pattern - but one of SCP's
1745 * protocol infelicities is that wildcard matching is
1746 * done at the server end _by the server's rules_ and
1747 * so in general this is infeasible. Hence, we only
1748 * accept filenames that don't correspond to `src' if
1749 * unsafe mode is enabled or we are using SFTP (which
1750 * resolves remote wildcards on the client side and can
1753 char *striptarget, *stripsrc;
1755 striptarget = stripslashes(act.name, 1);
1756 if (striptarget != act.name) {
1757 tell_user(stderr, "warning: remote host sent a compound"
1758 " pathname - possibly malicious! (ignored)");
1762 * Also check to see if the target filename is '.' or
1763 * '..', or indeed '...' and so on because Windows
1764 * appears to interpret those like '..'.
1766 if (is_dots(striptarget)) {
1767 bump("security violation: remote host attempted to write to"
1768 " a '.' or '..' path!");
1772 stripsrc = stripslashes(src, 1);
1773 if (strcmp(striptarget, stripsrc) &&
1774 !using_sftp && !scp_unsafe_mode) {
1775 tell_user(stderr, "warning: remote host tried to write "
1776 "to a file called '%s'", striptarget);
1777 tell_user(stderr, " when we requested a file "
1778 "called '%s'.", stripsrc);
1779 tell_user(stderr, " If this is a wildcard, "
1780 "consider upgrading to SSH 2 or using");
1781 tell_user(stderr, " the '-unsafe' option. Renaming"
1782 " of this file has been disallowed.");
1783 /* Override the name the server provided with our own. */
1784 striptarget = stripsrc;
1788 if (targ[0] != '\0')
1789 destfname = dupcat(targ, "\\", striptarget, NULL);
1791 destfname = dupstr(striptarget);
1794 * In this branch of the if, the target area is a
1795 * single file with an explicitly specified name in any
1796 * case, so there's no danger.
1798 destfname = dupstr(targ);
1800 attr = GetFileAttributes(destfname);
1801 exists = (attr != (DWORD) - 1);
1803 if (act.action == SCP_SINK_DIR) {
1804 if (exists && (attr & FILE_ATTRIBUTE_DIRECTORY) == 0) {
1805 run_err("%s: Not a directory", destfname);
1809 if (!CreateDirectory(destfname, NULL)) {
1810 run_err("%s: Cannot create directory", destfname);
1814 sink(destfname, NULL);
1815 /* can we set the timestamp for directories ? */
1819 f = CreateFile(destfname, GENERIC_WRITE, 0, NULL,
1820 CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
1821 if (f == INVALID_HANDLE_VALUE) {
1822 run_err("%s: Cannot create file", destfname);
1826 if (scp_accept_filexfer())
1830 stat_starttime = time(NULL);
1832 stat_name = stripslashes(destfname, 1);
1835 while (received < act.size) {
1836 char transbuf[4096];
1837 DWORD blksize, read, written;
1839 if (blksize > act.size - received)
1840 blksize = act.size - received;
1841 read = scp_recv_filedata(transbuf, blksize);
1843 bump("Lost connection");
1846 if (!WriteFile(f, transbuf, read, &written, NULL) ||
1849 /* FIXME: in sftp we can actually abort the transfer */
1851 printf("\r%-25.25s | %50s\n",
1853 "Write error.. waiting for end of file");
1858 if (time(NULL) > stat_lasttime ||
1859 received + read == act.size) {
1860 stat_lasttime = time(NULL);
1861 print_stats(stat_name, act.size, stat_bytes,
1862 stat_starttime, stat_lasttime);
1868 FILETIME actime, wrtime;
1869 TIME_POSIX_TO_WIN(act.atime, actime);
1870 TIME_POSIX_TO_WIN(act.mtime, wrtime);
1871 SetFileTime(f, NULL, &actime, &wrtime);
1876 run_err("%s: Write error", destfname);
1879 (void) scp_finish_filerecv();
1886 * We will copy local files to a remote server.
1888 static void toremote(int argc, char *argv[])
1890 char *src, *targ, *host, *user;
1894 targ = argv[argc - 1];
1896 /* Separate host from filename */
1900 bump("targ == NULL in toremote()");
1904 /* Substitute "." for emtpy target */
1906 /* Separate host and username */
1908 host = strrchr(host, '@');
1919 /* Find out if the source filespec covers multiple files
1920 if so, we should set the targetshouldbedirectory flag */
1922 WIN32_FIND_DATA fdat;
1923 if (colon(argv[0]) != NULL)
1924 bump("%s: Remote to remote not supported", argv[0]);
1925 fh = FindFirstFile(argv[0], &fdat);
1926 if (fh == INVALID_HANDLE_VALUE)
1927 bump("%s: No such file or directory\n", argv[0]);
1928 if (FindNextFile(fh, &fdat))
1929 targetshouldbedirectory = 1;
1933 cmd = smalloc(strlen(targ) + 100);
1934 sprintf(cmd, "scp%s%s%s%s -t %s",
1935 verbose ? " -v" : "",
1936 recursive ? " -r" : "",
1937 preserve ? " -p" : "",
1938 targetshouldbedirectory ? " -d" : "", targ);
1939 do_cmd(host, user, cmd);
1942 scp_source_setup(targ, targetshouldbedirectory);
1944 for (i = 0; i < argc - 1; i++) {
1945 char *srcpath, *last;
1947 WIN32_FIND_DATA fdat;
1949 if (colon(src) != NULL) {
1950 tell_user(stderr, "%s: Remote to remote not supported\n", src);
1956 * Trim off the last pathname component of `src', to
1957 * provide the base pathname which will be prepended to
1958 * filenames returned from Find{First,Next}File.
1960 srcpath = dupstr(src);
1961 last = stripslashes(srcpath, 1);
1962 if (last == srcpath) {
1963 last = strchr(srcpath, ':');
1971 dir = FindFirstFile(src, &fdat);
1972 if (dir == INVALID_HANDLE_VALUE) {
1973 run_err("%s: No such file or directory", src);
1980 * Ensure that . and .. are never matched by wildcards,
1981 * but only by deliberate action.
1983 if (!strcmp(fdat.cFileName, ".") ||
1984 !strcmp(fdat.cFileName, "..")) {
1986 * Find*File has returned a special dir. We require
1987 * that _either_ `src' ends in a backslash followed
1988 * by that string, _or_ `src' is precisely that
1991 int len = strlen(src), dlen = strlen(fdat.cFileName);
1992 if (len == dlen && !strcmp(src, fdat.cFileName)) {
1994 } else if (len > dlen + 1 && src[len - dlen - 1] == '\\' &&
1995 !strcmp(src + len - dlen, fdat.cFileName)) {
1998 continue; /* ignore this one */
2000 filename = dupcat(srcpath, fdat.cFileName, NULL);
2003 } while (FindNextFile(dir, &fdat));
2010 * We will copy files from a remote server to the local machine.
2012 static void tolocal(int argc, char *argv[])
2014 char *src, *targ, *host, *user;
2018 bump("More than one remote source not supported");
2023 /* Separate host from filename */
2027 bump("Local to local copy not supported");
2031 /* Substitute "." for empty filename */
2033 /* Separate username and hostname */
2035 host = strrchr(host, '@');
2045 cmd = smalloc(strlen(src) + 100);
2046 sprintf(cmd, "scp%s%s%s%s -f %s",
2047 verbose ? " -v" : "",
2048 recursive ? " -r" : "",
2049 preserve ? " -p" : "",
2050 targetshouldbedirectory ? " -d" : "", src);
2051 do_cmd(host, user, cmd);
2054 if (scp_sink_setup(src, preserve, recursive))
2061 * We will issue a list command to get a remote directory.
2063 static void get_dir_list(int argc, char *argv[])
2065 char *src, *host, *user;
2071 /* Separate host from filename */
2075 bump("Local to local copy not supported");
2079 /* Substitute "." for empty filename */
2081 /* Separate username and hostname */
2083 host = strrchr(host, '@');
2093 cmd = smalloc(4 * strlen(src) + 100);
2094 strcpy(cmd, "ls -la '");
2095 p = cmd + strlen(cmd);
2096 for (q = src; *q; q++) {
2109 do_cmd(host, user, cmd);
2113 scp_sftp_listdir(src);
2115 while (ssh_scp_recv(&c, 1) > 0)
2116 tell_char(stdout, c);
2121 * Initialize the Win$ock driver.
2123 static void init_winsock(void)
2128 winsock_ver = MAKEWORD(1, 1);
2129 if (WSAStartup(winsock_ver, &wsadata))
2130 bump("Unable to initialise WinSock");
2131 if (LOBYTE(wsadata.wVersion) != 1 || HIBYTE(wsadata.wVersion) != 1)
2132 bump("WinSock version is incompatible with 1.1");
2136 * Short description of parameters.
2138 static void usage(void)
2140 printf("PuTTY Secure Copy client\n");
2141 printf("%s\n", ver);
2142 printf("Usage: pscp [options] [user@]host:source target\n");
2144 (" pscp [options] source [source...] [user@]host:target\n");
2145 printf(" pscp [options] -ls user@host:filespec\n");
2146 printf("Options:\n");
2147 printf(" -p preserve file attributes\n");
2148 printf(" -q quiet, don't show statistics\n");
2149 printf(" -r copy directories recursively\n");
2150 printf(" -v show verbose messages\n");
2151 printf(" -P port connect to specified port\n");
2152 printf(" -pw passw login with specified password\n");
2153 printf(" -unsafe allow server-side wildcards (DANGEROUS)\n");
2156 * -gui is an internal option, used by GUI front ends to get
2157 * pscp to pass progress reports back to them. It's not an
2158 * ordinary user-accessible option, so it shouldn't be part of
2159 * the command-line help. The only people who need to know
2160 * about it are programmers, and they can read the source.
2163 (" -gui hWnd GUI mode with the windows handle for receiving messages\n");
2169 * Main program (no, really?)
2171 int main(int argc, char *argv[])
2175 default_protocol = PROT_TELNET;
2177 flags = FLAG_STDERR;
2178 ssh_get_line = &get_line;
2182 for (i = 1; i < argc; i++) {
2183 if (argv[i][0] != '-')
2185 if (strcmp(argv[i], "-v") == 0)
2186 verbose = 1, flags |= FLAG_VERBOSE;
2187 else if (strcmp(argv[i], "-r") == 0)
2189 else if (strcmp(argv[i], "-p") == 0)
2191 else if (strcmp(argv[i], "-q") == 0)
2193 else if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "-?") == 0)
2195 else if (strcmp(argv[i], "-P") == 0 && i + 1 < argc)
2196 portnumber = atoi(argv[++i]);
2197 else if (strcmp(argv[i], "-pw") == 0 && i + 1 < argc)
2198 password = argv[++i];
2199 else if (strcmp(argv[i], "-gui") == 0 && i + 1 < argc) {
2200 gui_hwnd = argv[++i];
2202 } else if (strcmp(argv[i], "-ls") == 0)
2204 else if (strcmp(argv[i], "-unsafe") == 0)
2205 scp_unsafe_mode = 1;
2206 else if (strcmp(argv[i], "--") == 0) {
2219 get_dir_list(argc, argv);
2226 targetshouldbedirectory = 1;
2228 if (colon(argv[argc - 1]) != NULL)
2229 toremote(argc, argv);
2231 tolocal(argc, argv);
2234 if (back != NULL && back->socket() != NULL) {
2236 back->special(TS_EOF);
2237 ssh_scp_recv(&ch, 1);
2242 /* GUI Adaptation - August 2000 */
2244 unsigned int msg_id = WM_RET_ERR_CNT;
2246 msg_id = WM_LS_RET_ERR_CNT;
2248 ((HWND) atoi(gui_hwnd), msg_id, (WPARAM) errs,
2249 0 /*lParam */ ))SleepEx(1000, TRUE);
2251 return (errs == 0 ? 0 : 1);