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 * (SGT, 2001-09-10: Joris van Rantwijk assures me that although
9 * this file as originally submitted was inspired by, and
10 * _structurally_ based on, ssh-1.2.26's scp.c, there wasn't any
11 * actual code duplicated, so the above comment shouldn't give rise
12 * to licensing issues.)
30 #define PUTTY_DO_GLOBALS
37 #define TIME_POSIX_TO_WIN(t, ft) (*(LONGLONG*)&(ft) = \
38 ((LONGLONG) (t) + (LONGLONG) 11644473600) * (LONGLONG) 10000000)
39 #define TIME_WIN_TO_POSIX(ft, t) ((t) = (unsigned long) \
40 ((*(LONGLONG*)&(ft)) / (LONGLONG) 10000000 - (LONGLONG) 11644473600))
42 /* GUI Adaptation - Sept 2000 */
43 #define WM_APP_BASE 0x8000
44 #define WM_STD_OUT_CHAR ( WM_APP_BASE+400 )
45 #define WM_STD_ERR_CHAR ( WM_APP_BASE+401 )
46 #define WM_STATS_CHAR ( WM_APP_BASE+402 )
47 #define WM_STATS_SIZE ( WM_APP_BASE+403 )
48 #define WM_STATS_PERCENT ( WM_APP_BASE+404 )
49 #define WM_STATS_ELAPSED ( WM_APP_BASE+405 )
50 #define WM_RET_ERR_CNT ( WM_APP_BASE+406 )
51 #define WM_LS_RET_ERR_CNT ( WM_APP_BASE+407 )
54 static int verbose
= 0;
55 static int recursive
= 0;
56 static int preserve
= 0;
57 static int targetshouldbedirectory
= 0;
58 static int statistics
= 1;
59 static int portnumber
= 0;
60 static int prev_stats_len
= 0;
61 static int scp_unsafe_mode
= 0;
62 static char *password
= NULL
;
64 /* GUI Adaptation - Sept 2000 */
65 #define NAME_STR_MAX 2048
66 static char statname
[NAME_STR_MAX
+ 1];
67 static unsigned long statsize
= 0;
68 static int statperct
= 0;
69 static unsigned long statelapsed
= 0;
70 static int gui_mode
= 0;
71 static char *gui_hwnd
= NULL
;
72 static int using_sftp
= 0;
74 static void source(char *src
);
75 static void rsource(char *src
);
76 static void sink(char *targ
, char *src
);
77 /* GUI Adaptation - Sept 2000 */
78 static void tell_char(FILE * stream
, char c
);
79 static void tell_str(FILE * stream
, char *str
);
80 static void tell_user(FILE * stream
, char *fmt
, ...);
81 static void gui_update_stats(char *name
, unsigned long size
,
82 int percentage
, unsigned long elapsed
);
85 * The maximum amount of queued data we accept before we stop and
86 * wait for the server to process some.
88 #define MAX_SCP_BUFSIZE 16384
90 void logevent(char *string
)
94 void ldisc_send(char *buf
, int len
, int interactive
)
97 * This is only here because of the calls to ldisc_send(NULL,
98 * 0) in ssh.c. Nothing in PSCP actually needs to use the ldisc
99 * as an ldisc. So if we get called with any real data, I want
105 void verify_ssh_host_key(char *host
, int port
, char *keytype
,
106 char *keystr
, char *fingerprint
)
112 static const char absentmsg
[] =
113 "The server's host key is not cached in the registry. You\n"
114 "have no guarantee that the server is the computer you\n"
116 "The server's key fingerprint is:\n"
118 "If you trust this host, enter \"y\" to add the key to\n"
119 "PuTTY's cache and carry on connecting.\n"
120 "If you want to carry on connecting just once, without\n"
121 "adding the key to the cache, enter \"n\".\n"
122 "If you do not trust this host, press Return to abandon the\n"
124 "Store key in cache? (y/n) ";
126 static const char wrongmsg
[] =
127 "WARNING - POTENTIAL SECURITY BREACH!\n"
128 "The server's host key does not match the one PuTTY has\n"
129 "cached in the registry. This means that either the\n"
130 "server administrator has changed the host key, or you\n"
131 "have actually connected to another computer pretending\n"
132 "to be the server.\n"
133 "The new key fingerprint is:\n"
135 "If you were expecting this change and trust the new key,\n"
136 "enter \"y\" to update PuTTY's cache and continue connecting.\n"
137 "If you want to carry on connecting but without updating\n"
138 "the cache, enter \"n\".\n"
139 "If you want to abandon the connection completely, press\n"
140 "Return to cancel. Pressing Return is the ONLY guaranteed\n"
142 "Update cached key? (y/n, Return cancels connection) ";
144 static const char abandoned
[] = "Connection abandoned.\n";
149 * Verify the key against the registry.
151 ret
= verify_host_key(host
, port
, keytype
, keystr
);
153 if (ret
== 0) /* success - key matched OK */
156 if (ret
== 2) { /* key was different */
157 fprintf(stderr
, wrongmsg
, fingerprint
);
160 if (ret
== 1) { /* key was absent */
161 fprintf(stderr
, absentmsg
, fingerprint
);
165 hin
= GetStdHandle(STD_INPUT_HANDLE
);
166 GetConsoleMode(hin
, &savemode
);
167 SetConsoleMode(hin
, (savemode
| ENABLE_ECHO_INPUT
|
168 ENABLE_PROCESSED_INPUT
| ENABLE_LINE_INPUT
));
169 ReadFile(hin
, line
, sizeof(line
) - 1, &i
, NULL
);
170 SetConsoleMode(hin
, savemode
);
172 if (line
[0] != '\0' && line
[0] != '\r' && line
[0] != '\n') {
173 if (line
[0] == 'y' || line
[0] == 'Y')
174 store_host_key(host
, port
, keytype
, keystr
);
176 fprintf(stderr
, abandoned
);
182 * Ask whether the selected cipher is acceptable (since it was
183 * below the configured 'warn' threshold).
184 * cs: 0 = both ways, 1 = client->server, 2 = server->client
186 void askcipher(char *ciphername
, int cs
)
191 static const char msg
[] =
192 "The first %scipher supported by the server is\n"
193 "%s, which is below the configured warning threshold.\n"
194 "Continue with connection? (y/n) ";
195 static const char abandoned
[] = "Connection abandoned.\n";
201 (cs
== 1) ?
"client-to-server " :
206 hin
= GetStdHandle(STD_INPUT_HANDLE
);
207 GetConsoleMode(hin
, &savemode
);
208 SetConsoleMode(hin
, (savemode
| ENABLE_ECHO_INPUT
|
209 ENABLE_PROCESSED_INPUT
| ENABLE_LINE_INPUT
));
210 ReadFile(hin
, line
, sizeof(line
) - 1, &i
, NULL
);
211 SetConsoleMode(hin
, savemode
);
213 if (line
[0] == 'y' || line
[0] == 'Y') {
216 fprintf(stderr
, abandoned
);
221 /* GUI Adaptation - Sept 2000 */
222 static void send_msg(HWND h
, UINT message
, WPARAM wParam
)
224 while (!PostMessage(h
, message
, wParam
, 0))
228 static void tell_char(FILE * stream
, char c
)
233 unsigned int msg_id
= WM_STD_OUT_CHAR
;
234 if (stream
== stderr
)
235 msg_id
= WM_STD_ERR_CHAR
;
236 send_msg((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) c
);
240 static void tell_str(FILE * stream
, char *str
)
244 for (i
= 0; i
< strlen(str
); ++i
)
245 tell_char(stream
, str
[i
]);
248 static void tell_user(FILE * stream
, char *fmt
, ...)
250 char str
[0x100]; /* Make the size big enough */
253 vsprintf(str
, fmt
, ap
);
256 tell_str(stream
, str
);
259 static void gui_update_stats(char *name
, unsigned long size
,
260 int percentage
, unsigned long elapsed
)
264 if (strcmp(name
, statname
) != 0) {
265 for (i
= 0; i
< strlen(name
); ++i
)
266 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_CHAR
,
268 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_CHAR
, (WPARAM
) '\n');
269 strcpy(statname
, name
);
271 if (statsize
!= size
) {
272 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_SIZE
, (WPARAM
) size
);
275 if (statelapsed
!= elapsed
) {
276 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_ELAPSED
,
278 statelapsed
= elapsed
;
280 if (statperct
!= percentage
) {
281 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_PERCENT
,
282 (WPARAM
) percentage
);
283 statperct
= percentage
;
288 * Print an error message and perform a fatal exit.
290 void fatalbox(char *fmt
, ...)
292 char str
[0x100]; /* Make the size big enough */
295 strcpy(str
, "Fatal: ");
296 vsprintf(str
+ strlen(str
), fmt
, ap
);
299 tell_str(stderr
, str
);
303 unsigned int msg_id
= WM_RET_ERR_CNT
;
305 msg_id
= WM_LS_RET_ERR_CNT
;
307 ((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) errs
,
308 0 /*lParam */ ))SleepEx(1000, TRUE
);
313 void connection_fatal(char *fmt
, ...)
315 char str
[0x100]; /* Make the size big enough */
318 strcpy(str
, "Fatal: ");
319 vsprintf(str
+ strlen(str
), fmt
, ap
);
322 tell_str(stderr
, str
);
326 unsigned int msg_id
= WM_RET_ERR_CNT
;
328 msg_id
= WM_LS_RET_ERR_CNT
;
330 ((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) errs
,
331 0 /*lParam */ ))SleepEx(1000, TRUE
);
338 * Be told what socket we're supposed to be using.
340 static SOCKET scp_ssh_socket
;
341 char *do_select(SOCKET skt
, int startup
)
344 scp_ssh_socket
= skt
;
346 scp_ssh_socket
= INVALID_SOCKET
;
349 extern int select_result(WPARAM
, LPARAM
);
352 * Receive a block of data from the SSH link. Block until all data
355 * To do this, we repeatedly call the SSH protocol module, with our
356 * own trap in from_backend() to catch the data that comes back. We
357 * do this until we have enough data.
360 static unsigned char *outptr
; /* where to put the data */
361 static unsigned outlen
; /* how much data required */
362 static unsigned char *pending
= NULL
; /* any spare data */
363 static unsigned pendlen
= 0, pendsize
= 0; /* length and phys. size of buffer */
364 int from_backend(int is_stderr
, char *data
, int datalen
)
366 unsigned char *p
= (unsigned char *) data
;
367 unsigned len
= (unsigned) datalen
;
370 * stderr data is just spouted to local stderr and otherwise
374 fwrite(data
, 1, len
, stderr
);
379 * If this is before the real session begins, just return.
385 unsigned used
= outlen
;
388 memcpy(outptr
, p
, used
);
396 if (pendsize
< pendlen
+ len
) {
397 pendsize
= pendlen
+ len
+ 4096;
398 pending
= (pending ?
srealloc(pending
, pendsize
) :
401 fatalbox("Out of memory");
403 memcpy(pending
+ pendlen
, p
, len
);
409 static int scp_process_network_event(void)
414 FD_SET(scp_ssh_socket
, &readfds
);
415 if (select(1, &readfds
, NULL
, NULL
, NULL
) < 0)
417 select_result((WPARAM
) scp_ssh_socket
, (LPARAM
) FD_READ
);
420 static int ssh_scp_recv(unsigned char *buf
, int len
)
426 * See if the pending-input block contains some of what we
430 unsigned pendused
= pendlen
;
431 if (pendused
> outlen
)
433 memcpy(outptr
, pending
, pendused
);
434 memmove(pending
, pending
+ pendused
, pendlen
- pendused
);
448 if (!scp_process_network_event())
456 * Loop through the ssh connection and authentication process.
458 static void ssh_scp_init(void)
460 if (scp_ssh_socket
== INVALID_SOCKET
)
462 while (!back
->sendok()) {
465 FD_SET(scp_ssh_socket
, &readfds
);
466 if (select(1, &readfds
, NULL
, NULL
, NULL
) < 0)
468 select_result((WPARAM
) scp_ssh_socket
, (LPARAM
) FD_READ
);
470 using_sftp
= !ssh_fallback_cmd
;
474 * Print an error message and exit after closing the SSH link.
476 static void bump(char *fmt
, ...)
478 char str
[0x100]; /* Make the size big enough */
481 strcpy(str
, "Fatal: ");
482 vsprintf(str
+ strlen(str
), fmt
, ap
);
485 tell_str(stderr
, str
);
488 if (back
!= NULL
&& back
->socket() != NULL
) {
490 back
->special(TS_EOF
);
491 ssh_scp_recv(&ch
, 1);
495 unsigned int msg_id
= WM_RET_ERR_CNT
;
497 msg_id
= WM_LS_RET_ERR_CNT
;
499 ((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) errs
,
500 0 /*lParam */ ))SleepEx(1000, TRUE
);
506 static int get_line(const char *prompt
, char *str
, int maxlen
, int is_pw
)
509 DWORD savemode
, newmode
, i
;
511 if (is_pw
&& password
) {
512 static int tried_once
= 0;
517 strncpy(str
, password
, maxlen
);
518 str
[maxlen
- 1] = '\0';
524 /* GUI Adaptation - Sept 2000 */
529 hin
= GetStdHandle(STD_INPUT_HANDLE
);
530 hout
= GetStdHandle(STD_OUTPUT_HANDLE
);
531 if (hin
== INVALID_HANDLE_VALUE
|| hout
== INVALID_HANDLE_VALUE
)
532 bump("Cannot get standard input/output handles");
534 GetConsoleMode(hin
, &savemode
);
535 newmode
= savemode
| ENABLE_PROCESSED_INPUT
| ENABLE_LINE_INPUT
;
537 newmode
&= ~ENABLE_ECHO_INPUT
;
539 newmode
|= ENABLE_ECHO_INPUT
;
540 SetConsoleMode(hin
, newmode
);
542 WriteFile(hout
, prompt
, strlen(prompt
), &i
, NULL
);
543 ReadFile(hin
, str
, maxlen
- 1, &i
, NULL
);
545 SetConsoleMode(hin
, savemode
);
547 if ((int) i
> maxlen
)
554 WriteFile(hout
, "\r\n", 2, &i
, NULL
);
561 * Open an SSH connection to user@host and execute cmd.
563 static void do_cmd(char *host
, char *user
, char *cmd
)
565 char *err
, *realhost
;
568 if (host
== NULL
|| host
[0] == '\0')
569 bump("Empty host name");
571 /* Try to load settings for this host */
572 do_defaults(host
, &cfg
);
573 if (cfg
.host
[0] == '\0') {
574 /* No settings for this host; use defaults */
575 do_defaults(NULL
, &cfg
);
576 strncpy(cfg
.host
, host
, sizeof(cfg
.host
) - 1);
577 cfg
.host
[sizeof(cfg
.host
) - 1] = '\0';
582 if (user
!= NULL
&& user
[0] != '\0') {
583 strncpy(cfg
.username
, user
, sizeof(cfg
.username
) - 1);
584 cfg
.username
[sizeof(cfg
.username
) - 1] = '\0';
585 } else if (cfg
.username
[0] == '\0') {
587 if (GetUserName(user
, &namelen
) == FALSE
)
588 bump("Empty user name");
589 user
= smalloc(namelen
* sizeof(char));
590 GetUserName(user
, &namelen
);
592 tell_user(stderr
, "Guessing user name: %s", user
);
593 strncpy(cfg
.username
, user
, sizeof(cfg
.username
) - 1);
594 cfg
.username
[sizeof(cfg
.username
) - 1] = '\0';
598 if (cfg
.protocol
!= PROT_SSH
)
602 cfg
.port
= portnumber
;
605 * Disable scary things which shouldn't be enabled for simple
606 * things like SCP and SFTP: agent forwarding, port forwarding,
611 cfg
.portfwd
[0] = cfg
.portfwd
[1] = '\0';
614 * Attempt to start the SFTP subsystem as a first choice,
615 * falling back to the provided scp command if that fails.
617 strcpy(cfg
.remote_cmd
, "sftp");
618 cfg
.ssh_subsys
= TRUE
;
619 cfg
.remote_cmd_ptr2
= cmd
;
620 cfg
.ssh_subsys2
= FALSE
;
625 err
= back
->init(cfg
.host
, cfg
.port
, &realhost
);
627 bump("ssh_init: %s", err
);
629 if (verbose
&& realhost
!= NULL
)
630 tell_user(stderr
, "Connected to %s\n", realhost
);
635 * Update statistic information about current file.
637 static void print_stats(char *name
, unsigned long size
, unsigned long done
,
638 time_t start
, time_t now
)
646 /* GUI Adaptation - Sept 2000 */
648 gui_update_stats(name
, size
, (int) (100 * (done
* 1.0 / size
)),
649 (unsigned long) difftime(now
, start
));
652 ratebs
= (float) done
/ (now
- start
);
654 ratebs
= (float) done
;
659 eta
= (unsigned long) ((size
- done
) / ratebs
);
660 sprintf(etastr
, "%02ld:%02ld:%02ld",
661 eta
/ 3600, (eta
% 3600) / 60, eta
% 60);
663 pct
= (int) (100 * (done
* 1.0 / size
));
665 len
= printf("\r%-25.25s | %10ld kB | %5.1f kB/s | ETA: %8s | %3d%%",
666 name
, done
/ 1024, ratebs
/ 1024.0, etastr
, pct
);
667 if (len
< prev_stats_len
)
668 printf("%*s", prev_stats_len
- len
, "");
669 prev_stats_len
= len
;
677 * Find a colon in str and return a pointer to the colon.
678 * This is used to separate hostname from filename.
680 static char *colon(char *str
)
682 /* We ignore a leading colon, since the hostname cannot be
683 empty. We also ignore a colon as second character because
684 of filenames like f:myfile.txt. */
685 if (str
[0] == '\0' || str
[0] == ':' || str
[1] == ':')
687 while (*str
!= '\0' && *str
!= ':' && *str
!= '/' && *str
!= '\\')
696 * Return a pointer to the portion of str that comes after the last
697 * slash (or backslash or colon, if `local' is TRUE).
699 static char *stripslashes(char *str
, int local
)
704 p
= strchr(str
, ':');
708 p
= strrchr(str
, '/');
712 p
= strrchr(str
, '\\');
720 * Determine whether a string is entirely composed of dots.
722 static int is_dots(char *str
)
724 return str
[strspn(str
, ".")] == '\0';
728 * Wait for a response from the other side.
729 * Return 0 if ok, -1 if error.
731 static int response(void)
733 char ch
, resp
, rbuf
[2048];
736 if (ssh_scp_recv(&resp
, 1) <= 0)
737 bump("Lost connection");
747 case 2: /* fatal error */
749 if (ssh_scp_recv(&ch
, 1) <= 0)
750 bump("Protocol error: Lost connection");
752 } while (p
< sizeof(rbuf
) && ch
!= '\n');
755 tell_user(stderr
, "%s\n", rbuf
);
763 int sftp_recvdata(char *buf
, int len
)
765 return ssh_scp_recv(buf
, len
);
767 int sftp_senddata(char *buf
, int len
)
769 back
->send((unsigned char *) buf
, len
);
773 /* ----------------------------------------------------------------------
774 * sftp-based replacement for the hacky `pscp -ls'.
776 static int sftp_ls_compare(const void *av
, const void *bv
)
778 const struct fxp_name
*a
= (const struct fxp_name
*) av
;
779 const struct fxp_name
*b
= (const struct fxp_name
*) bv
;
780 return strcmp(a
->filename
, b
->filename
);
782 void scp_sftp_listdir(char *dirname
)
784 struct fxp_handle
*dirh
;
785 struct fxp_names
*names
;
786 struct fxp_name
*ournames
;
787 int nnames
, namesize
;
790 printf("Listing directory %s\n", dirname
);
792 dirh
= fxp_opendir(dirname
);
794 printf("Unable to open %s: %s\n", dirname
, fxp_error());
796 nnames
= namesize
= 0;
801 names
= fxp_readdir(dirh
);
803 if (fxp_error_type() == SSH_FX_EOF
)
805 printf("Reading directory %s: %s\n", dirname
, fxp_error());
808 if (names
->nnames
== 0) {
809 fxp_free_names(names
);
813 if (nnames
+ names
->nnames
>= namesize
) {
814 namesize
+= names
->nnames
+ 128;
816 srealloc(ournames
, namesize
* sizeof(*ournames
));
819 for (i
= 0; i
< names
->nnames
; i
++)
820 ournames
[nnames
++] = names
->names
[i
];
822 names
->nnames
= 0; /* prevent free_names */
823 fxp_free_names(names
);
828 * Now we have our filenames. Sort them by actual file
829 * name, and then output the longname parts.
831 qsort(ournames
, nnames
, sizeof(*ournames
), sftp_ls_compare
);
836 for (i
= 0; i
< nnames
; i
++)
837 printf("%s\n", ournames
[i
].longname
);
841 /* ----------------------------------------------------------------------
842 * Helper routines that contain the actual SCP protocol elements,
843 * implemented both as SCP1 and SFTP.
846 static struct scp_sftp_dirstack
{
847 struct scp_sftp_dirstack
*next
;
848 struct fxp_name
*names
;
849 int namepos
, namelen
;
852 int matched_something
; /* wildcard match set was non-empty */
853 } *scp_sftp_dirstack_head
;
854 static char *scp_sftp_remotepath
, *scp_sftp_currentname
;
855 static char *scp_sftp_wildcard
;
856 static int scp_sftp_targetisdir
, scp_sftp_donethistarget
;
857 static int scp_sftp_preserve
, scp_sftp_recursive
;
858 static unsigned long scp_sftp_mtime
, scp_sftp_atime
;
859 static int scp_has_times
;
860 static struct fxp_handle
*scp_sftp_filehandle
;
861 static uint64 scp_sftp_fileoffset
;
863 void scp_source_setup(char *target
, int shouldbedir
)
867 * Find out whether the target filespec is in fact a
870 struct fxp_attrs attrs
;
872 if (!fxp_stat(target
, &attrs
) ||
873 !(attrs
.flags
& SSH_FILEXFER_ATTR_PERMISSIONS
))
874 scp_sftp_targetisdir
= 0;
876 scp_sftp_targetisdir
= (attrs
.permissions
& 0040000) != 0;
878 if (shouldbedir
&& !scp_sftp_targetisdir
) {
879 bump("pscp: remote filespec %s: not a directory\n", target
);
882 scp_sftp_remotepath
= dupstr(target
);
890 int scp_send_errmsg(char *str
)
893 /* do nothing; we never need to send our errors to the server */
895 back
->send("\001", 1); /* scp protocol error prefix */
896 back
->send(str
, strlen(str
));
898 return 0; /* can't fail */
901 int scp_send_filetimes(unsigned long mtime
, unsigned long atime
)
904 scp_sftp_mtime
= mtime
;
905 scp_sftp_atime
= atime
;
910 sprintf(buf
, "T%lu 0 %lu 0\n", mtime
, atime
);
911 back
->send(buf
, strlen(buf
));
916 int scp_send_filename(char *name
, unsigned long size
, int modes
)
920 if (scp_sftp_targetisdir
) {
921 fullname
= dupcat(scp_sftp_remotepath
, "/", name
, NULL
);
923 fullname
= dupstr(scp_sftp_remotepath
);
925 scp_sftp_filehandle
=
926 fxp_open(fullname
, SSH_FXF_WRITE
| SSH_FXF_CREAT
| SSH_FXF_TRUNC
);
927 if (!scp_sftp_filehandle
) {
928 tell_user(stderr
, "pscp: unable to open %s: %s",
929 fullname
, fxp_error());
933 scp_sftp_fileoffset
= uint64_make(0, 0);
938 sprintf(buf
, "C%04o %lu ", modes
, size
);
939 back
->send(buf
, strlen(buf
));
940 back
->send(name
, strlen(name
));
946 int scp_send_filedata(char *data
, int len
)
949 if (!scp_sftp_filehandle
) {
952 if (!fxp_write(scp_sftp_filehandle
, data
, scp_sftp_fileoffset
, len
)) {
953 tell_user(stderr
, "error while writing: %s\n", fxp_error());
957 scp_sftp_fileoffset
= uint64_add32(scp_sftp_fileoffset
, len
);
960 int bufsize
= back
->send(data
, len
);
963 * If the network transfer is backing up - that is, the
964 * remote site is not accepting data as fast as we can
965 * produce it - then we must loop on network events until
966 * we have space in the buffer again.
968 while (bufsize
> MAX_SCP_BUFSIZE
) {
969 if (!scp_process_network_event())
971 bufsize
= back
->sendbuffer();
978 int scp_send_finish(void)
981 struct fxp_attrs attrs
;
982 if (!scp_sftp_filehandle
) {
986 attrs
.flags
= SSH_FILEXFER_ATTR_ACMODTIME
;
987 attrs
.atime
= scp_sftp_atime
;
988 attrs
.mtime
= scp_sftp_mtime
;
989 if (!fxp_fsetstat(scp_sftp_filehandle
, attrs
)) {
990 tell_user(stderr
, "unable to set file times: %s\n", fxp_error());
994 fxp_close(scp_sftp_filehandle
);
1003 char *scp_save_remotepath(void)
1006 return scp_sftp_remotepath
;
1011 void scp_restore_remotepath(char *data
)
1014 scp_sftp_remotepath
= data
;
1017 int scp_send_dirname(char *name
, int modes
)
1022 struct fxp_attrs attrs
;
1023 if (scp_sftp_targetisdir
) {
1024 fullname
= dupcat(scp_sftp_remotepath
, "/", name
, NULL
);
1026 fullname
= dupstr(scp_sftp_remotepath
);
1030 * We don't worry about whether we managed to create the
1031 * directory, because if it exists already it's OK just to
1032 * use it. Instead, we will stat it afterwards, and if it
1033 * exists and is a directory we will assume we were either
1034 * successful or it didn't matter.
1036 if (!fxp_mkdir(fullname
))
1039 err
= "server reported no error";
1040 if (!fxp_stat(fullname
, &attrs
) ||
1041 !(attrs
.flags
& SSH_FILEXFER_ATTR_PERMISSIONS
) ||
1042 !(attrs
.permissions
& 0040000)) {
1043 tell_user(stderr
, "unable to create directory %s: %s",
1049 scp_sftp_remotepath
= fullname
;
1054 sprintf(buf
, "D%04o 0 ", modes
);
1055 back
->send(buf
, strlen(buf
));
1056 back
->send(name
, strlen(name
));
1057 back
->send("\n", 1);
1062 int scp_send_enddir(void)
1065 sfree(scp_sftp_remotepath
);
1068 back
->send("E\n", 2);
1074 * Yes, I know; I have an scp_sink_setup _and_ an scp_sink_init.
1075 * That's bad. The difference is that scp_sink_setup is called once
1076 * right at the start, whereas scp_sink_init is called to
1077 * initialise every level of recursion in the protocol.
1079 int scp_sink_setup(char *source
, int preserve
, int recursive
)
1084 * It's possible that the source string we've been given
1085 * contains a wildcard. If so, we must split the directory
1086 * away from the wildcard itself (throwing an error if any
1087 * wildcardness comes before the final slash) and arrange
1088 * things so that a dirstack entry will be set up.
1090 newsource
= smalloc(1+strlen(source
));
1091 if (!wc_unescape(newsource
, source
)) {
1092 /* Yes, here we go; it's a wildcard. Bah. */
1093 char *dupsource
, *lastpart
, *dirpart
, *wildcard
;
1094 dupsource
= dupstr(source
);
1095 lastpart
= stripslashes(dupsource
, 0);
1096 wildcard
= dupstr(lastpart
);
1098 if (*dupsource
&& dupsource
[1]) {
1100 * The remains of dupsource are at least two
1101 * characters long, meaning the pathname wasn't
1102 * empty or just `/'. Hence, we remove the trailing
1105 lastpart
[-1] = '\0';
1106 } else if (!*dupsource
) {
1108 * The remains of dupsource are _empty_ - the whole
1109 * pathname was a wildcard. Hence we need to
1110 * replace it with ".".
1113 dupsource
= dupstr(".");
1117 * Now we have separated our string into dupsource (the
1118 * directory part) and wildcard. Both of these will
1119 * need freeing at some point. Next step is to remove
1120 * wildcard escapes from the directory part, throwing
1121 * an error if it contains a real wildcard.
1123 dirpart
= smalloc(1+strlen(dupsource
));
1124 if (!wc_unescape(dirpart
, dupsource
)) {
1125 tell_user(stderr
, "%s: multiple-level wildcards unsupported",
1135 * Now we have dirpart (unescaped, ie a valid remote
1136 * path), and wildcard (a wildcard). This will be
1137 * sufficient to arrange a dirstack entry.
1139 scp_sftp_remotepath
= dirpart
;
1140 scp_sftp_wildcard
= wildcard
;
1143 scp_sftp_remotepath
= newsource
;
1144 scp_sftp_wildcard
= NULL
;
1146 scp_sftp_preserve
= preserve
;
1147 scp_sftp_recursive
= recursive
;
1148 scp_sftp_donethistarget
= 0;
1149 scp_sftp_dirstack_head
= NULL
;
1154 int scp_sink_init(void)
1162 #define SCP_SINK_FILE 1
1163 #define SCP_SINK_DIR 2
1164 #define SCP_SINK_ENDDIR 3
1165 #define SCP_SINK_RETRY 4 /* not an action; just try again */
1166 struct scp_sink_action
{
1167 int action
; /* FILE, DIR, ENDDIR */
1168 char *buf
; /* will need freeing after use */
1169 char *name
; /* filename or dirname (not ENDDIR) */
1170 int mode
; /* access mode (not ENDDIR) */
1171 unsigned long size
; /* file size (not ENDDIR) */
1172 int settime
; /* 1 if atime and mtime are filled */
1173 unsigned long atime
, mtime
; /* access times for the file */
1176 int scp_get_sink_action(struct scp_sink_action
*act
)
1180 int must_free_fname
;
1181 struct fxp_attrs attrs
;
1184 if (!scp_sftp_dirstack_head
) {
1185 if (!scp_sftp_donethistarget
) {
1187 * Simple case: we are only dealing with one file.
1189 fname
= scp_sftp_remotepath
;
1190 must_free_fname
= 0;
1191 scp_sftp_donethistarget
= 1;
1194 * Even simpler case: one file _which we've done_.
1195 * Return 1 (finished).
1201 * We're now in the middle of stepping through a list
1202 * of names returned from fxp_readdir(); so let's carry
1205 struct scp_sftp_dirstack
*head
= scp_sftp_dirstack_head
;
1206 while (head
->namepos
< head
->namelen
&&
1207 (is_dots(head
->names
[head
->namepos
].filename
) ||
1209 !wc_match(head
->wildcard
,
1210 head
->names
[head
->namepos
].filename
))))
1211 head
->namepos
++; /* skip . and .. */
1212 if (head
->namepos
< head
->namelen
) {
1213 head
->matched_something
= 1;
1214 fname
= dupcat(head
->dirpath
, "/",
1215 head
->names
[head
->namepos
++].filename
,
1217 must_free_fname
= 1;
1220 * We've come to the end of the list; pop it off
1221 * the stack and return an ENDDIR action (or RETRY
1222 * if this was a wildcard match).
1224 if (head
->wildcard
) {
1225 act
->action
= SCP_SINK_RETRY
;
1226 if (!head
->matched_something
) {
1227 tell_user(stderr
, "pscp: wildcard '%s' matched "
1228 "no files", head
->wildcard
);
1231 sfree(head
->wildcard
);
1234 act
->action
= SCP_SINK_ENDDIR
;
1237 sfree(head
->dirpath
);
1239 scp_sftp_dirstack_head
= head
->next
;
1247 * Now we have a filename. Stat it, and see if it's a file
1250 ret
= fxp_stat(fname
, &attrs
);
1251 if (!ret
|| !(attrs
.flags
& SSH_FILEXFER_ATTR_PERMISSIONS
)) {
1252 tell_user(stderr
, "unable to identify %s: %s", fname
,
1253 ret ?
"file type not supplied" : fxp_error());
1258 if (attrs
.permissions
& 0040000) {
1259 struct scp_sftp_dirstack
*newitem
;
1260 struct fxp_handle
*dirhandle
;
1261 int nnames
, namesize
;
1262 struct fxp_name
*ournames
;
1263 struct fxp_names
*names
;
1266 * It's a directory. If we're not in recursive mode,
1267 * this merits a complaint (which is fatal if the name
1268 * was specified directly, but not if it was matched by
1271 * We skip this complaint completely if
1272 * scp_sftp_wildcard is set, because that's an
1273 * indication that we're not actually supposed to
1274 * _recursively_ transfer the dir, just scan it for
1275 * things matching the wildcard.
1277 if (!scp_sftp_recursive
&& !scp_sftp_wildcard
) {
1278 tell_user(stderr
, "pscp: %s: is a directory", fname
);
1280 if (must_free_fname
) sfree(fname
);
1281 if (scp_sftp_dirstack_head
) {
1282 act
->action
= SCP_SINK_RETRY
;
1290 * Otherwise, the fun begins. We must fxp_opendir() the
1291 * directory, slurp the filenames into memory, return
1292 * SCP_SINK_DIR (unless this is a wildcard match), and
1293 * set targetisdir. The next time we're called, we will
1294 * run through the list of filenames one by one,
1295 * matching them against a wildcard if present.
1297 * If targetisdir is _already_ set (meaning we're
1298 * already in the middle of going through another such
1299 * list), we must push the other (target,namelist) pair
1302 dirhandle
= fxp_opendir(fname
);
1304 tell_user(stderr
, "scp: unable to open directory %s: %s",
1305 fname
, fxp_error());
1306 if (must_free_fname
) sfree(fname
);
1310 nnames
= namesize
= 0;
1315 names
= fxp_readdir(dirhandle
);
1316 if (names
== NULL
) {
1317 if (fxp_error_type() == SSH_FX_EOF
)
1319 tell_user(stderr
, "scp: reading directory %s: %s\n",
1320 fname
, fxp_error());
1321 if (must_free_fname
) sfree(fname
);
1326 if (names
->nnames
== 0) {
1327 fxp_free_names(names
);
1330 if (nnames
+ names
->nnames
>= namesize
) {
1331 namesize
+= names
->nnames
+ 128;
1333 srealloc(ournames
, namesize
* sizeof(*ournames
));
1335 for (i
= 0; i
< names
->nnames
; i
++)
1336 ournames
[nnames
++] = names
->names
[i
];
1337 names
->nnames
= 0; /* prevent free_names */
1338 fxp_free_names(names
);
1340 fxp_close(dirhandle
);
1342 newitem
= smalloc(sizeof(struct scp_sftp_dirstack
));
1343 newitem
->next
= scp_sftp_dirstack_head
;
1344 newitem
->names
= ournames
;
1345 newitem
->namepos
= 0;
1346 newitem
->namelen
= nnames
;
1347 if (must_free_fname
)
1348 newitem
->dirpath
= fname
;
1350 newitem
->dirpath
= dupstr(fname
);
1351 if (scp_sftp_wildcard
) {
1352 newitem
->wildcard
= scp_sftp_wildcard
;
1353 newitem
->matched_something
= 0;
1354 scp_sftp_wildcard
= NULL
;
1356 newitem
->wildcard
= NULL
;
1358 scp_sftp_dirstack_head
= newitem
;
1360 if (newitem
->wildcard
) {
1361 act
->action
= SCP_SINK_RETRY
;
1363 act
->action
= SCP_SINK_DIR
;
1364 act
->buf
= dupstr(stripslashes(fname
, 0));
1365 act
->name
= act
->buf
;
1366 act
->size
= 0; /* duhh, it's a directory */
1367 act
->mode
= 07777 & attrs
.permissions
;
1368 if (scp_sftp_preserve
&&
1369 (attrs
.flags
& SSH_FILEXFER_ATTR_ACMODTIME
)) {
1370 act
->atime
= attrs
.atime
;
1371 act
->mtime
= attrs
.mtime
;
1380 * It's a file. Return SCP_SINK_FILE.
1382 act
->action
= SCP_SINK_FILE
;
1383 act
->buf
= dupstr(stripslashes(fname
, 0));
1384 act
->name
= act
->buf
;
1385 if (attrs
.flags
& SSH_FILEXFER_ATTR_SIZE
) {
1386 if (uint64_compare(attrs
.size
,
1387 uint64_make(0, ULONG_MAX
)) > 0) {
1388 act
->size
= ULONG_MAX
; /* *boggle* */
1390 act
->size
= attrs
.size
.lo
;
1392 act
->size
= ULONG_MAX
; /* no idea */
1393 act
->mode
= 07777 & attrs
.permissions
;
1394 if (scp_sftp_preserve
&&
1395 (attrs
.flags
& SSH_FILEXFER_ATTR_ACMODTIME
)) {
1396 act
->atime
= attrs
.atime
;
1397 act
->mtime
= attrs
.mtime
;
1401 if (must_free_fname
)
1402 scp_sftp_currentname
= fname
;
1404 scp_sftp_currentname
= dupstr(fname
);
1419 if (ssh_scp_recv(&ch
, 1) <= 0)
1422 bump("Protocol error: Unexpected newline");
1426 if (ssh_scp_recv(&ch
, 1) <= 0)
1427 bump("Lost connection");
1430 act
->buf
= srealloc(act
->buf
, bufsize
);
1433 } while (ch
!= '\n');
1434 act
->buf
[i
- 1] = '\0';
1436 case '\01': /* error */
1437 tell_user(stderr
, "%s\n", act
->buf
);
1439 continue; /* go round again */
1440 case '\02': /* fatal error */
1441 bump("%s", act
->buf
);
1444 act
->action
= SCP_SINK_ENDDIR
;
1447 if (sscanf(act
->buf
, "%ld %*d %ld %*d",
1448 &act
->mtime
, &act
->atime
) == 2) {
1451 continue; /* go round again */
1453 bump("Protocol error: Illegal time format");
1456 act
->action
= (action
== 'C' ? SCP_SINK_FILE
: SCP_SINK_DIR
);
1459 bump("Protocol error: Expected control record");
1462 * We will go round this loop only once, unless we hit
1469 * If we get here, we must have seen SCP_SINK_FILE or
1472 if (sscanf(act
->buf
, "%o %lu %n", &act
->mode
, &act
->size
, &i
) != 2)
1473 bump("Protocol error: Illegal file descriptor format");
1474 act
->name
= act
->buf
+ i
;
1479 int scp_accept_filexfer(void)
1482 scp_sftp_filehandle
=
1483 fxp_open(scp_sftp_currentname
, SSH_FXF_READ
);
1484 if (!scp_sftp_filehandle
) {
1485 tell_user(stderr
, "pscp: unable to open %s: %s",
1486 scp_sftp_currentname
, fxp_error());
1490 scp_sftp_fileoffset
= uint64_make(0, 0);
1491 sfree(scp_sftp_currentname
);
1495 return 0; /* can't fail */
1499 int scp_recv_filedata(char *data
, int len
)
1502 int actuallen
= fxp_read(scp_sftp_filehandle
, data
,
1503 scp_sftp_fileoffset
, len
);
1504 if (actuallen
== -1 && fxp_error_type() != SSH_FX_EOF
) {
1505 tell_user(stderr
, "pscp: error while reading: %s", fxp_error());
1512 scp_sftp_fileoffset
= uint64_add32(scp_sftp_fileoffset
, actuallen
);
1516 return ssh_scp_recv(data
, len
);
1520 int scp_finish_filerecv(void)
1523 fxp_close(scp_sftp_filehandle
);
1531 /* ----------------------------------------------------------------------
1532 * Send an error message to the other side and to the screen.
1533 * Increment error counter.
1535 static void run_err(const char *fmt
, ...)
1541 strcpy(str
, "scp: ");
1542 vsprintf(str
+ strlen(str
), fmt
, ap
);
1544 scp_send_errmsg(str
);
1545 tell_user(stderr
, "%s", str
);
1550 * Execute the source part of the SCP protocol.
1552 static void source(char *src
)
1559 unsigned long stat_bytes
;
1560 time_t stat_starttime
, stat_lasttime
;
1562 attr
= GetFileAttributes(src
);
1563 if (attr
== (DWORD
) - 1) {
1564 run_err("%s: No such file or directory", src
);
1568 if ((attr
& FILE_ATTRIBUTE_DIRECTORY
) != 0) {
1571 * Avoid . and .. directories.
1574 p
= strrchr(src
, '/');
1576 p
= strrchr(src
, '\\');
1581 if (!strcmp(p
, ".") || !strcmp(p
, ".."))
1582 /* skip . and .. */ ;
1586 run_err("%s: not a regular file", src
);
1591 if ((last
= strrchr(src
, '/')) == NULL
)
1595 if (strrchr(last
, '\\') != NULL
)
1596 last
= strrchr(last
, '\\') + 1;
1597 if (last
== src
&& strchr(src
, ':') != NULL
)
1598 last
= strchr(src
, ':') + 1;
1600 f
= CreateFile(src
, GENERIC_READ
, FILE_SHARE_READ
, NULL
,
1601 OPEN_EXISTING
, 0, 0);
1602 if (f
== INVALID_HANDLE_VALUE
) {
1603 run_err("%s: Cannot open file", src
);
1608 FILETIME actime
, wrtime
;
1609 unsigned long mtime
, atime
;
1610 GetFileTime(f
, NULL
, &actime
, &wrtime
);
1611 TIME_WIN_TO_POSIX(actime
, atime
);
1612 TIME_WIN_TO_POSIX(wrtime
, mtime
);
1613 if (scp_send_filetimes(mtime
, atime
))
1617 size
= GetFileSize(f
, NULL
);
1619 tell_user(stderr
, "Sending file %s, size=%lu", last
, size
);
1620 if (scp_send_filename(last
, size
, 0644))
1624 stat_starttime
= time(NULL
);
1627 for (i
= 0; i
< size
; i
+= 4096) {
1628 char transbuf
[4096];
1633 if (!ReadFile(f
, transbuf
, k
, &j
, NULL
) || j
!= k
) {
1636 bump("%s: Read error", src
);
1638 if (scp_send_filedata(transbuf
, k
))
1639 bump("%s: Network error occurred", src
);
1643 if (time(NULL
) != stat_lasttime
|| i
+ k
== size
) {
1644 stat_lasttime
= time(NULL
);
1645 print_stats(last
, size
, stat_bytes
,
1646 stat_starttime
, stat_lasttime
);
1653 (void) scp_send_finish();
1657 * Recursively send the contents of a directory.
1659 static void rsource(char *src
)
1661 char *last
, *findfile
;
1664 WIN32_FIND_DATA fdat
;
1667 if ((last
= strrchr(src
, '/')) == NULL
)
1671 if (strrchr(last
, '\\') != NULL
)
1672 last
= strrchr(last
, '\\') + 1;
1673 if (last
== src
&& strchr(src
, ':') != NULL
)
1674 last
= strchr(src
, ':') + 1;
1676 /* maybe send filetime */
1678 save_target
= scp_save_remotepath();
1681 tell_user(stderr
, "Entering directory: %s", last
);
1682 if (scp_send_dirname(last
, 0755))
1685 findfile
= dupcat(src
, "/*", NULL
);
1686 dir
= FindFirstFile(findfile
, &fdat
);
1687 ok
= (dir
!= INVALID_HANDLE_VALUE
);
1689 if (strcmp(fdat
.cFileName
, ".") == 0 ||
1690 strcmp(fdat
.cFileName
, "..") == 0) {
1691 /* ignore . and .. */
1693 char *foundfile
= dupcat(src
, "/", fdat
.cFileName
, NULL
);
1697 ok
= FindNextFile(dir
, &fdat
);
1702 (void) scp_send_enddir();
1704 scp_restore_remotepath(save_target
);
1708 * Execute the sink part of the SCP protocol.
1710 static void sink(char *targ
, char *src
)
1717 unsigned long received
;
1719 unsigned long stat_bytes
;
1720 time_t stat_starttime
, stat_lasttime
;
1723 attr
= GetFileAttributes(targ
);
1724 if (attr
!= (DWORD
) - 1 && (attr
& FILE_ATTRIBUTE_DIRECTORY
) != 0)
1727 if (targetshouldbedirectory
&& !targisdir
)
1728 bump("%s: Not a directory", targ
);
1732 struct scp_sink_action act
;
1733 if (scp_get_sink_action(&act
))
1736 if (act
.action
== SCP_SINK_ENDDIR
)
1739 if (act
.action
== SCP_SINK_RETRY
)
1744 * Prevent the remote side from maliciously writing to
1745 * files outside the target area by sending a filename
1746 * containing `../'. In fact, it shouldn't be sending
1747 * filenames with any slashes or colons in at all; so
1748 * we'll find the last slash, backslash or colon in the
1749 * filename and use only the part after that. (And
1752 * In addition, we also ensure here that if we're
1753 * copying a single file and the target is a directory
1754 * (common usage: `pscp host:filename .') the remote
1755 * can't send us a _different_ file name. We can
1756 * distinguish this case because `src' will be non-NULL
1757 * and the last component of that will fail to match
1758 * (the last component of) the name sent.
1760 * Well, not always; if `src' is a wildcard, we do
1761 * expect to get back filenames that don't correspond
1762 * exactly to it. Ideally in this case, we would like
1763 * to ensure that the returned filename actually
1764 * matches the wildcard pattern - but one of SCP's
1765 * protocol infelicities is that wildcard matching is
1766 * done at the server end _by the server's rules_ and
1767 * so in general this is infeasible. Hence, we only
1768 * accept filenames that don't correspond to `src' if
1769 * unsafe mode is enabled or we are using SFTP (which
1770 * resolves remote wildcards on the client side and can
1773 char *striptarget
, *stripsrc
;
1775 striptarget
= stripslashes(act
.name
, 1);
1776 if (striptarget
!= act
.name
) {
1777 tell_user(stderr
, "warning: remote host sent a compound"
1778 " pathname '%s'", act
.name
);
1779 tell_user(stderr
, " renaming local file to '%s'",
1784 * Also check to see if the target filename is '.' or
1785 * '..', or indeed '...' and so on because Windows
1786 * appears to interpret those like '..'.
1788 if (is_dots(striptarget
)) {
1789 bump("security violation: remote host attempted to write to"
1790 " a '.' or '..' path!");
1794 stripsrc
= stripslashes(src
, 1);
1795 if (strcmp(striptarget
, stripsrc
) &&
1796 !using_sftp
&& !scp_unsafe_mode
) {
1797 tell_user(stderr
, "warning: remote host tried to write "
1798 "to a file called '%s'", striptarget
);
1799 tell_user(stderr
, " when we requested a file "
1800 "called '%s'.", stripsrc
);
1801 tell_user(stderr
, " If this is a wildcard, "
1802 "consider upgrading to SSH 2 or using");
1803 tell_user(stderr
, " the '-unsafe' option. Renaming"
1804 " of this file has been disallowed.");
1805 /* Override the name the server provided with our own. */
1806 striptarget
= stripsrc
;
1810 if (targ
[0] != '\0')
1811 destfname
= dupcat(targ
, "\\", striptarget
, NULL
);
1813 destfname
= dupstr(striptarget
);
1816 * In this branch of the if, the target area is a
1817 * single file with an explicitly specified name in any
1818 * case, so there's no danger.
1820 destfname
= dupstr(targ
);
1822 attr
= GetFileAttributes(destfname
);
1823 exists
= (attr
!= (DWORD
) - 1);
1825 if (act
.action
== SCP_SINK_DIR
) {
1826 if (exists
&& (attr
& FILE_ATTRIBUTE_DIRECTORY
) == 0) {
1827 run_err("%s: Not a directory", destfname
);
1831 if (!CreateDirectory(destfname
, NULL
)) {
1832 run_err("%s: Cannot create directory", destfname
);
1836 sink(destfname
, NULL
);
1837 /* can we set the timestamp for directories ? */
1841 f
= CreateFile(destfname
, GENERIC_WRITE
, 0, NULL
,
1842 CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, 0);
1843 if (f
== INVALID_HANDLE_VALUE
) {
1844 run_err("%s: Cannot create file", destfname
);
1848 if (scp_accept_filexfer())
1852 stat_starttime
= time(NULL
);
1854 stat_name
= stripslashes(destfname
, 1);
1857 while (received
< act
.size
) {
1858 char transbuf
[4096];
1859 DWORD blksize
, read
, written
;
1861 if (blksize
> act
.size
- received
)
1862 blksize
= act
.size
- received
;
1863 read
= scp_recv_filedata(transbuf
, blksize
);
1865 bump("Lost connection");
1868 if (!WriteFile(f
, transbuf
, read
, &written
, NULL
) ||
1871 /* FIXME: in sftp we can actually abort the transfer */
1873 printf("\r%-25.25s | %50s\n",
1875 "Write error.. waiting for end of file");
1880 if (time(NULL
) > stat_lasttime
||
1881 received
+ read
== act
.size
) {
1882 stat_lasttime
= time(NULL
);
1883 print_stats(stat_name
, act
.size
, stat_bytes
,
1884 stat_starttime
, stat_lasttime
);
1890 FILETIME actime
, wrtime
;
1891 TIME_POSIX_TO_WIN(act
.atime
, actime
);
1892 TIME_POSIX_TO_WIN(act
.mtime
, wrtime
);
1893 SetFileTime(f
, NULL
, &actime
, &wrtime
);
1898 run_err("%s: Write error", destfname
);
1901 (void) scp_finish_filerecv();
1908 * We will copy local files to a remote server.
1910 static void toremote(int argc
, char *argv
[])
1912 char *src
, *targ
, *host
, *user
;
1916 targ
= argv
[argc
- 1];
1918 /* Separate host from filename */
1922 bump("targ == NULL in toremote()");
1926 /* Substitute "." for emtpy target */
1928 /* Separate host and username */
1930 host
= strrchr(host
, '@');
1941 /* Find out if the source filespec covers multiple files
1942 if so, we should set the targetshouldbedirectory flag */
1944 WIN32_FIND_DATA fdat
;
1945 if (colon(argv
[0]) != NULL
)
1946 bump("%s: Remote to remote not supported", argv
[0]);
1947 fh
= FindFirstFile(argv
[0], &fdat
);
1948 if (fh
== INVALID_HANDLE_VALUE
)
1949 bump("%s: No such file or directory\n", argv
[0]);
1950 if (FindNextFile(fh
, &fdat
))
1951 targetshouldbedirectory
= 1;
1955 cmd
= smalloc(strlen(targ
) + 100);
1956 sprintf(cmd
, "scp%s%s%s%s -t %s",
1957 verbose ?
" -v" : "",
1958 recursive ?
" -r" : "",
1959 preserve ?
" -p" : "",
1960 targetshouldbedirectory ?
" -d" : "", targ
);
1961 do_cmd(host
, user
, cmd
);
1964 scp_source_setup(targ
, targetshouldbedirectory
);
1966 for (i
= 0; i
< argc
- 1; i
++) {
1967 char *srcpath
, *last
;
1969 WIN32_FIND_DATA fdat
;
1971 if (colon(src
) != NULL
) {
1972 tell_user(stderr
, "%s: Remote to remote not supported\n", src
);
1978 * Trim off the last pathname component of `src', to
1979 * provide the base pathname which will be prepended to
1980 * filenames returned from Find{First,Next}File.
1982 srcpath
= dupstr(src
);
1983 last
= stripslashes(srcpath
, 1);
1986 dir
= FindFirstFile(src
, &fdat
);
1987 if (dir
== INVALID_HANDLE_VALUE
) {
1988 run_err("%s: No such file or directory", src
);
1994 * Ensure that . and .. are never matched by wildcards,
1995 * but only by deliberate action.
1997 if (!strcmp(fdat
.cFileName
, ".") ||
1998 !strcmp(fdat
.cFileName
, "..")) {
2000 * Find*File has returned a special dir. We require
2001 * that _either_ `src' ends in a backslash followed
2002 * by that string, _or_ `src' is precisely that
2005 int len
= strlen(src
), dlen
= strlen(fdat
.cFileName
);
2006 if (len
== dlen
&& !strcmp(src
, fdat
.cFileName
)) {
2008 } else if (len
> dlen
+ 1 && src
[len
- dlen
- 1] == '\\' &&
2009 !strcmp(src
+ len
- dlen
, fdat
.cFileName
)) {
2012 continue; /* ignore this one */
2014 filename
= dupcat(srcpath
, fdat
.cFileName
, NULL
);
2017 } while (FindNextFile(dir
, &fdat
));
2024 * We will copy files from a remote server to the local machine.
2026 static void tolocal(int argc
, char *argv
[])
2028 char *src
, *targ
, *host
, *user
;
2032 bump("More than one remote source not supported");
2037 /* Separate host from filename */
2041 bump("Local to local copy not supported");
2045 /* Substitute "." for empty filename */
2047 /* Separate username and hostname */
2049 host
= strrchr(host
, '@');
2059 cmd
= smalloc(strlen(src
) + 100);
2060 sprintf(cmd
, "scp%s%s%s%s -f %s",
2061 verbose ?
" -v" : "",
2062 recursive ?
" -r" : "",
2063 preserve ?
" -p" : "",
2064 targetshouldbedirectory ?
" -d" : "", src
);
2065 do_cmd(host
, user
, cmd
);
2068 if (scp_sink_setup(src
, preserve
, recursive
))
2075 * We will issue a list command to get a remote directory.
2077 static void get_dir_list(int argc
, char *argv
[])
2079 char *src
, *host
, *user
;
2085 /* Separate host from filename */
2089 bump("Local to local copy not supported");
2093 /* Substitute "." for empty filename */
2095 /* Separate username and hostname */
2097 host
= strrchr(host
, '@');
2107 cmd
= smalloc(4 * strlen(src
) + 100);
2108 strcpy(cmd
, "ls -la '");
2109 p
= cmd
+ strlen(cmd
);
2110 for (q
= src
; *q
; q
++) {
2123 do_cmd(host
, user
, cmd
);
2127 scp_sftp_listdir(src
);
2129 while (ssh_scp_recv(&c
, 1) > 0)
2130 tell_char(stdout
, c
);
2135 * Initialize the Win$ock driver.
2137 static void init_winsock(void)
2142 winsock_ver
= MAKEWORD(1, 1);
2143 if (WSAStartup(winsock_ver
, &wsadata
))
2144 bump("Unable to initialise WinSock");
2145 if (LOBYTE(wsadata
.wVersion
) != 1 || HIBYTE(wsadata
.wVersion
) != 1)
2146 bump("WinSock version is incompatible with 1.1");
2150 * Short description of parameters.
2152 static void usage(void)
2154 printf("PuTTY Secure Copy client\n");
2155 printf("%s\n", ver
);
2156 printf("Usage: pscp [options] [user@]host:source target\n");
2158 (" pscp [options] source [source...] [user@]host:target\n");
2159 printf(" pscp [options] -ls user@host:filespec\n");
2160 printf("Options:\n");
2161 printf(" -p preserve file attributes\n");
2162 printf(" -q quiet, don't show statistics\n");
2163 printf(" -r copy directories recursively\n");
2164 printf(" -v show verbose messages\n");
2165 printf(" -P port connect to specified port\n");
2166 printf(" -pw passw login with specified password\n");
2167 printf(" -unsafe allow server-side wildcards (DANGEROUS)\n");
2170 * -gui is an internal option, used by GUI front ends to get
2171 * pscp to pass progress reports back to them. It's not an
2172 * ordinary user-accessible option, so it shouldn't be part of
2173 * the command-line help. The only people who need to know
2174 * about it are programmers, and they can read the source.
2177 (" -gui hWnd GUI mode with the windows handle for receiving messages\n");
2183 * Main program (no, really?)
2185 int main(int argc
, char *argv
[])
2189 default_protocol
= PROT_TELNET
;
2191 flags
= FLAG_STDERR
;
2192 ssh_get_line
= &get_line
;
2196 for (i
= 1; i
< argc
; i
++) {
2197 if (argv
[i
][0] != '-')
2199 if (strcmp(argv
[i
], "-v") == 0)
2200 verbose
= 1, flags
|= FLAG_VERBOSE
;
2201 else if (strcmp(argv
[i
], "-r") == 0)
2203 else if (strcmp(argv
[i
], "-p") == 0)
2205 else if (strcmp(argv
[i
], "-q") == 0)
2207 else if (strcmp(argv
[i
], "-h") == 0 || strcmp(argv
[i
], "-?") == 0)
2209 else if (strcmp(argv
[i
], "-P") == 0 && i
+ 1 < argc
)
2210 portnumber
= atoi(argv
[++i
]);
2211 else if (strcmp(argv
[i
], "-pw") == 0 && i
+ 1 < argc
)
2212 password
= argv
[++i
];
2213 else if (strcmp(argv
[i
], "-gui") == 0 && i
+ 1 < argc
) {
2214 gui_hwnd
= argv
[++i
];
2216 } else if (strcmp(argv
[i
], "-ls") == 0)
2218 else if (strcmp(argv
[i
], "-unsafe") == 0)
2219 scp_unsafe_mode
= 1;
2220 else if (strcmp(argv
[i
], "--") == 0) {
2233 get_dir_list(argc
, argv
);
2240 targetshouldbedirectory
= 1;
2242 if (colon(argv
[argc
- 1]) != NULL
)
2243 toremote(argc
, argv
);
2245 tolocal(argc
, argv
);
2248 if (back
!= NULL
&& back
->socket() != NULL
) {
2250 back
->special(TS_EOF
);
2251 ssh_scp_recv(&ch
, 1);
2256 /* GUI Adaptation - August 2000 */
2258 unsigned int msg_id
= WM_RET_ERR_CNT
;
2260 msg_id
= WM_LS_RET_ERR_CNT
;
2262 ((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) errs
,
2263 0 /*lParam */ ))SleepEx(1000, TRUE
);
2265 return (errs
== 0 ?
0 : 1);