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
24 /* GUI Adaptation - Sept 2000 */
28 #define PUTTY_DO_GLOBALS
33 #define TIME_POSIX_TO_WIN(t, ft) (*(LONGLONG*)&(ft) = \
34 ((LONGLONG) (t) + (LONGLONG) 11644473600) * (LONGLONG) 10000000)
35 #define TIME_WIN_TO_POSIX(ft, t) ((t) = (unsigned long) \
36 ((*(LONGLONG*)&(ft)) / (LONGLONG) 10000000 - (LONGLONG) 11644473600))
38 /* GUI Adaptation - Sept 2000 */
39 #define WM_APP_BASE 0x8000
40 #define WM_STD_OUT_CHAR ( WM_APP_BASE+400 )
41 #define WM_STD_ERR_CHAR ( WM_APP_BASE+401 )
42 #define WM_STATS_CHAR ( WM_APP_BASE+402 )
43 #define WM_STATS_SIZE ( WM_APP_BASE+403 )
44 #define WM_STATS_PERCENT ( WM_APP_BASE+404 )
45 #define WM_STATS_ELAPSED ( WM_APP_BASE+405 )
46 #define WM_RET_ERR_CNT ( WM_APP_BASE+406 )
47 #define WM_LS_RET_ERR_CNT ( WM_APP_BASE+407 )
50 static int verbose = 0;
51 static int recursive = 0;
52 static int preserve = 0;
53 static int targetshouldbedirectory = 0;
54 static int statistics = 1;
55 static int portnumber = 0;
56 static char *password = NULL;
58 /* GUI Adaptation - Sept 2000 */
59 #define NAME_STR_MAX 2048
60 static char statname[NAME_STR_MAX + 1];
61 static unsigned long statsize = 0;
62 static int statperct = 0;
63 static unsigned long statelapsed = 0;
64 static int gui_mode = 0;
65 static char *gui_hwnd = NULL;
67 static void source(char *src);
68 static void rsource(char *src);
69 static void sink(char *targ, char *src);
70 /* GUI Adaptation - Sept 2000 */
71 static void tell_char(FILE * stream, char c);
72 static void tell_str(FILE * stream, char *str);
73 static void tell_user(FILE * stream, char *fmt, ...);
74 static void gui_update_stats(char *name, unsigned long size,
75 int percentage, unsigned long elapsed);
77 void logevent(char *string)
81 void ldisc_send(char *buf, int len)
84 * This is only here because of the calls to ldisc_send(NULL,
85 * 0) in ssh.c. Nothing in PSCP actually needs to use the ldisc
86 * as an ldisc. So if we get called with any real data, I want
92 void verify_ssh_host_key(char *host, int port, char *keytype,
93 char *keystr, char *fingerprint)
99 static const char absentmsg[] =
100 "The server's host key is not cached in the registry. You\n"
101 "have no guarantee that the server is the computer you\n"
103 "The server's key fingerprint is:\n"
105 "If you trust this host, enter \"y\" to add the key to\n"
106 "PuTTY's cache and carry on connecting.\n"
107 "If you want to carry on connecting just once, without\n"
108 "adding the key to the cache, enter \"n\".\n"
109 "If you do not trust this host, press Return to abandon the\n"
111 "Store key in cache? (y/n) ";
113 static const char wrongmsg[] =
114 "WARNING - POTENTIAL SECURITY BREACH!\n"
115 "The server's host key does not match the one PuTTY has\n"
116 "cached in the registry. This means that either the\n"
117 "server administrator has changed the host key, or you\n"
118 "have actually connected to another computer pretending\n"
119 "to be the server.\n"
120 "The new key fingerprint is:\n"
122 "If you were expecting this change and trust the new key,\n"
123 "enter \"y\" to update PuTTY's cache and continue connecting.\n"
124 "If you want to carry on connecting but without updating\n"
125 "the cache, enter \"n\".\n"
126 "If you want to abandon the connection completely, press\n"
127 "Return to cancel. Pressing Return is the ONLY guaranteed\n"
129 "Update cached key? (y/n, Return cancels connection) ";
131 static const char abandoned[] = "Connection abandoned.\n";
136 * Verify the key against the registry.
138 ret = verify_host_key(host, port, keytype, keystr);
140 if (ret == 0) /* success - key matched OK */
143 if (ret == 2) { /* key was different */
144 fprintf(stderr, wrongmsg, fingerprint);
147 if (ret == 1) { /* key was absent */
148 fprintf(stderr, absentmsg, fingerprint);
152 hin = GetStdHandle(STD_INPUT_HANDLE);
153 GetConsoleMode(hin, &savemode);
154 SetConsoleMode(hin, (savemode | ENABLE_ECHO_INPUT |
155 ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT));
156 ReadFile(hin, line, sizeof(line) - 1, &i, NULL);
157 SetConsoleMode(hin, savemode);
159 if (line[0] != '\0' && line[0] != '\r' && line[0] != '\n') {
160 if (line[0] == 'y' || line[0] == 'Y')
161 store_host_key(host, port, keytype, keystr);
163 fprintf(stderr, abandoned);
168 /* GUI Adaptation - Sept 2000 */
169 static void send_msg(HWND h, UINT message, WPARAM wParam)
171 while (!PostMessage(h, message, wParam, 0))
175 static void tell_char(FILE * stream, char c)
180 unsigned int msg_id = WM_STD_OUT_CHAR;
181 if (stream == stderr)
182 msg_id = WM_STD_ERR_CHAR;
183 send_msg((HWND) atoi(gui_hwnd), msg_id, (WPARAM) c);
187 static void tell_str(FILE * stream, char *str)
191 for (i = 0; i < strlen(str); ++i)
192 tell_char(stream, str[i]);
195 static void tell_user(FILE * stream, char *fmt, ...)
197 char str[0x100]; /* Make the size big enough */
200 vsprintf(str, fmt, ap);
203 tell_str(stream, str);
206 static void gui_update_stats(char *name, unsigned long size,
207 int percentage, unsigned long elapsed)
211 if (strcmp(name, statname) != 0) {
212 for (i = 0; i < strlen(name); ++i)
213 send_msg((HWND) atoi(gui_hwnd), WM_STATS_CHAR,
215 send_msg((HWND) atoi(gui_hwnd), WM_STATS_CHAR, (WPARAM) '\n');
216 strcpy(statname, name);
218 if (statsize != size) {
219 send_msg((HWND) atoi(gui_hwnd), WM_STATS_SIZE, (WPARAM) size);
222 if (statelapsed != elapsed) {
223 send_msg((HWND) atoi(gui_hwnd), WM_STATS_ELAPSED,
225 statelapsed = elapsed;
227 if (statperct != percentage) {
228 send_msg((HWND) atoi(gui_hwnd), WM_STATS_PERCENT,
229 (WPARAM) percentage);
230 statperct = percentage;
235 * Print an error message and perform a fatal exit.
237 void fatalbox(char *fmt, ...)
239 char str[0x100]; /* Make the size big enough */
242 strcpy(str, "Fatal:");
243 vsprintf(str + strlen(str), fmt, ap);
246 tell_str(stderr, str);
250 unsigned int msg_id = WM_RET_ERR_CNT;
252 msg_id = WM_LS_RET_ERR_CNT;
254 ((HWND) atoi(gui_hwnd), msg_id, (WPARAM) errs,
255 0 /*lParam */ ))SleepEx(1000, TRUE);
260 void connection_fatal(char *fmt, ...)
262 char str[0x100]; /* Make the size big enough */
265 strcpy(str, "Fatal:");
266 vsprintf(str + strlen(str), fmt, ap);
269 tell_str(stderr, str);
273 unsigned int msg_id = WM_RET_ERR_CNT;
275 msg_id = WM_LS_RET_ERR_CNT;
277 ((HWND) atoi(gui_hwnd), msg_id, (WPARAM) errs,
278 0 /*lParam */ ))SleepEx(1000, TRUE);
285 * Be told what socket we're supposed to be using.
287 static SOCKET scp_ssh_socket;
288 char *do_select(SOCKET skt, int startup)
291 scp_ssh_socket = skt;
293 scp_ssh_socket = INVALID_SOCKET;
296 extern int select_result(WPARAM, LPARAM);
299 * Receive a block of data from the SSH link. Block until all data
302 * To do this, we repeatedly call the SSH protocol module, with our
303 * own trap in from_backend() to catch the data that comes back. We
304 * do this until we have enough data.
307 static unsigned char *outptr; /* where to put the data */
308 static unsigned outlen; /* how much data required */
309 static unsigned char *pending = NULL; /* any spare data */
310 static unsigned pendlen = 0, pendsize = 0; /* length and phys. size of buffer */
311 void from_backend(int is_stderr, char *data, int datalen)
313 unsigned char *p = (unsigned char *) data;
314 unsigned len = (unsigned) datalen;
317 * stderr data is just spouted to local stderr and otherwise
321 fwrite(data, 1, len, stderr);
328 * If this is before the real session begins, just return.
334 unsigned used = outlen;
337 memcpy(outptr, p, used);
345 if (pendsize < pendlen + len) {
346 pendsize = pendlen + len + 4096;
347 pending = (pending ? srealloc(pending, pendsize) :
350 fatalbox("Out of memory");
352 memcpy(pending + pendlen, p, len);
356 static int ssh_scp_recv(unsigned char *buf, int len)
362 * See if the pending-input block contains some of what we
366 unsigned pendused = pendlen;
367 if (pendused > outlen)
369 memcpy(outptr, pending, pendused);
370 memmove(pending, pending + pendused, pendlen - pendused);
387 FD_SET(scp_ssh_socket, &readfds);
388 if (select(1, &readfds, NULL, NULL, NULL) < 0)
390 select_result((WPARAM) scp_ssh_socket, (LPARAM) FD_READ);
397 * Loop through the ssh connection and authentication process.
399 static void ssh_scp_init(void)
401 if (scp_ssh_socket == INVALID_SOCKET)
403 while (!back->sendok()) {
406 FD_SET(scp_ssh_socket, &readfds);
407 if (select(1, &readfds, NULL, NULL, NULL) < 0)
409 select_result((WPARAM) scp_ssh_socket, (LPARAM) FD_READ);
414 * Print an error message and exit after closing the SSH link.
416 static void bump(char *fmt, ...)
418 char str[0x100]; /* Make the size big enough */
421 strcpy(str, "Fatal:");
422 vsprintf(str + strlen(str), fmt, ap);
425 tell_str(stderr, str);
428 if (back != NULL && back->socket() != NULL) {
430 back->special(TS_EOF);
431 ssh_scp_recv(&ch, 1);
435 unsigned int msg_id = WM_RET_ERR_CNT;
437 msg_id = WM_LS_RET_ERR_CNT;
439 ((HWND) atoi(gui_hwnd), msg_id, (WPARAM) errs,
440 0 /*lParam */ ))SleepEx(1000, TRUE);
446 static int get_line(const char *prompt, char *str, int maxlen, int is_pw)
449 DWORD savemode, newmode, i;
451 if (is_pw && password) {
452 static int tried_once = 0;
457 strncpy(str, password, maxlen);
458 str[maxlen - 1] = '\0';
464 /* GUI Adaptation - Sept 2000 */
469 hin = GetStdHandle(STD_INPUT_HANDLE);
470 hout = GetStdHandle(STD_OUTPUT_HANDLE);
471 if (hin == INVALID_HANDLE_VALUE || hout == INVALID_HANDLE_VALUE)
472 bump("Cannot get standard input/output handles");
474 GetConsoleMode(hin, &savemode);
475 newmode = savemode | ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT;
477 newmode &= ~ENABLE_ECHO_INPUT;
479 newmode |= ENABLE_ECHO_INPUT;
480 SetConsoleMode(hin, newmode);
482 WriteFile(hout, prompt, strlen(prompt), &i, NULL);
483 ReadFile(hin, str, maxlen - 1, &i, NULL);
485 SetConsoleMode(hin, savemode);
487 if ((int) i > maxlen)
494 WriteFile(hout, "\r\n", 2, &i, NULL);
501 * Open an SSH connection to user@host and execute cmd.
503 static void do_cmd(char *host, char *user, char *cmd)
505 char *err, *realhost;
508 if (host == NULL || host[0] == '\0')
509 bump("Empty host name");
511 /* Try to load settings for this host */
512 do_defaults(host, &cfg);
513 if (cfg.host[0] == '\0') {
514 /* No settings for this host; use defaults */
515 do_defaults(NULL, &cfg);
516 strncpy(cfg.host, host, sizeof(cfg.host) - 1);
517 cfg.host[sizeof(cfg.host) - 1] = '\0';
522 if (user != NULL && user[0] != '\0') {
523 strncpy(cfg.username, user, sizeof(cfg.username) - 1);
524 cfg.username[sizeof(cfg.username) - 1] = '\0';
525 } else if (cfg.username[0] == '\0') {
527 if (GetUserName(user, &namelen) == FALSE)
528 bump("Empty user name");
529 user = smalloc(namelen * sizeof(char));
530 GetUserName(user, &namelen);
532 tell_user(stderr, "Guessing user name: %s", user);
533 strncpy(cfg.username, user, sizeof(cfg.username) - 1);
534 cfg.username[sizeof(cfg.username) - 1] = '\0';
538 if (cfg.protocol != PROT_SSH)
542 cfg.port = portnumber;
544 strncpy(cfg.remote_cmd, cmd, sizeof(cfg.remote_cmd));
545 cfg.remote_cmd[sizeof(cfg.remote_cmd) - 1] = '\0';
550 err = back->init(cfg.host, cfg.port, &realhost);
552 bump("ssh_init: %s", err);
554 if (verbose && realhost != NULL)
555 tell_user(stderr, "Connected to %s\n", realhost);
560 * Update statistic information about current file.
562 static void print_stats(char *name, unsigned long size, unsigned long done,
563 time_t start, time_t now)
570 /* GUI Adaptation - Sept 2000 */
572 gui_update_stats(name, size, (int) (100 * (done * 1.0 / size)),
573 (unsigned long) difftime(now, start));
576 ratebs = (float) done / (now - start);
578 ratebs = (float) done;
583 eta = (unsigned long) ((size - done) / ratebs);
584 sprintf(etastr, "%02ld:%02ld:%02ld",
585 eta / 3600, (eta % 3600) / 60, eta % 60);
587 pct = (int) (100.0 * (float) done / size);
589 printf("\r%-25.25s | %10ld kB | %5.1f kB/s | ETA: %8s | %3d%%",
590 name, done / 1024, ratebs / 1024.0, etastr, pct);
598 * Find a colon in str and return a pointer to the colon.
599 * This is used to separate hostname from filename.
601 static char *colon(char *str)
603 /* We ignore a leading colon, since the hostname cannot be
604 empty. We also ignore a colon as second character because
605 of filenames like f:myfile.txt. */
606 if (str[0] == '\0' || str[0] == ':' || str[1] == ':')
608 while (*str != '\0' && *str != ':' && *str != '/' && *str != '\\')
617 * Wait for a response from the other side.
618 * Return 0 if ok, -1 if error.
620 static int response(void)
622 char ch, resp, rbuf[2048];
625 if (ssh_scp_recv(&resp, 1) <= 0)
626 bump("Lost connection");
636 case 2: /* fatal error */
638 if (ssh_scp_recv(&ch, 1) <= 0)
639 bump("Protocol error: Lost connection");
641 } while (p < sizeof(rbuf) && ch != '\n');
644 tell_user(stderr, "%s\n", rbuf);
653 * Send an error message to the other side and to the screen.
654 * Increment error counter.
656 static void run_err(const char *fmt, ...)
662 strcpy(str, "scp: ");
663 vsprintf(str + strlen(str), fmt, ap);
665 back->send("\001", 1); /* scp protocol error prefix */
666 back->send(str, strlen(str));
667 tell_user(stderr, "%s", str);
672 * Execute the source part of the SCP protocol.
674 static void source(char *src)
682 unsigned long stat_bytes;
683 time_t stat_starttime, stat_lasttime;
685 attr = GetFileAttributes(src);
686 if (attr == (DWORD) - 1) {
687 run_err("%s: No such file or directory", src);
691 if ((attr & FILE_ATTRIBUTE_DIRECTORY) != 0) {
694 * Avoid . and .. directories.
697 p = strrchr(src, '/');
699 p = strrchr(src, '\\');
704 if (!strcmp(p, ".") || !strcmp(p, ".."))
705 /* skip . and .. */ ;
709 run_err("%s: not a regular file", src);
714 if ((last = strrchr(src, '/')) == NULL)
718 if (strrchr(last, '\\') != NULL)
719 last = strrchr(last, '\\') + 1;
720 if (last == src && strchr(src, ':') != NULL)
721 last = strchr(src, ':') + 1;
723 f = CreateFile(src, GENERIC_READ, FILE_SHARE_READ, NULL,
724 OPEN_EXISTING, 0, 0);
725 if (f == INVALID_HANDLE_VALUE) {
726 run_err("%s: Cannot open file", src);
731 FILETIME actime, wrtime;
732 unsigned long mtime, atime;
733 GetFileTime(f, NULL, &actime, &wrtime);
734 TIME_WIN_TO_POSIX(actime, atime);
735 TIME_WIN_TO_POSIX(wrtime, mtime);
736 sprintf(buf, "T%lu 0 %lu 0\n", mtime, atime);
737 back->send(buf, strlen(buf));
742 size = GetFileSize(f, NULL);
743 sprintf(buf, "C0644 %lu %s\n", size, last);
745 tell_user(stderr, "Sending file modes: %s", buf);
746 back->send(buf, strlen(buf));
751 stat_starttime = time(NULL);
754 for (i = 0; i < size; i += 4096) {
759 if (!ReadFile(f, transbuf, k, &j, NULL) || j != k) {
762 bump("%s: Read error", src);
764 back->send(transbuf, k);
767 if (time(NULL) != stat_lasttime || i + k == size) {
768 stat_lasttime = time(NULL);
769 print_stats(last, size, stat_bytes,
770 stat_starttime, stat_lasttime);
781 * Recursively send the contents of a directory.
783 static void rsource(char *src)
788 WIN32_FIND_DATA fdat;
791 if ((last = strrchr(src, '/')) == NULL)
795 if (strrchr(last, '\\') != NULL)
796 last = strrchr(last, '\\') + 1;
797 if (last == src && strchr(src, ':') != NULL)
798 last = strchr(src, ':') + 1;
800 /* maybe send filetime */
802 sprintf(buf, "D0755 0 %s\n", last);
804 tell_user(stderr, "Entering directory: %s", buf);
805 back->send(buf, strlen(buf));
809 sprintf(buf, "%s/*", src);
810 dir = FindFirstFile(buf, &fdat);
811 ok = (dir != INVALID_HANDLE_VALUE);
813 if (strcmp(fdat.cFileName, ".") == 0 ||
814 strcmp(fdat.cFileName, "..") == 0) {
815 } else if (strlen(src) + 1 + strlen(fdat.cFileName) >= sizeof(buf)) {
816 run_err("%s/%s: Name too long", src, fdat.cFileName);
818 sprintf(buf, "%s/%s", src, fdat.cFileName);
821 ok = FindNextFile(dir, &fdat);
826 back->send(buf, strlen(buf));
831 * Execute the sink part of the SCP protocol.
833 static void sink(char *targ, char *src)
843 unsigned long mtime, atime;
845 unsigned long size, i;
847 unsigned long stat_bytes;
848 time_t stat_starttime, stat_lasttime;
851 attr = GetFileAttributes(targ);
852 if (attr != (DWORD) - 1 && (attr & FILE_ATTRIBUTE_DIRECTORY) != 0)
855 if (targetshouldbedirectory && !targisdir)
856 bump("%s: Not a directory", targ);
862 if (ssh_scp_recv(&ch, 1) <= 0)
865 bump("Protocol error: Unexpected newline");
869 if (ssh_scp_recv(&ch, 1) <= 0)
870 bump("Lost connection");
872 } while (i < sizeof(buf) && ch != '\n');
875 case '\01': /* error */
876 tell_user(stderr, "%s\n", buf + 1);
879 case '\02': /* fatal error */
885 if (sscanf(buf, "T%ld %*d %ld %*d", &mtime, &atime) == 2) {
890 bump("Protocol error: Illegal time format");
895 bump("Protocol error: Expected control record");
898 if (sscanf(buf + 1, "%u %lu %[^\n]", &mode, &size, namebuf) != 3)
899 bump("Protocol error: Illegal file descriptor format");
900 /* Security fix: ensure the file ends up where we asked for it. */
907 p = namebuf + strlen(namebuf);
908 while (p > namebuf && p[-1] != '/' && p[-1] != '\\')
913 strcpy(namebuf, targ);
915 attr = GetFileAttributes(namebuf);
916 exists = (attr != (DWORD) - 1);
919 if (exists && (attr & FILE_ATTRIBUTE_DIRECTORY) == 0) {
920 run_err("%s: Not a directory", namebuf);
924 if (!CreateDirectory(namebuf, NULL)) {
925 run_err("%s: Cannot create directory", namebuf);
930 /* can we set the timestamp for directories ? */
934 f = CreateFile(namebuf, GENERIC_WRITE, 0, NULL,
935 CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
936 if (f == INVALID_HANDLE_VALUE) {
937 run_err("%s: Cannot create file", namebuf);
944 stat_starttime = time(NULL);
946 if ((stat_name = strrchr(namebuf, '/')) == NULL)
950 if (strrchr(stat_name, '\\') != NULL)
951 stat_name = strrchr(stat_name, '\\') + 1;
953 for (i = 0; i < size; i += 4096) {
958 if (ssh_scp_recv(transbuf, k) == 0)
959 bump("Lost connection");
962 if (!WriteFile(f, transbuf, k, &j, NULL) || j != k) {
965 printf("\r%-25.25s | %50s\n",
967 "Write error.. waiting for end of file");
972 if (time(NULL) > stat_lasttime || i + k == size) {
973 stat_lasttime = time(NULL);
974 print_stats(stat_name, size, stat_bytes,
975 stat_starttime, stat_lasttime);
982 FILETIME actime, wrtime;
983 TIME_POSIX_TO_WIN(atime, actime);
984 TIME_POSIX_TO_WIN(mtime, wrtime);
985 SetFileTime(f, NULL, &actime, &wrtime);
990 run_err("%s: Write error", namebuf);
998 * We will copy local files to a remote server.
1000 static void toremote(int argc, char *argv[])
1002 char *src, *targ, *host, *user;
1006 targ = argv[argc - 1];
1008 /* Separate host from filename */
1012 bump("targ == NULL in toremote()");
1016 /* Substitute "." for emtpy target */
1018 /* Separate host and username */
1020 host = strrchr(host, '@');
1031 /* Find out if the source filespec covers multiple files
1032 if so, we should set the targetshouldbedirectory flag */
1034 WIN32_FIND_DATA fdat;
1035 if (colon(argv[0]) != NULL)
1036 bump("%s: Remote to remote not supported", argv[0]);
1037 fh = FindFirstFile(argv[0], &fdat);
1038 if (fh == INVALID_HANDLE_VALUE)
1039 bump("%s: No such file or directory\n", argv[0]);
1040 if (FindNextFile(fh, &fdat))
1041 targetshouldbedirectory = 1;
1045 cmd = smalloc(strlen(targ) + 100);
1046 sprintf(cmd, "scp%s%s%s%s -t %s",
1047 verbose ? " -v" : "",
1048 recursive ? " -r" : "",
1049 preserve ? " -p" : "",
1050 targetshouldbedirectory ? " -d" : "", targ);
1051 do_cmd(host, user, cmd);
1056 for (i = 0; i < argc - 1; i++) {
1058 WIN32_FIND_DATA fdat;
1060 if (colon(src) != NULL) {
1061 tell_user(stderr, "%s: Remote to remote not supported\n", src);
1065 dir = FindFirstFile(src, &fdat);
1066 if (dir == INVALID_HANDLE_VALUE) {
1067 run_err("%s: No such file or directory", src);
1074 * Ensure that . and .. are never matched by wildcards,
1075 * but only by deliberate action.
1077 if (!strcmp(fdat.cFileName, ".") ||
1078 !strcmp(fdat.cFileName, "..")) {
1080 * Find*File has returned a special dir. We require
1081 * that _either_ `src' ends in a backslash followed
1082 * by that string, _or_ `src' is precisely that
1085 int len = strlen(src), dlen = strlen(fdat.cFileName);
1086 if (len == dlen && !strcmp(src, fdat.cFileName)) {
1088 } else if (len > dlen + 1 && src[len - dlen - 1] == '\\' &&
1089 !strcmp(src + len - dlen, fdat.cFileName)) {
1092 continue; /* ignore this one */
1094 if (strlen(src) + strlen(fdat.cFileName) >= sizeof(namebuf)) {
1095 tell_user(stderr, "%s: Name too long", src);
1098 strcpy(namebuf, src);
1099 if ((last = strrchr(namebuf, '/')) == NULL)
1103 if (strrchr(last, '\\') != NULL)
1104 last = strrchr(last, '\\') + 1;
1105 if (last == namebuf && strrchr(namebuf, ':') != NULL)
1106 last = strchr(namebuf, ':') + 1;
1107 strcpy(last, fdat.cFileName);
1109 } while (FindNextFile(dir, &fdat));
1115 * We will copy files from a remote server to the local machine.
1117 static void tolocal(int argc, char *argv[])
1119 char *src, *targ, *host, *user;
1123 bump("More than one remote source not supported");
1128 /* Separate host from filename */
1132 bump("Local to local copy not supported");
1136 /* Substitute "." for empty filename */
1138 /* Separate username and hostname */
1140 host = strrchr(host, '@');
1150 cmd = smalloc(strlen(src) + 100);
1151 sprintf(cmd, "scp%s%s%s%s -f %s",
1152 verbose ? " -v" : "",
1153 recursive ? " -r" : "",
1154 preserve ? " -p" : "",
1155 targetshouldbedirectory ? " -d" : "", src);
1156 do_cmd(host, user, cmd);
1163 * We will issue a list command to get a remote directory.
1165 static void get_dir_list(int argc, char *argv[])
1167 char *src, *host, *user;
1173 /* Separate host from filename */
1177 bump("Local to local copy not supported");
1181 /* Substitute "." for empty filename */
1183 /* Separate username and hostname */
1185 host = strrchr(host, '@');
1195 cmd = smalloc(4 * strlen(src) + 100);
1196 strcpy(cmd, "ls -la '");
1197 p = cmd + strlen(cmd);
1198 for (q = src; *q; q++) {
1211 do_cmd(host, user, cmd);
1214 while (ssh_scp_recv(&c, 1) > 0)
1215 tell_char(stdout, c);
1219 * Initialize the Win$ock driver.
1221 static void init_winsock(void)
1226 winsock_ver = MAKEWORD(1, 1);
1227 if (WSAStartup(winsock_ver, &wsadata))
1228 bump("Unable to initialise WinSock");
1229 if (LOBYTE(wsadata.wVersion) != 1 || HIBYTE(wsadata.wVersion) != 1)
1230 bump("WinSock version is incompatible with 1.1");
1234 * Short description of parameters.
1236 static void usage(void)
1238 printf("PuTTY Secure Copy client\n");
1239 printf("%s\n", ver);
1240 printf("Usage: pscp [options] [user@]host:source target\n");
1242 (" pscp [options] source [source...] [user@]host:target\n");
1243 printf(" pscp [options] -ls user@host:filespec\n");
1244 printf("Options:\n");
1245 printf(" -p preserve file attributes\n");
1246 printf(" -q quiet, don't show statistics\n");
1247 printf(" -r copy directories recursively\n");
1248 printf(" -v show verbose messages\n");
1249 printf(" -P port connect to specified port\n");
1250 printf(" -pw passw login with specified password\n");
1253 * -gui is an internal option, used by GUI front ends to get
1254 * pscp to pass progress reports back to them. It's not an
1255 * ordinary user-accessible option, so it shouldn't be part of
1256 * the command-line help. The only people who need to know
1257 * about it are programmers, and they can read the source.
1260 (" -gui hWnd GUI mode with the windows handle for receiving messages\n");
1266 * Main program (no, really?)
1268 int main(int argc, char *argv[])
1272 default_protocol = PROT_TELNET;
1274 flags = FLAG_STDERR;
1275 ssh_get_line = &get_line;
1279 for (i = 1; i < argc; i++) {
1280 if (argv[i][0] != '-')
1282 if (strcmp(argv[i], "-v") == 0)
1283 verbose = 1, flags |= FLAG_VERBOSE;
1284 else if (strcmp(argv[i], "-r") == 0)
1286 else if (strcmp(argv[i], "-p") == 0)
1288 else if (strcmp(argv[i], "-q") == 0)
1290 else if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "-?") == 0)
1292 else if (strcmp(argv[i], "-P") == 0 && i + 1 < argc)
1293 portnumber = atoi(argv[++i]);
1294 else if (strcmp(argv[i], "-pw") == 0 && i + 1 < argc)
1295 password = argv[++i];
1296 else if (strcmp(argv[i], "-gui") == 0 && i + 1 < argc) {
1297 gui_hwnd = argv[++i];
1299 } else if (strcmp(argv[i], "-ls") == 0)
1301 else if (strcmp(argv[i], "--") == 0) {
1314 get_dir_list(argc, argv);
1321 targetshouldbedirectory = 1;
1323 if (colon(argv[argc - 1]) != NULL)
1324 toremote(argc, argv);
1326 tolocal(argc, argv);
1329 if (back != NULL && back->socket() != NULL) {
1331 back->special(TS_EOF);
1332 ssh_scp_recv(&ch, 1);
1337 /* GUI Adaptation - August 2000 */
1339 unsigned int msg_id = WM_RET_ERR_CNT;
1341 msg_id = WM_LS_RET_ERR_CNT;
1343 ((HWND) atoi(gui_hwnd), msg_id, (WPARAM) errs,
1344 0 /*lParam */ ))SleepEx(1000, TRUE);
1346 return (errs == 0 ? 0 : 1);