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 int prev_stats_len
= 0;
57 static char *password
= NULL
;
59 /* GUI Adaptation - Sept 2000 */
60 #define NAME_STR_MAX 2048
61 static char statname
[NAME_STR_MAX
+ 1];
62 static unsigned long statsize
= 0;
63 static int statperct
= 0;
64 static unsigned long statelapsed
= 0;
65 static int gui_mode
= 0;
66 static char *gui_hwnd
= NULL
;
68 static void source(char *src
);
69 static void rsource(char *src
);
70 static void sink(char *targ
, char *src
);
71 /* GUI Adaptation - Sept 2000 */
72 static void tell_char(FILE * stream
, char c
);
73 static void tell_str(FILE * stream
, char *str
);
74 static void tell_user(FILE * stream
, char *fmt
, ...);
75 static void gui_update_stats(char *name
, unsigned long size
,
76 int percentage
, unsigned long elapsed
);
79 * The maximum amount of queued data we accept before we stop and
80 * wait for the server to process some.
82 #define MAX_SCP_BUFSIZE 16384
84 void logevent(char *string
)
88 void ldisc_send(char *buf
, int len
)
91 * This is only here because of the calls to ldisc_send(NULL,
92 * 0) in ssh.c. Nothing in PSCP actually needs to use the ldisc
93 * as an ldisc. So if we get called with any real data, I want
99 void verify_ssh_host_key(char *host
, int port
, char *keytype
,
100 char *keystr
, char *fingerprint
)
106 static const char absentmsg
[] =
107 "The server's host key is not cached in the registry. You\n"
108 "have no guarantee that the server is the computer you\n"
110 "The server's key fingerprint is:\n"
112 "If you trust this host, enter \"y\" to add the key to\n"
113 "PuTTY's cache and carry on connecting.\n"
114 "If you want to carry on connecting just once, without\n"
115 "adding the key to the cache, enter \"n\".\n"
116 "If you do not trust this host, press Return to abandon the\n"
118 "Store key in cache? (y/n) ";
120 static const char wrongmsg
[] =
121 "WARNING - POTENTIAL SECURITY BREACH!\n"
122 "The server's host key does not match the one PuTTY has\n"
123 "cached in the registry. This means that either the\n"
124 "server administrator has changed the host key, or you\n"
125 "have actually connected to another computer pretending\n"
126 "to be the server.\n"
127 "The new key fingerprint is:\n"
129 "If you were expecting this change and trust the new key,\n"
130 "enter \"y\" to update PuTTY's cache and continue connecting.\n"
131 "If you want to carry on connecting but without updating\n"
132 "the cache, enter \"n\".\n"
133 "If you want to abandon the connection completely, press\n"
134 "Return to cancel. Pressing Return is the ONLY guaranteed\n"
136 "Update cached key? (y/n, Return cancels connection) ";
138 static const char abandoned
[] = "Connection abandoned.\n";
143 * Verify the key against the registry.
145 ret
= verify_host_key(host
, port
, keytype
, keystr
);
147 if (ret
== 0) /* success - key matched OK */
150 if (ret
== 2) { /* key was different */
151 fprintf(stderr
, wrongmsg
, fingerprint
);
154 if (ret
== 1) { /* key was absent */
155 fprintf(stderr
, absentmsg
, fingerprint
);
159 hin
= GetStdHandle(STD_INPUT_HANDLE
);
160 GetConsoleMode(hin
, &savemode
);
161 SetConsoleMode(hin
, (savemode
| ENABLE_ECHO_INPUT
|
162 ENABLE_PROCESSED_INPUT
| ENABLE_LINE_INPUT
));
163 ReadFile(hin
, line
, sizeof(line
) - 1, &i
, NULL
);
164 SetConsoleMode(hin
, savemode
);
166 if (line
[0] != '\0' && line
[0] != '\r' && line
[0] != '\n') {
167 if (line
[0] == 'y' || line
[0] == 'Y')
168 store_host_key(host
, port
, keytype
, keystr
);
170 fprintf(stderr
, abandoned
);
176 * Ask whether the selected cipher is acceptable (since it was
177 * below the configured 'warn' threshold).
178 * cs: 0 = both ways, 1 = client->server, 2 = server->client
180 void askcipher(char *ciphername
, int cs
)
185 static const char msg
[] =
186 "The first %scipher supported by the server is\n"
187 "%s, which is below the configured warning threshold.\n"
188 "Continue with connection? (y/n) ";
189 static const char abandoned
[] = "Connection abandoned.\n";
195 (cs
== 1) ?
"client-to-server " :
200 hin
= GetStdHandle(STD_INPUT_HANDLE
);
201 GetConsoleMode(hin
, &savemode
);
202 SetConsoleMode(hin
, (savemode
| ENABLE_ECHO_INPUT
|
203 ENABLE_PROCESSED_INPUT
| ENABLE_LINE_INPUT
));
204 ReadFile(hin
, line
, sizeof(line
) - 1, &i
, NULL
);
205 SetConsoleMode(hin
, savemode
);
207 if (line
[0] == 'y' || line
[0] == 'Y') {
210 fprintf(stderr
, abandoned
);
215 /* GUI Adaptation - Sept 2000 */
216 static void send_msg(HWND h
, UINT message
, WPARAM wParam
)
218 while (!PostMessage(h
, message
, wParam
, 0))
222 static void tell_char(FILE * stream
, char c
)
227 unsigned int msg_id
= WM_STD_OUT_CHAR
;
228 if (stream
== stderr
)
229 msg_id
= WM_STD_ERR_CHAR
;
230 send_msg((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) c
);
234 static void tell_str(FILE * stream
, char *str
)
238 for (i
= 0; i
< strlen(str
); ++i
)
239 tell_char(stream
, str
[i
]);
242 static void tell_user(FILE * stream
, char *fmt
, ...)
244 char str
[0x100]; /* Make the size big enough */
247 vsprintf(str
, fmt
, ap
);
250 tell_str(stream
, str
);
253 static void gui_update_stats(char *name
, unsigned long size
,
254 int percentage
, unsigned long elapsed
)
258 if (strcmp(name
, statname
) != 0) {
259 for (i
= 0; i
< strlen(name
); ++i
)
260 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_CHAR
,
262 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_CHAR
, (WPARAM
) '\n');
263 strcpy(statname
, name
);
265 if (statsize
!= size
) {
266 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_SIZE
, (WPARAM
) size
);
269 if (statelapsed
!= elapsed
) {
270 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_ELAPSED
,
272 statelapsed
= elapsed
;
274 if (statperct
!= percentage
) {
275 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_PERCENT
,
276 (WPARAM
) percentage
);
277 statperct
= percentage
;
282 * Print an error message and perform a fatal exit.
284 void fatalbox(char *fmt
, ...)
286 char str
[0x100]; /* Make the size big enough */
289 strcpy(str
, "Fatal: ");
290 vsprintf(str
+ strlen(str
), fmt
, ap
);
293 tell_str(stderr
, str
);
297 unsigned int msg_id
= WM_RET_ERR_CNT
;
299 msg_id
= WM_LS_RET_ERR_CNT
;
301 ((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) errs
,
302 0 /*lParam */ ))SleepEx(1000, TRUE
);
307 void connection_fatal(char *fmt
, ...)
309 char str
[0x100]; /* Make the size big enough */
312 strcpy(str
, "Fatal: ");
313 vsprintf(str
+ strlen(str
), fmt
, ap
);
316 tell_str(stderr
, str
);
320 unsigned int msg_id
= WM_RET_ERR_CNT
;
322 msg_id
= WM_LS_RET_ERR_CNT
;
324 ((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) errs
,
325 0 /*lParam */ ))SleepEx(1000, TRUE
);
332 * Be told what socket we're supposed to be using.
334 static SOCKET scp_ssh_socket
;
335 char *do_select(SOCKET skt
, int startup
)
338 scp_ssh_socket
= skt
;
340 scp_ssh_socket
= INVALID_SOCKET
;
343 extern int select_result(WPARAM
, LPARAM
);
346 * Receive a block of data from the SSH link. Block until all data
349 * To do this, we repeatedly call the SSH protocol module, with our
350 * own trap in from_backend() to catch the data that comes back. We
351 * do this until we have enough data.
354 static unsigned char *outptr
; /* where to put the data */
355 static unsigned outlen
; /* how much data required */
356 static unsigned char *pending
= NULL
; /* any spare data */
357 static unsigned pendlen
= 0, pendsize
= 0; /* length and phys. size of buffer */
358 int from_backend(int is_stderr
, char *data
, int datalen
)
360 unsigned char *p
= (unsigned char *) data
;
361 unsigned len
= (unsigned) datalen
;
364 * stderr data is just spouted to local stderr and otherwise
368 fwrite(data
, 1, len
, stderr
);
375 * If this is before the real session begins, just return.
381 unsigned used
= outlen
;
384 memcpy(outptr
, p
, used
);
392 if (pendsize
< pendlen
+ len
) {
393 pendsize
= pendlen
+ len
+ 4096;
394 pending
= (pending ?
srealloc(pending
, pendsize
) :
397 fatalbox("Out of memory");
399 memcpy(pending
+ pendlen
, p
, len
);
405 static int scp_process_network_event(void)
410 FD_SET(scp_ssh_socket
, &readfds
);
411 if (select(1, &readfds
, NULL
, NULL
, NULL
) < 0)
413 select_result((WPARAM
) scp_ssh_socket
, (LPARAM
) FD_READ
);
416 static int ssh_scp_recv(unsigned char *buf
, int len
)
422 * See if the pending-input block contains some of what we
426 unsigned pendused
= pendlen
;
427 if (pendused
> outlen
)
429 memcpy(outptr
, pending
, pendused
);
430 memmove(pending
, pending
+ pendused
, pendlen
- pendused
);
444 if (!scp_process_network_event())
452 * Loop through the ssh connection and authentication process.
454 static void ssh_scp_init(void)
456 if (scp_ssh_socket
== INVALID_SOCKET
)
458 while (!back
->sendok()) {
461 FD_SET(scp_ssh_socket
, &readfds
);
462 if (select(1, &readfds
, NULL
, NULL
, NULL
) < 0)
464 select_result((WPARAM
) scp_ssh_socket
, (LPARAM
) FD_READ
);
469 * Print an error message and exit after closing the SSH link.
471 static void bump(char *fmt
, ...)
473 char str
[0x100]; /* Make the size big enough */
476 strcpy(str
, "Fatal: ");
477 vsprintf(str
+ strlen(str
), fmt
, ap
);
480 tell_str(stderr
, str
);
483 if (back
!= NULL
&& back
->socket() != NULL
) {
485 back
->special(TS_EOF
);
486 ssh_scp_recv(&ch
, 1);
490 unsigned int msg_id
= WM_RET_ERR_CNT
;
492 msg_id
= WM_LS_RET_ERR_CNT
;
494 ((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) errs
,
495 0 /*lParam */ ))SleepEx(1000, TRUE
);
501 static int get_line(const char *prompt
, char *str
, int maxlen
, int is_pw
)
504 DWORD savemode
, newmode
, i
;
506 if (is_pw
&& password
) {
507 static int tried_once
= 0;
512 strncpy(str
, password
, maxlen
);
513 str
[maxlen
- 1] = '\0';
519 /* GUI Adaptation - Sept 2000 */
524 hin
= GetStdHandle(STD_INPUT_HANDLE
);
525 hout
= GetStdHandle(STD_OUTPUT_HANDLE
);
526 if (hin
== INVALID_HANDLE_VALUE
|| hout
== INVALID_HANDLE_VALUE
)
527 bump("Cannot get standard input/output handles");
529 GetConsoleMode(hin
, &savemode
);
530 newmode
= savemode
| ENABLE_PROCESSED_INPUT
| ENABLE_LINE_INPUT
;
532 newmode
&= ~ENABLE_ECHO_INPUT
;
534 newmode
|= ENABLE_ECHO_INPUT
;
535 SetConsoleMode(hin
, newmode
);
537 WriteFile(hout
, prompt
, strlen(prompt
), &i
, NULL
);
538 ReadFile(hin
, str
, maxlen
- 1, &i
, NULL
);
540 SetConsoleMode(hin
, savemode
);
542 if ((int) i
> maxlen
)
549 WriteFile(hout
, "\r\n", 2, &i
, NULL
);
556 * Open an SSH connection to user@host and execute cmd.
558 static void do_cmd(char *host
, char *user
, char *cmd
)
560 char *err
, *realhost
;
563 if (host
== NULL
|| host
[0] == '\0')
564 bump("Empty host name");
566 /* Try to load settings for this host */
567 do_defaults(host
, &cfg
);
568 if (cfg
.host
[0] == '\0') {
569 /* No settings for this host; use defaults */
570 do_defaults(NULL
, &cfg
);
571 strncpy(cfg
.host
, host
, sizeof(cfg
.host
) - 1);
572 cfg
.host
[sizeof(cfg
.host
) - 1] = '\0';
577 if (user
!= NULL
&& user
[0] != '\0') {
578 strncpy(cfg
.username
, user
, sizeof(cfg
.username
) - 1);
579 cfg
.username
[sizeof(cfg
.username
) - 1] = '\0';
580 } else if (cfg
.username
[0] == '\0') {
582 if (GetUserName(user
, &namelen
) == FALSE
)
583 bump("Empty user name");
584 user
= smalloc(namelen
* sizeof(char));
585 GetUserName(user
, &namelen
);
587 tell_user(stderr
, "Guessing user name: %s", user
);
588 strncpy(cfg
.username
, user
, sizeof(cfg
.username
) - 1);
589 cfg
.username
[sizeof(cfg
.username
) - 1] = '\0';
593 if (cfg
.protocol
!= PROT_SSH
)
597 cfg
.port
= portnumber
;
599 strncpy(cfg
.remote_cmd
, cmd
, sizeof(cfg
.remote_cmd
));
600 cfg
.remote_cmd
[sizeof(cfg
.remote_cmd
) - 1] = '\0';
605 err
= back
->init(cfg
.host
, cfg
.port
, &realhost
);
607 bump("ssh_init: %s", err
);
609 if (verbose
&& realhost
!= NULL
)
610 tell_user(stderr
, "Connected to %s\n", realhost
);
615 * Update statistic information about current file.
617 static void print_stats(char *name
, unsigned long size
, unsigned long done
,
618 time_t start
, time_t now
)
626 /* GUI Adaptation - Sept 2000 */
628 gui_update_stats(name
, size
, (int) (100 * (done
* 1.0 / size
)),
629 (unsigned long) difftime(now
, start
));
632 ratebs
= (float) done
/ (now
- start
);
634 ratebs
= (float) done
;
639 eta
= (unsigned long) ((size
- done
) / ratebs
);
640 sprintf(etastr
, "%02ld:%02ld:%02ld",
641 eta
/ 3600, (eta
% 3600) / 60, eta
% 60);
643 pct
= (int) (100.0 * (float) done
/ size
);
645 len
= printf("\r%-25.25s | %10ld kB | %5.1f kB/s | ETA: %8s | %3d%%",
646 name
, done
/ 1024, ratebs
/ 1024.0, etastr
, pct
);
647 if (len
< prev_stats_len
)
648 printf("%*s", prev_stats_len
- len
, "");
649 prev_stats_len
= len
;
657 * Find a colon in str and return a pointer to the colon.
658 * This is used to separate hostname from filename.
660 static char *colon(char *str
)
662 /* We ignore a leading colon, since the hostname cannot be
663 empty. We also ignore a colon as second character because
664 of filenames like f:myfile.txt. */
665 if (str
[0] == '\0' || str
[0] == ':' || str
[1] == ':')
667 while (*str
!= '\0' && *str
!= ':' && *str
!= '/' && *str
!= '\\')
676 * Return a pointer to the portion of str that comes after the last
677 * slash or backslash.
679 static char *stripslashes(char *str
)
683 p
= strrchr(str
, '/');
686 p
= strrchr(str
, '\\');
693 * Wait for a response from the other side.
694 * Return 0 if ok, -1 if error.
696 static int response(void)
698 char ch
, resp
, rbuf
[2048];
701 if (ssh_scp_recv(&resp
, 1) <= 0)
702 bump("Lost connection");
712 case 2: /* fatal error */
714 if (ssh_scp_recv(&ch
, 1) <= 0)
715 bump("Protocol error: Lost connection");
717 } while (p
< sizeof(rbuf
) && ch
!= '\n');
720 tell_user(stderr
, "%s\n", rbuf
);
728 /* ----------------------------------------------------------------------
729 * Helper routines that contain the actual SCP protocol elements,
730 * so they can be switched to use SFTP.
733 int scp_send_errmsg(char *str
)
735 back
->send("\001", 1); /* scp protocol error prefix */
736 back
->send(str
, strlen(str
));
737 return 0; /* can't fail */
740 int scp_send_filetimes(unsigned long mtime
, unsigned long atime
)
743 sprintf(buf
, "T%lu 0 %lu 0\n", mtime
, atime
);
744 back
->send(buf
, strlen(buf
));
748 int scp_send_filename(char *name
, unsigned long size
, int modes
)
751 sprintf(buf
, "C%04o %lu ", modes
, size
);
752 back
->send(buf
, strlen(buf
));
753 back
->send(name
, strlen(name
));
758 int scp_send_filedata(char *data
, int len
)
760 int bufsize
= back
->send(data
, len
);
763 * If the network transfer is backing up - that is, the remote
764 * site is not accepting data as fast as we can produce it -
765 * then we must loop on network events until we have space in
768 while (bufsize
> MAX_SCP_BUFSIZE
) {
769 if (!scp_process_network_event())
771 bufsize
= back
->sendbuffer();
777 int scp_send_finish(void)
783 int scp_send_dirname(char *name
, int modes
)
786 sprintf(buf
, "D%04o 0 ", modes
);
787 back
->send(buf
, strlen(buf
));
788 back
->send(name
, strlen(name
));
793 int scp_send_enddir(void)
795 back
->send("E\n", 2);
799 int scp_sink_init(void)
805 #define SCP_SINK_FILE 1
806 #define SCP_SINK_DIR 2
807 #define SCP_SINK_ENDDIR 3
808 struct scp_sink_action
{
809 int action
; /* FILE, DIR, ENDDIR */
810 char *buf
; /* will need freeing after use */
811 char *name
; /* filename or dirname (not ENDDIR) */
812 int mode
; /* access mode (not ENDDIR) */
813 unsigned long size
; /* file size (not ENDDIR) */
814 int settime
; /* 1 if atime and mtime are filled */
815 unsigned long atime
, mtime
; /* access times for the file */
818 int scp_get_sink_action(struct scp_sink_action
*act
)
830 if (ssh_scp_recv(&ch
, 1) <= 0)
833 bump("Protocol error: Unexpected newline");
837 if (ssh_scp_recv(&ch
, 1) <= 0)
838 bump("Lost connection");
841 act
->buf
= srealloc(act
->buf
, bufsize
);
844 } while (ch
!= '\n');
845 act
->buf
[i
- 1] = '\0';
847 case '\01': /* error */
848 tell_user(stderr
, "%s\n", act
->buf
);
850 continue; /* go round again */
851 case '\02': /* fatal error */
852 bump("%s", act
->buf
);
855 act
->action
= SCP_SINK_ENDDIR
;
858 if (sscanf(act
->buf
, "%ld %*d %ld %*d",
859 &act
->mtime
, &act
->atime
) == 2) {
862 continue; /* go round again */
864 bump("Protocol error: Illegal time format");
867 act
->action
= (action
== 'C' ? SCP_SINK_FILE
: SCP_SINK_DIR
);
870 bump("Protocol error: Expected control record");
873 * We will go round this loop only once, unless we hit
880 * If we get here, we must have seen SCP_SINK_FILE or
883 if (sscanf(act
->buf
, "%o %lu %n", &act
->mode
, &act
->size
, &i
) != 2)
884 bump("Protocol error: Illegal file descriptor format");
885 act
->name
= act
->buf
+ i
;
889 int scp_accept_filexfer(void)
892 return 0; /* can't fail */
895 int scp_recv_filedata(char *data
, int len
)
897 return ssh_scp_recv(data
, len
);
900 int scp_finish_filerecv(void)
906 /* ----------------------------------------------------------------------
907 * Send an error message to the other side and to the screen.
908 * Increment error counter.
910 static void run_err(const char *fmt
, ...)
916 strcpy(str
, "scp: ");
917 vsprintf(str
+ strlen(str
), fmt
, ap
);
919 scp_send_errmsg(str
);
920 tell_user(stderr
, "%s", str
);
925 * Execute the source part of the SCP protocol.
927 static void source(char *src
)
934 unsigned long stat_bytes
;
935 time_t stat_starttime
, stat_lasttime
;
937 attr
= GetFileAttributes(src
);
938 if (attr
== (DWORD
) - 1) {
939 run_err("%s: No such file or directory", src
);
943 if ((attr
& FILE_ATTRIBUTE_DIRECTORY
) != 0) {
946 * Avoid . and .. directories.
949 p
= strrchr(src
, '/');
951 p
= strrchr(src
, '\\');
956 if (!strcmp(p
, ".") || !strcmp(p
, ".."))
957 /* skip . and .. */ ;
961 run_err("%s: not a regular file", src
);
966 if ((last
= strrchr(src
, '/')) == NULL
)
970 if (strrchr(last
, '\\') != NULL
)
971 last
= strrchr(last
, '\\') + 1;
972 if (last
== src
&& strchr(src
, ':') != NULL
)
973 last
= strchr(src
, ':') + 1;
975 f
= CreateFile(src
, GENERIC_READ
, FILE_SHARE_READ
, NULL
,
976 OPEN_EXISTING
, 0, 0);
977 if (f
== INVALID_HANDLE_VALUE
) {
978 run_err("%s: Cannot open file", src
);
983 FILETIME actime
, wrtime
;
984 unsigned long mtime
, atime
;
985 GetFileTime(f
, NULL
, &actime
, &wrtime
);
986 TIME_WIN_TO_POSIX(actime
, atime
);
987 TIME_WIN_TO_POSIX(wrtime
, mtime
);
988 if (scp_send_filetimes(mtime
, atime
))
992 size
= GetFileSize(f
, NULL
);
994 tell_user(stderr
, "Sending file %s, size=%lu", last
, size
);
995 if (scp_send_filename(last
, size
, 0644))
999 stat_starttime
= time(NULL
);
1002 for (i
= 0; i
< size
; i
+= 4096) {
1003 char transbuf
[4096];
1008 if (!ReadFile(f
, transbuf
, k
, &j
, NULL
) || j
!= k
) {
1011 bump("%s: Read error", src
);
1013 if (scp_send_filedata(transbuf
, k
))
1014 bump("%s: Network error occurred", src
);
1018 if (time(NULL
) != stat_lasttime
|| i
+ k
== size
) {
1019 stat_lasttime
= time(NULL
);
1020 print_stats(last
, size
, stat_bytes
,
1021 stat_starttime
, stat_lasttime
);
1028 (void) scp_send_finish();
1032 * Recursively send the contents of a directory.
1034 static void rsource(char *src
)
1036 char *last
, *findfile
;
1038 WIN32_FIND_DATA fdat
;
1041 if ((last
= strrchr(src
, '/')) == NULL
)
1045 if (strrchr(last
, '\\') != NULL
)
1046 last
= strrchr(last
, '\\') + 1;
1047 if (last
== src
&& strchr(src
, ':') != NULL
)
1048 last
= strchr(src
, ':') + 1;
1050 /* maybe send filetime */
1053 tell_user(stderr
, "Entering directory: %s", last
);
1054 if (scp_send_dirname(last
, 0755))
1057 findfile
= dupcat(src
, "/*", NULL
);
1058 dir
= FindFirstFile(findfile
, &fdat
);
1059 ok
= (dir
!= INVALID_HANDLE_VALUE
);
1061 if (strcmp(fdat
.cFileName
, ".") == 0 ||
1062 strcmp(fdat
.cFileName
, "..") == 0) {
1063 /* ignore . and .. */
1065 char *foundfile
= dupcat(src
, "/", fdat
.cFileName
);
1069 ok
= FindNextFile(dir
, &fdat
);
1074 (void) scp_send_enddir();
1078 * Execute the sink part of the SCP protocol.
1080 static void sink(char *targ
, char *src
)
1089 unsigned long received
;
1091 unsigned long stat_bytes
;
1092 time_t stat_starttime
, stat_lasttime
;
1095 attr
= GetFileAttributes(targ
);
1096 if (attr
!= (DWORD
) - 1 && (attr
& FILE_ATTRIBUTE_DIRECTORY
) != 0)
1099 if (targetshouldbedirectory
&& !targisdir
)
1100 bump("%s: Not a directory", targ
);
1104 struct scp_sink_action act
;
1105 if (scp_get_sink_action(&act
))
1108 if (act
.action
== SCP_SINK_ENDDIR
)
1113 * Prevent the remote side from maliciously writing to
1114 * files outside the target area by sending a filename
1115 * containing `../'. In fact, it shouldn't be sending
1116 * filenames with any slashes in at all; so we'll find
1117 * the last slash or backslash in the filename and use
1118 * only the part after that. (And warn!)
1120 * In addition, we also ensure here that if we're
1121 * copying a single file and the target is a directory
1122 * (common usage: `pscp host:filename .') the remote
1123 * can't send us a _different_ file name. We can
1124 * distinguish this case because `src' will be non-NULL
1125 * and the last component of that will fail to match
1126 * (the last component of) the name sent.
1128 char *striptarget
, *stripsrc
;
1130 striptarget
= stripslashes(act
.name
);
1131 if (striptarget
!= act
.name
) {
1132 tell_user(stderr
, "warning: remote host sent a compound"
1133 " pathname - possibly malicious! (ignored)");
1137 * Also check to see if the target filename is '.' or
1138 * '..', or indeed '...' and so on because Windows
1139 * appears to interpret those like '..'.
1141 if (striptarget
[strspn(striptarget
, ".")] == '\0') {
1142 bump("security violation: remote host attempted to write to"
1143 " a '.' or '..' path!");
1147 stripsrc
= stripslashes(src
);
1148 if (strcmp(striptarget
, stripsrc
)) {
1149 tell_user(stderr
, "warning: remote host attempted to"
1150 " write to a different filename: disallowing");
1152 /* Override the name the server provided with our own. */
1153 striptarget
= stripsrc
;
1156 if (targ
[0] != '\0')
1157 destfname
= dupcat(targ
, "\\", striptarget
, NULL
);
1159 destfname
= dupstr(striptarget
);
1162 * In this branch of the if, the target area is a
1163 * single file with an explicitly specified name in any
1164 * case, so there's no danger.
1166 destfname
= dupstr(targ
);
1168 attr
= GetFileAttributes(destfname
);
1169 exists
= (attr
!= (DWORD
) - 1);
1171 if (act
.action
== SCP_SINK_DIR
) {
1172 if (exists
&& (attr
& FILE_ATTRIBUTE_DIRECTORY
) == 0) {
1173 run_err("%s: Not a directory", destfname
);
1177 if (!CreateDirectory(destfname
, NULL
)) {
1178 run_err("%s: Cannot create directory", destfname
);
1182 sink(destfname
, NULL
);
1183 /* can we set the timestamp for directories ? */
1187 f
= CreateFile(destfname
, GENERIC_WRITE
, 0, NULL
,
1188 CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, 0);
1189 if (f
== INVALID_HANDLE_VALUE
) {
1190 run_err("%s: Cannot create file", destfname
);
1194 if (scp_accept_filexfer())
1198 stat_starttime
= time(NULL
);
1200 stat_name
= stripslashes(destfname
);
1203 while (received
< act
.size
) {
1204 char transbuf
[4096];
1205 DWORD blksize
, read
, written
;
1207 if (blksize
> act
.size
- received
)
1208 blksize
= act
.size
- received
;
1209 read
= scp_recv_filedata(transbuf
, blksize
);
1211 bump("Lost connection");
1214 if (!WriteFile(f
, transbuf
, read
, &written
, NULL
) ||
1217 /* FIXME: in sftp we can actually abort the transfer */
1219 printf("\r%-25.25s | %50s\n",
1221 "Write error.. waiting for end of file");
1226 if (time(NULL
) > stat_lasttime
||
1227 received
+ read
== act
.size
) {
1228 stat_lasttime
= time(NULL
);
1229 print_stats(stat_name
, act
.size
, stat_bytes
,
1230 stat_starttime
, stat_lasttime
);
1236 FILETIME actime
, wrtime
;
1237 TIME_POSIX_TO_WIN(act
.atime
, actime
);
1238 TIME_POSIX_TO_WIN(act
.mtime
, wrtime
);
1239 SetFileTime(f
, NULL
, &actime
, &wrtime
);
1244 run_err("%s: Write error", destfname
);
1247 (void) scp_finish_filerecv();
1254 * We will copy local files to a remote server.
1256 static void toremote(int argc
, char *argv
[])
1258 char *src
, *targ
, *host
, *user
;
1262 targ
= argv
[argc
- 1];
1264 /* Separate host from filename */
1268 bump("targ == NULL in toremote()");
1272 /* Substitute "." for emtpy target */
1274 /* Separate host and username */
1276 host
= strrchr(host
, '@');
1287 /* Find out if the source filespec covers multiple files
1288 if so, we should set the targetshouldbedirectory flag */
1290 WIN32_FIND_DATA fdat
;
1291 if (colon(argv
[0]) != NULL
)
1292 bump("%s: Remote to remote not supported", argv
[0]);
1293 fh
= FindFirstFile(argv
[0], &fdat
);
1294 if (fh
== INVALID_HANDLE_VALUE
)
1295 bump("%s: No such file or directory\n", argv
[0]);
1296 if (FindNextFile(fh
, &fdat
))
1297 targetshouldbedirectory
= 1;
1301 cmd
= smalloc(strlen(targ
) + 100);
1302 sprintf(cmd
, "scp%s%s%s%s -t %s",
1303 verbose ?
" -v" : "",
1304 recursive ?
" -r" : "",
1305 preserve ?
" -p" : "",
1306 targetshouldbedirectory ?
" -d" : "", targ
);
1307 do_cmd(host
, user
, cmd
);
1312 for (i
= 0; i
< argc
- 1; i
++) {
1313 char *srcpath
, *last
;
1315 WIN32_FIND_DATA fdat
;
1317 if (colon(src
) != NULL
) {
1318 tell_user(stderr
, "%s: Remote to remote not supported\n", src
);
1324 * Trim off the last pathname component of `src', to
1325 * provide the base pathname which will be prepended to
1326 * filenames returned from Find{First,Next}File.
1328 srcpath
= dupstr(src
);
1329 last
= stripslashes(srcpath
);
1330 if (last
== srcpath
) {
1331 last
= strchr(srcpath
, ':');
1339 dir
= FindFirstFile(src
, &fdat
);
1340 if (dir
== INVALID_HANDLE_VALUE
) {
1341 run_err("%s: No such file or directory", src
);
1348 * Ensure that . and .. are never matched by wildcards,
1349 * but only by deliberate action.
1351 if (!strcmp(fdat
.cFileName
, ".") ||
1352 !strcmp(fdat
.cFileName
, "..")) {
1354 * Find*File has returned a special dir. We require
1355 * that _either_ `src' ends in a backslash followed
1356 * by that string, _or_ `src' is precisely that
1359 int len
= strlen(src
), dlen
= strlen(fdat
.cFileName
);
1360 if (len
== dlen
&& !strcmp(src
, fdat
.cFileName
)) {
1362 } else if (len
> dlen
+ 1 && src
[len
- dlen
- 1] == '\\' &&
1363 !strcmp(src
+ len
- dlen
, fdat
.cFileName
)) {
1366 continue; /* ignore this one */
1368 filename
= dupcat(srcpath
, fdat
.cFileName
, NULL
);
1371 } while (FindNextFile(dir
, &fdat
));
1378 * We will copy files from a remote server to the local machine.
1380 static void tolocal(int argc
, char *argv
[])
1382 char *src
, *targ
, *host
, *user
;
1386 bump("More than one remote source not supported");
1391 /* Separate host from filename */
1395 bump("Local to local copy not supported");
1399 /* Substitute "." for empty filename */
1401 /* Separate username and hostname */
1403 host
= strrchr(host
, '@');
1413 cmd
= smalloc(strlen(src
) + 100);
1414 sprintf(cmd
, "scp%s%s%s%s -f %s",
1415 verbose ?
" -v" : "",
1416 recursive ?
" -r" : "",
1417 preserve ?
" -p" : "",
1418 targetshouldbedirectory ?
" -d" : "", src
);
1419 do_cmd(host
, user
, cmd
);
1426 * We will issue a list command to get a remote directory.
1428 static void get_dir_list(int argc
, char *argv
[])
1430 char *src
, *host
, *user
;
1436 /* Separate host from filename */
1440 bump("Local to local copy not supported");
1444 /* Substitute "." for empty filename */
1446 /* Separate username and hostname */
1448 host
= strrchr(host
, '@');
1458 cmd
= smalloc(4 * strlen(src
) + 100);
1459 strcpy(cmd
, "ls -la '");
1460 p
= cmd
+ strlen(cmd
);
1461 for (q
= src
; *q
; q
++) {
1474 do_cmd(host
, user
, cmd
);
1477 while (ssh_scp_recv(&c
, 1) > 0)
1478 tell_char(stdout
, c
);
1482 * Initialize the Win$ock driver.
1484 static void init_winsock(void)
1489 winsock_ver
= MAKEWORD(1, 1);
1490 if (WSAStartup(winsock_ver
, &wsadata
))
1491 bump("Unable to initialise WinSock");
1492 if (LOBYTE(wsadata
.wVersion
) != 1 || HIBYTE(wsadata
.wVersion
) != 1)
1493 bump("WinSock version is incompatible with 1.1");
1497 * Short description of parameters.
1499 static void usage(void)
1501 printf("PuTTY Secure Copy client\n");
1502 printf("%s\n", ver
);
1503 printf("Usage: pscp [options] [user@]host:source target\n");
1505 (" pscp [options] source [source...] [user@]host:target\n");
1506 printf(" pscp [options] -ls user@host:filespec\n");
1507 printf("Options:\n");
1508 printf(" -p preserve file attributes\n");
1509 printf(" -q quiet, don't show statistics\n");
1510 printf(" -r copy directories recursively\n");
1511 printf(" -v show verbose messages\n");
1512 printf(" -P port connect to specified port\n");
1513 printf(" -pw passw login with specified password\n");
1516 * -gui is an internal option, used by GUI front ends to get
1517 * pscp to pass progress reports back to them. It's not an
1518 * ordinary user-accessible option, so it shouldn't be part of
1519 * the command-line help. The only people who need to know
1520 * about it are programmers, and they can read the source.
1523 (" -gui hWnd GUI mode with the windows handle for receiving messages\n");
1529 * Main program (no, really?)
1531 int main(int argc
, char *argv
[])
1535 default_protocol
= PROT_TELNET
;
1537 flags
= FLAG_STDERR
;
1538 ssh_get_line
= &get_line
;
1542 for (i
= 1; i
< argc
; i
++) {
1543 if (argv
[i
][0] != '-')
1545 if (strcmp(argv
[i
], "-v") == 0)
1546 verbose
= 1, flags
|= FLAG_VERBOSE
;
1547 else if (strcmp(argv
[i
], "-r") == 0)
1549 else if (strcmp(argv
[i
], "-p") == 0)
1551 else if (strcmp(argv
[i
], "-q") == 0)
1553 else if (strcmp(argv
[i
], "-h") == 0 || strcmp(argv
[i
], "-?") == 0)
1555 else if (strcmp(argv
[i
], "-P") == 0 && i
+ 1 < argc
)
1556 portnumber
= atoi(argv
[++i
]);
1557 else if (strcmp(argv
[i
], "-pw") == 0 && i
+ 1 < argc
)
1558 password
= argv
[++i
];
1559 else if (strcmp(argv
[i
], "-gui") == 0 && i
+ 1 < argc
) {
1560 gui_hwnd
= argv
[++i
];
1562 } else if (strcmp(argv
[i
], "-ls") == 0)
1564 else if (strcmp(argv
[i
], "--") == 0) {
1577 get_dir_list(argc
, argv
);
1584 targetshouldbedirectory
= 1;
1586 if (colon(argv
[argc
- 1]) != NULL
)
1587 toremote(argc
, argv
);
1589 tolocal(argc
, argv
);
1592 if (back
!= NULL
&& back
->socket() != NULL
) {
1594 back
->special(TS_EOF
);
1595 ssh_scp_recv(&ch
, 1);
1600 /* GUI Adaptation - August 2000 */
1602 unsigned int msg_id
= WM_RET_ERR_CNT
;
1604 msg_id
= WM_LS_RET_ERR_CNT
;
1606 ((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) errs
,
1607 0 /*lParam */ ))SleepEx(1000, TRUE
);
1609 return (errs
== 0 ?
0 : 1);