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 )
52 #define WM_STATS_DONE ( WM_APP_BASE+408 )
53 #define WM_STATS_ETA ( WM_APP_BASE+409 )
54 #define WM_STATS_RATEBS ( WM_APP_BASE+410 )
57 static int verbose
= 0;
58 static int recursive
= 0;
59 static int preserve
= 0;
60 static int targetshouldbedirectory
= 0;
61 static int statistics
= 1;
62 static int portnumber
= 0;
63 static int prev_stats_len
= 0;
64 static int scp_unsafe_mode
= 0;
65 static char *password
= NULL
;
67 /* GUI Adaptation - Sept 2000 */
68 #define NAME_STR_MAX 2048
69 static char statname
[NAME_STR_MAX
+ 1];
70 static unsigned long statsize
= 0;
71 static unsigned long statdone
= 0;
72 static unsigned long stateta
= 0;
73 static unsigned long statratebs
= 0;
74 static int statperct
= 0;
75 static unsigned long statelapsed
= 0;
76 static int gui_mode
= 0;
77 static char *gui_hwnd
= NULL
;
78 static int using_sftp
= 0;
80 static void source(char *src
);
81 static void rsource(char *src
);
82 static void sink(char *targ
, char *src
);
83 /* GUI Adaptation - Sept 2000 */
84 static void tell_char(FILE * stream
, char c
);
85 static void tell_str(FILE * stream
, char *str
);
86 static void tell_user(FILE * stream
, char *fmt
, ...);
87 static void gui_update_stats(char *name
, unsigned long size
,
88 int percentage
, unsigned long elapsed
,
89 unsigned long done
, unsigned long eta
,
90 unsigned long ratebs
);
93 * The maximum amount of queued data we accept before we stop and
94 * wait for the server to process some.
96 #define MAX_SCP_BUFSIZE 16384
98 void logevent(char *string
)
102 void ldisc_send(char *buf
, int len
, int interactive
)
105 * This is only here because of the calls to ldisc_send(NULL,
106 * 0) in ssh.c. Nothing in PSCP actually needs to use the ldisc
107 * as an ldisc. So if we get called with any real data, I want
113 void verify_ssh_host_key(char *host
, int port
, char *keytype
,
114 char *keystr
, char *fingerprint
)
120 static const char absentmsg
[] =
121 "The server's host key is not cached in the registry. You\n"
122 "have no guarantee that the server is the computer you\n"
124 "The server's key fingerprint is:\n"
126 "If you trust this host, enter \"y\" to add the key to\n"
127 "PuTTY's cache and carry on connecting.\n"
128 "If you want to carry on connecting just once, without\n"
129 "adding the key to the cache, enter \"n\".\n"
130 "If you do not trust this host, press Return to abandon the\n"
132 "Store key in cache? (y/n) ";
134 static const char wrongmsg
[] =
135 "WARNING - POTENTIAL SECURITY BREACH!\n"
136 "The server's host key does not match the one PuTTY has\n"
137 "cached in the registry. This means that either the\n"
138 "server administrator has changed the host key, or you\n"
139 "have actually connected to another computer pretending\n"
140 "to be the server.\n"
141 "The new key fingerprint is:\n"
143 "If you were expecting this change and trust the new key,\n"
144 "enter \"y\" to update PuTTY's cache and continue connecting.\n"
145 "If you want to carry on connecting but without updating\n"
146 "the cache, enter \"n\".\n"
147 "If you want to abandon the connection completely, press\n"
148 "Return to cancel. Pressing Return is the ONLY guaranteed\n"
150 "Update cached key? (y/n, Return cancels connection) ";
152 static const char abandoned
[] = "Connection abandoned.\n";
157 * Verify the key against the registry.
159 ret
= verify_host_key(host
, port
, keytype
, keystr
);
161 if (ret
== 0) /* success - key matched OK */
164 if (ret
== 2) { /* key was different */
165 fprintf(stderr
, wrongmsg
, fingerprint
);
168 if (ret
== 1) { /* key was absent */
169 fprintf(stderr
, absentmsg
, fingerprint
);
173 hin
= GetStdHandle(STD_INPUT_HANDLE
);
174 GetConsoleMode(hin
, &savemode
);
175 SetConsoleMode(hin
, (savemode
| ENABLE_ECHO_INPUT
|
176 ENABLE_PROCESSED_INPUT
| ENABLE_LINE_INPUT
));
177 ReadFile(hin
, line
, sizeof(line
) - 1, &i
, NULL
);
178 SetConsoleMode(hin
, savemode
);
180 if (line
[0] != '\0' && line
[0] != '\r' && line
[0] != '\n') {
181 if (line
[0] == 'y' || line
[0] == 'Y')
182 store_host_key(host
, port
, keytype
, keystr
);
184 fprintf(stderr
, abandoned
);
190 * Ask whether the selected cipher is acceptable (since it was
191 * below the configured 'warn' threshold).
192 * cs: 0 = both ways, 1 = client->server, 2 = server->client
194 void askcipher(char *ciphername
, int cs
)
199 static const char msg
[] =
200 "The first %scipher supported by the server is\n"
201 "%s, which is below the configured warning threshold.\n"
202 "Continue with connection? (y/n) ";
203 static const char abandoned
[] = "Connection abandoned.\n";
209 (cs
== 1) ?
"client-to-server " :
214 hin
= GetStdHandle(STD_INPUT_HANDLE
);
215 GetConsoleMode(hin
, &savemode
);
216 SetConsoleMode(hin
, (savemode
| ENABLE_ECHO_INPUT
|
217 ENABLE_PROCESSED_INPUT
| ENABLE_LINE_INPUT
));
218 ReadFile(hin
, line
, sizeof(line
) - 1, &i
, NULL
);
219 SetConsoleMode(hin
, savemode
);
221 if (line
[0] == 'y' || line
[0] == 'Y') {
224 fprintf(stderr
, abandoned
);
229 /* GUI Adaptation - Sept 2000 */
230 static void send_msg(HWND h
, UINT message
, WPARAM wParam
)
232 while (!PostMessage(h
, message
, wParam
, 0))
236 static void tell_char(FILE * stream
, char c
)
241 unsigned int msg_id
= WM_STD_OUT_CHAR
;
242 if (stream
== stderr
)
243 msg_id
= WM_STD_ERR_CHAR
;
244 send_msg((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) c
);
248 static void tell_str(FILE * stream
, char *str
)
252 for (i
= 0; i
< strlen(str
); ++i
)
253 tell_char(stream
, str
[i
]);
256 static void tell_user(FILE * stream
, char *fmt
, ...)
258 char str
[0x100]; /* Make the size big enough */
261 vsprintf(str
, fmt
, ap
);
264 tell_str(stream
, str
);
267 static void gui_update_stats(char *name
, unsigned long size
,
268 int percentage
, unsigned long elapsed
,
269 unsigned long done
, unsigned long eta
,
270 unsigned long ratebs
)
274 if (strcmp(name
, statname
) != 0) {
275 for (i
= 0; i
< strlen(name
); ++i
)
276 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_CHAR
,
278 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_CHAR
, (WPARAM
) '\n');
279 strcpy(statname
, name
);
281 if (statsize
!= size
) {
282 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_SIZE
, (WPARAM
) size
);
285 if (statdone
!= done
) {
286 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_DONE
, (WPARAM
) done
);
289 if (stateta
!= eta
) {
290 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_ETA
, (WPARAM
) eta
);
293 if (statratebs
!= ratebs
) {
294 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_RATEBS
, (WPARAM
) ratebs
);
297 if (statelapsed
!= elapsed
) {
298 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_ELAPSED
,
300 statelapsed
= elapsed
;
302 if (statperct
!= percentage
) {
303 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_PERCENT
,
304 (WPARAM
) percentage
);
305 statperct
= percentage
;
310 * Print an error message and perform a fatal exit.
312 void fatalbox(char *fmt
, ...)
314 char str
[0x100]; /* Make the size big enough */
317 strcpy(str
, "Fatal: ");
318 vsprintf(str
+ strlen(str
), fmt
, ap
);
321 tell_str(stderr
, str
);
325 unsigned int msg_id
= WM_RET_ERR_CNT
;
327 msg_id
= WM_LS_RET_ERR_CNT
;
329 ((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) errs
,
330 0 /*lParam */ ))SleepEx(1000, TRUE
);
335 void connection_fatal(char *fmt
, ...)
337 char str
[0x100]; /* Make the size big enough */
340 strcpy(str
, "Fatal: ");
341 vsprintf(str
+ strlen(str
), fmt
, ap
);
344 tell_str(stderr
, str
);
348 unsigned int msg_id
= WM_RET_ERR_CNT
;
350 msg_id
= WM_LS_RET_ERR_CNT
;
352 ((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) errs
,
353 0 /*lParam */ ))SleepEx(1000, TRUE
);
360 * Be told what socket we're supposed to be using.
362 static SOCKET scp_ssh_socket
;
363 char *do_select(SOCKET skt
, int startup
)
366 scp_ssh_socket
= skt
;
368 scp_ssh_socket
= INVALID_SOCKET
;
371 extern int select_result(WPARAM
, LPARAM
);
374 * Receive a block of data from the SSH link. Block until all data
377 * To do this, we repeatedly call the SSH protocol module, with our
378 * own trap in from_backend() to catch the data that comes back. We
379 * do this until we have enough data.
382 static unsigned char *outptr
; /* where to put the data */
383 static unsigned outlen
; /* how much data required */
384 static unsigned char *pending
= NULL
; /* any spare data */
385 static unsigned pendlen
= 0, pendsize
= 0; /* length and phys. size of buffer */
386 int from_backend(int is_stderr
, char *data
, int datalen
)
388 unsigned char *p
= (unsigned char *) data
;
389 unsigned len
= (unsigned) datalen
;
392 * stderr data is just spouted to local stderr and otherwise
396 fwrite(data
, 1, len
, stderr
);
401 * If this is before the real session begins, just return.
407 unsigned used
= outlen
;
410 memcpy(outptr
, p
, used
);
418 if (pendsize
< pendlen
+ len
) {
419 pendsize
= pendlen
+ len
+ 4096;
420 pending
= (pending ?
srealloc(pending
, pendsize
) :
423 fatalbox("Out of memory");
425 memcpy(pending
+ pendlen
, p
, len
);
431 static int scp_process_network_event(void)
436 FD_SET(scp_ssh_socket
, &readfds
);
437 if (select(1, &readfds
, NULL
, NULL
, NULL
) < 0)
439 select_result((WPARAM
) scp_ssh_socket
, (LPARAM
) FD_READ
);
442 static int ssh_scp_recv(unsigned char *buf
, int len
)
448 * See if the pending-input block contains some of what we
452 unsigned pendused
= pendlen
;
453 if (pendused
> outlen
)
455 memcpy(outptr
, pending
, pendused
);
456 memmove(pending
, pending
+ pendused
, pendlen
- pendused
);
470 if (!scp_process_network_event())
478 * Loop through the ssh connection and authentication process.
480 static void ssh_scp_init(void)
482 if (scp_ssh_socket
== INVALID_SOCKET
)
484 while (!back
->sendok()) {
487 FD_SET(scp_ssh_socket
, &readfds
);
488 if (select(1, &readfds
, NULL
, NULL
, NULL
) < 0)
490 select_result((WPARAM
) scp_ssh_socket
, (LPARAM
) FD_READ
);
492 using_sftp
= !ssh_fallback_cmd
;
496 * Print an error message and exit after closing the SSH link.
498 static void bump(char *fmt
, ...)
500 char str
[0x100]; /* Make the size big enough */
503 strcpy(str
, "Fatal: ");
504 vsprintf(str
+ strlen(str
), fmt
, ap
);
507 tell_str(stderr
, str
);
510 if (back
!= NULL
&& back
->socket() != NULL
) {
512 back
->special(TS_EOF
);
513 ssh_scp_recv(&ch
, 1);
517 unsigned int msg_id
= WM_RET_ERR_CNT
;
519 msg_id
= WM_LS_RET_ERR_CNT
;
521 ((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) errs
,
522 0 /*lParam */ ))SleepEx(1000, TRUE
);
528 static int get_line(const char *prompt
, char *str
, int maxlen
, int is_pw
)
531 DWORD savemode
, newmode
, i
;
533 if (is_pw
&& password
) {
534 static int tried_once
= 0;
539 strncpy(str
, password
, maxlen
);
540 str
[maxlen
- 1] = '\0';
546 /* GUI Adaptation - Sept 2000 */
551 hin
= GetStdHandle(STD_INPUT_HANDLE
);
552 hout
= GetStdHandle(STD_OUTPUT_HANDLE
);
553 if (hin
== INVALID_HANDLE_VALUE
|| hout
== INVALID_HANDLE_VALUE
)
554 bump("Cannot get standard input/output handles");
556 GetConsoleMode(hin
, &savemode
);
557 newmode
= savemode
| ENABLE_PROCESSED_INPUT
| ENABLE_LINE_INPUT
;
559 newmode
&= ~ENABLE_ECHO_INPUT
;
561 newmode
|= ENABLE_ECHO_INPUT
;
562 SetConsoleMode(hin
, newmode
);
564 WriteFile(hout
, prompt
, strlen(prompt
), &i
, NULL
);
565 ReadFile(hin
, str
, maxlen
- 1, &i
, NULL
);
567 SetConsoleMode(hin
, savemode
);
569 if ((int) i
> maxlen
)
576 WriteFile(hout
, "\r\n", 2, &i
, NULL
);
583 * Open an SSH connection to user@host and execute cmd.
585 static void do_cmd(char *host
, char *user
, char *cmd
)
587 char *err
, *realhost
;
590 if (host
== NULL
|| host
[0] == '\0')
591 bump("Empty host name");
593 /* Try to load settings for this host */
594 do_defaults(host
, &cfg
);
595 if (cfg
.host
[0] == '\0') {
596 /* No settings for this host; use defaults */
597 do_defaults(NULL
, &cfg
);
598 strncpy(cfg
.host
, host
, sizeof(cfg
.host
) - 1);
599 cfg
.host
[sizeof(cfg
.host
) - 1] = '\0';
604 * Trim leading whitespace off the hostname if it's there.
607 int space
= strspn(cfg
.host
, " \t");
608 memmove(cfg
.host
, cfg
.host
+space
, 1+strlen(cfg
.host
)-space
);
611 /* See if host is of the form user@host */
612 if (cfg
.host
[0] != '\0') {
613 char *atsign
= strchr(cfg
.host
, '@');
614 /* Make sure we're not overflowing the user field */
616 if (atsign
- cfg
.host
< sizeof cfg
.username
) {
617 strncpy(cfg
.username
, cfg
.host
, atsign
- cfg
.host
);
618 cfg
.username
[atsign
- cfg
.host
] = '\0';
620 memmove(cfg
.host
, atsign
+ 1, 1 + strlen(atsign
+ 1));
625 * Trim a colon suffix off the hostname if it's there.
627 cfg
.host
[strcspn(cfg
.host
, ":")] = '\0';
630 if (user
!= NULL
&& user
[0] != '\0') {
631 strncpy(cfg
.username
, user
, sizeof(cfg
.username
) - 1);
632 cfg
.username
[sizeof(cfg
.username
) - 1] = '\0';
633 } else if (cfg
.username
[0] == '\0') {
635 if (GetUserName(user
, &namelen
) == FALSE
)
636 bump("Empty user name");
637 user
= smalloc(namelen
* sizeof(char));
638 GetUserName(user
, &namelen
);
640 tell_user(stderr
, "Guessing user name: %s", user
);
641 strncpy(cfg
.username
, user
, sizeof(cfg
.username
) - 1);
642 cfg
.username
[sizeof(cfg
.username
) - 1] = '\0';
646 if (cfg
.protocol
!= PROT_SSH
)
650 cfg
.port
= portnumber
;
653 * Disable scary things which shouldn't be enabled for simple
654 * things like SCP and SFTP: agent forwarding, port forwarding,
659 cfg
.portfwd
[0] = cfg
.portfwd
[1] = '\0';
662 * Attempt to start the SFTP subsystem as a first choice,
663 * falling back to the provided scp command if that fails.
665 strcpy(cfg
.remote_cmd
, "sftp");
666 cfg
.ssh_subsys
= TRUE
;
667 cfg
.remote_cmd_ptr2
= cmd
;
668 cfg
.ssh_subsys2
= FALSE
;
673 err
= back
->init(cfg
.host
, cfg
.port
, &realhost
);
675 bump("ssh_init: %s", err
);
677 if (verbose
&& realhost
!= NULL
)
678 tell_user(stderr
, "Connected to %s\n", realhost
);
683 * Update statistic information about current file.
685 static void print_stats(char *name
, unsigned long size
, unsigned long done
,
686 time_t start
, time_t now
)
695 elap
= (unsigned long) difftime(now
, start
);
698 ratebs
= (float) done
/ elap
;
700 ratebs
= (float) done
;
705 eta
= (unsigned long) ((size
- done
) / ratebs
);
706 sprintf(etastr
, "%02ld:%02ld:%02ld",
707 eta
/ 3600, (eta
% 3600) / 60, eta
% 60);
709 pct
= (int) (100 * (done
* 1.0 / size
));
712 /* GUI Adaptation - Sept 2000 */
713 gui_update_stats(name
, size
, pct
, elap
, done
, eta
,
714 (unsigned long) ratebs
);
716 len
= printf("\r%-25.25s | %10ld kB | %5.1f kB/s | ETA: %8s | %3d%%",
717 name
, done
/ 1024, ratebs
/ 1024.0, etastr
, pct
);
718 if (len
< prev_stats_len
)
719 printf("%*s", prev_stats_len
- len
, "");
720 prev_stats_len
= len
;
728 * Find a colon in str and return a pointer to the colon.
729 * This is used to separate hostname from filename.
731 static char *colon(char *str
)
733 /* We ignore a leading colon, since the hostname cannot be
734 empty. We also ignore a colon as second character because
735 of filenames like f:myfile.txt. */
736 if (str
[0] == '\0' || str
[0] == ':' || str
[1] == ':')
738 while (*str
!= '\0' && *str
!= ':' && *str
!= '/' && *str
!= '\\')
747 * Return a pointer to the portion of str that comes after the last
748 * slash (or backslash or colon, if `local' is TRUE).
750 static char *stripslashes(char *str
, int local
)
755 p
= strchr(str
, ':');
759 p
= strrchr(str
, '/');
763 p
= strrchr(str
, '\\');
771 * Determine whether a string is entirely composed of dots.
773 static int is_dots(char *str
)
775 return str
[strspn(str
, ".")] == '\0';
779 * Wait for a response from the other side.
780 * Return 0 if ok, -1 if error.
782 static int response(void)
784 char ch
, resp
, rbuf
[2048];
787 if (ssh_scp_recv(&resp
, 1) <= 0)
788 bump("Lost connection");
798 case 2: /* fatal error */
800 if (ssh_scp_recv(&ch
, 1) <= 0)
801 bump("Protocol error: Lost connection");
803 } while (p
< sizeof(rbuf
) && ch
!= '\n');
806 tell_user(stderr
, "%s\n", rbuf
);
814 int sftp_recvdata(char *buf
, int len
)
816 return ssh_scp_recv(buf
, len
);
818 int sftp_senddata(char *buf
, int len
)
820 back
->send((unsigned char *) buf
, len
);
824 /* ----------------------------------------------------------------------
825 * sftp-based replacement for the hacky `pscp -ls'.
827 static int sftp_ls_compare(const void *av
, const void *bv
)
829 const struct fxp_name
*a
= (const struct fxp_name
*) av
;
830 const struct fxp_name
*b
= (const struct fxp_name
*) bv
;
831 return strcmp(a
->filename
, b
->filename
);
833 void scp_sftp_listdir(char *dirname
)
835 struct fxp_handle
*dirh
;
836 struct fxp_names
*names
;
837 struct fxp_name
*ournames
;
838 int nnames
, namesize
;
841 printf("Listing directory %s\n", dirname
);
843 dirh
= fxp_opendir(dirname
);
845 printf("Unable to open %s: %s\n", dirname
, fxp_error());
847 nnames
= namesize
= 0;
852 names
= fxp_readdir(dirh
);
854 if (fxp_error_type() == SSH_FX_EOF
)
856 printf("Reading directory %s: %s\n", dirname
, fxp_error());
859 if (names
->nnames
== 0) {
860 fxp_free_names(names
);
864 if (nnames
+ names
->nnames
>= namesize
) {
865 namesize
+= names
->nnames
+ 128;
867 srealloc(ournames
, namesize
* sizeof(*ournames
));
870 for (i
= 0; i
< names
->nnames
; i
++)
871 ournames
[nnames
++] = names
->names
[i
];
873 names
->nnames
= 0; /* prevent free_names */
874 fxp_free_names(names
);
879 * Now we have our filenames. Sort them by actual file
880 * name, and then output the longname parts.
882 qsort(ournames
, nnames
, sizeof(*ournames
), sftp_ls_compare
);
887 for (i
= 0; i
< nnames
; i
++)
888 printf("%s\n", ournames
[i
].longname
);
892 /* ----------------------------------------------------------------------
893 * Helper routines that contain the actual SCP protocol elements,
894 * implemented both as SCP1 and SFTP.
897 static struct scp_sftp_dirstack
{
898 struct scp_sftp_dirstack
*next
;
899 struct fxp_name
*names
;
900 int namepos
, namelen
;
903 int matched_something
; /* wildcard match set was non-empty */
904 } *scp_sftp_dirstack_head
;
905 static char *scp_sftp_remotepath
, *scp_sftp_currentname
;
906 static char *scp_sftp_wildcard
;
907 static int scp_sftp_targetisdir
, scp_sftp_donethistarget
;
908 static int scp_sftp_preserve
, scp_sftp_recursive
;
909 static unsigned long scp_sftp_mtime
, scp_sftp_atime
;
910 static int scp_has_times
;
911 static struct fxp_handle
*scp_sftp_filehandle
;
912 static uint64 scp_sftp_fileoffset
;
914 void scp_source_setup(char *target
, int shouldbedir
)
918 * Find out whether the target filespec is in fact a
921 struct fxp_attrs attrs
;
923 if (!fxp_stat(target
, &attrs
) ||
924 !(attrs
.flags
& SSH_FILEXFER_ATTR_PERMISSIONS
))
925 scp_sftp_targetisdir
= 0;
927 scp_sftp_targetisdir
= (attrs
.permissions
& 0040000) != 0;
929 if (shouldbedir
&& !scp_sftp_targetisdir
) {
930 bump("pscp: remote filespec %s: not a directory\n", target
);
933 scp_sftp_remotepath
= dupstr(target
);
941 int scp_send_errmsg(char *str
)
944 /* do nothing; we never need to send our errors to the server */
946 back
->send("\001", 1); /* scp protocol error prefix */
947 back
->send(str
, strlen(str
));
949 return 0; /* can't fail */
952 int scp_send_filetimes(unsigned long mtime
, unsigned long atime
)
955 scp_sftp_mtime
= mtime
;
956 scp_sftp_atime
= atime
;
961 sprintf(buf
, "T%lu 0 %lu 0\n", mtime
, atime
);
962 back
->send(buf
, strlen(buf
));
967 int scp_send_filename(char *name
, unsigned long size
, int modes
)
971 if (scp_sftp_targetisdir
) {
972 fullname
= dupcat(scp_sftp_remotepath
, "/", name
, NULL
);
974 fullname
= dupstr(scp_sftp_remotepath
);
976 scp_sftp_filehandle
=
977 fxp_open(fullname
, SSH_FXF_WRITE
| SSH_FXF_CREAT
| SSH_FXF_TRUNC
);
978 if (!scp_sftp_filehandle
) {
979 tell_user(stderr
, "pscp: unable to open %s: %s",
980 fullname
, fxp_error());
984 scp_sftp_fileoffset
= uint64_make(0, 0);
989 sprintf(buf
, "C%04o %lu ", modes
, size
);
990 back
->send(buf
, strlen(buf
));
991 back
->send(name
, strlen(name
));
997 int scp_send_filedata(char *data
, int len
)
1000 if (!scp_sftp_filehandle
) {
1003 if (!fxp_write(scp_sftp_filehandle
, data
, scp_sftp_fileoffset
, len
)) {
1004 tell_user(stderr
, "error while writing: %s\n", fxp_error());
1008 scp_sftp_fileoffset
= uint64_add32(scp_sftp_fileoffset
, len
);
1011 int bufsize
= back
->send(data
, len
);
1014 * If the network transfer is backing up - that is, the
1015 * remote site is not accepting data as fast as we can
1016 * produce it - then we must loop on network events until
1017 * we have space in the buffer again.
1019 while (bufsize
> MAX_SCP_BUFSIZE
) {
1020 if (!scp_process_network_event())
1022 bufsize
= back
->sendbuffer();
1029 int scp_send_finish(void)
1032 struct fxp_attrs attrs
;
1033 if (!scp_sftp_filehandle
) {
1036 if (scp_has_times
) {
1037 attrs
.flags
= SSH_FILEXFER_ATTR_ACMODTIME
;
1038 attrs
.atime
= scp_sftp_atime
;
1039 attrs
.mtime
= scp_sftp_mtime
;
1040 if (!fxp_fsetstat(scp_sftp_filehandle
, attrs
)) {
1041 tell_user(stderr
, "unable to set file times: %s\n", fxp_error());
1045 fxp_close(scp_sftp_filehandle
);
1054 char *scp_save_remotepath(void)
1057 return scp_sftp_remotepath
;
1062 void scp_restore_remotepath(char *data
)
1065 scp_sftp_remotepath
= data
;
1068 int scp_send_dirname(char *name
, int modes
)
1073 struct fxp_attrs attrs
;
1074 if (scp_sftp_targetisdir
) {
1075 fullname
= dupcat(scp_sftp_remotepath
, "/", name
, NULL
);
1077 fullname
= dupstr(scp_sftp_remotepath
);
1081 * We don't worry about whether we managed to create the
1082 * directory, because if it exists already it's OK just to
1083 * use it. Instead, we will stat it afterwards, and if it
1084 * exists and is a directory we will assume we were either
1085 * successful or it didn't matter.
1087 if (!fxp_mkdir(fullname
))
1090 err
= "server reported no error";
1091 if (!fxp_stat(fullname
, &attrs
) ||
1092 !(attrs
.flags
& SSH_FILEXFER_ATTR_PERMISSIONS
) ||
1093 !(attrs
.permissions
& 0040000)) {
1094 tell_user(stderr
, "unable to create directory %s: %s",
1100 scp_sftp_remotepath
= fullname
;
1105 sprintf(buf
, "D%04o 0 ", modes
);
1106 back
->send(buf
, strlen(buf
));
1107 back
->send(name
, strlen(name
));
1108 back
->send("\n", 1);
1113 int scp_send_enddir(void)
1116 sfree(scp_sftp_remotepath
);
1119 back
->send("E\n", 2);
1125 * Yes, I know; I have an scp_sink_setup _and_ an scp_sink_init.
1126 * That's bad. The difference is that scp_sink_setup is called once
1127 * right at the start, whereas scp_sink_init is called to
1128 * initialise every level of recursion in the protocol.
1130 int scp_sink_setup(char *source
, int preserve
, int recursive
)
1135 * It's possible that the source string we've been given
1136 * contains a wildcard. If so, we must split the directory
1137 * away from the wildcard itself (throwing an error if any
1138 * wildcardness comes before the final slash) and arrange
1139 * things so that a dirstack entry will be set up.
1141 newsource
= smalloc(1+strlen(source
));
1142 if (!wc_unescape(newsource
, source
)) {
1143 /* Yes, here we go; it's a wildcard. Bah. */
1144 char *dupsource
, *lastpart
, *dirpart
, *wildcard
;
1145 dupsource
= dupstr(source
);
1146 lastpart
= stripslashes(dupsource
, 0);
1147 wildcard
= dupstr(lastpart
);
1149 if (*dupsource
&& dupsource
[1]) {
1151 * The remains of dupsource are at least two
1152 * characters long, meaning the pathname wasn't
1153 * empty or just `/'. Hence, we remove the trailing
1156 lastpart
[-1] = '\0';
1157 } else if (!*dupsource
) {
1159 * The remains of dupsource are _empty_ - the whole
1160 * pathname was a wildcard. Hence we need to
1161 * replace it with ".".
1164 dupsource
= dupstr(".");
1168 * Now we have separated our string into dupsource (the
1169 * directory part) and wildcard. Both of these will
1170 * need freeing at some point. Next step is to remove
1171 * wildcard escapes from the directory part, throwing
1172 * an error if it contains a real wildcard.
1174 dirpart
= smalloc(1+strlen(dupsource
));
1175 if (!wc_unescape(dirpart
, dupsource
)) {
1176 tell_user(stderr
, "%s: multiple-level wildcards unsupported",
1186 * Now we have dirpart (unescaped, ie a valid remote
1187 * path), and wildcard (a wildcard). This will be
1188 * sufficient to arrange a dirstack entry.
1190 scp_sftp_remotepath
= dirpart
;
1191 scp_sftp_wildcard
= wildcard
;
1194 scp_sftp_remotepath
= newsource
;
1195 scp_sftp_wildcard
= NULL
;
1197 scp_sftp_preserve
= preserve
;
1198 scp_sftp_recursive
= recursive
;
1199 scp_sftp_donethistarget
= 0;
1200 scp_sftp_dirstack_head
= NULL
;
1205 int scp_sink_init(void)
1213 #define SCP_SINK_FILE 1
1214 #define SCP_SINK_DIR 2
1215 #define SCP_SINK_ENDDIR 3
1216 #define SCP_SINK_RETRY 4 /* not an action; just try again */
1217 struct scp_sink_action
{
1218 int action
; /* FILE, DIR, ENDDIR */
1219 char *buf
; /* will need freeing after use */
1220 char *name
; /* filename or dirname (not ENDDIR) */
1221 int mode
; /* access mode (not ENDDIR) */
1222 unsigned long size
; /* file size (not ENDDIR) */
1223 int settime
; /* 1 if atime and mtime are filled */
1224 unsigned long atime
, mtime
; /* access times for the file */
1227 int scp_get_sink_action(struct scp_sink_action
*act
)
1231 int must_free_fname
;
1232 struct fxp_attrs attrs
;
1235 if (!scp_sftp_dirstack_head
) {
1236 if (!scp_sftp_donethistarget
) {
1238 * Simple case: we are only dealing with one file.
1240 fname
= scp_sftp_remotepath
;
1241 must_free_fname
= 0;
1242 scp_sftp_donethistarget
= 1;
1245 * Even simpler case: one file _which we've done_.
1246 * Return 1 (finished).
1252 * We're now in the middle of stepping through a list
1253 * of names returned from fxp_readdir(); so let's carry
1256 struct scp_sftp_dirstack
*head
= scp_sftp_dirstack_head
;
1257 while (head
->namepos
< head
->namelen
&&
1258 (is_dots(head
->names
[head
->namepos
].filename
) ||
1260 !wc_match(head
->wildcard
,
1261 head
->names
[head
->namepos
].filename
))))
1262 head
->namepos
++; /* skip . and .. */
1263 if (head
->namepos
< head
->namelen
) {
1264 head
->matched_something
= 1;
1265 fname
= dupcat(head
->dirpath
, "/",
1266 head
->names
[head
->namepos
++].filename
,
1268 must_free_fname
= 1;
1271 * We've come to the end of the list; pop it off
1272 * the stack and return an ENDDIR action (or RETRY
1273 * if this was a wildcard match).
1275 if (head
->wildcard
) {
1276 act
->action
= SCP_SINK_RETRY
;
1277 if (!head
->matched_something
) {
1278 tell_user(stderr
, "pscp: wildcard '%s' matched "
1279 "no files", head
->wildcard
);
1282 sfree(head
->wildcard
);
1285 act
->action
= SCP_SINK_ENDDIR
;
1288 sfree(head
->dirpath
);
1290 scp_sftp_dirstack_head
= head
->next
;
1298 * Now we have a filename. Stat it, and see if it's a file
1301 ret
= fxp_stat(fname
, &attrs
);
1302 if (!ret
|| !(attrs
.flags
& SSH_FILEXFER_ATTR_PERMISSIONS
)) {
1303 tell_user(stderr
, "unable to identify %s: %s", fname
,
1304 ret ?
"file type not supplied" : fxp_error());
1309 if (attrs
.permissions
& 0040000) {
1310 struct scp_sftp_dirstack
*newitem
;
1311 struct fxp_handle
*dirhandle
;
1312 int nnames
, namesize
;
1313 struct fxp_name
*ournames
;
1314 struct fxp_names
*names
;
1317 * It's a directory. If we're not in recursive mode,
1318 * this merits a complaint (which is fatal if the name
1319 * was specified directly, but not if it was matched by
1322 * We skip this complaint completely if
1323 * scp_sftp_wildcard is set, because that's an
1324 * indication that we're not actually supposed to
1325 * _recursively_ transfer the dir, just scan it for
1326 * things matching the wildcard.
1328 if (!scp_sftp_recursive
&& !scp_sftp_wildcard
) {
1329 tell_user(stderr
, "pscp: %s: is a directory", fname
);
1331 if (must_free_fname
) sfree(fname
);
1332 if (scp_sftp_dirstack_head
) {
1333 act
->action
= SCP_SINK_RETRY
;
1341 * Otherwise, the fun begins. We must fxp_opendir() the
1342 * directory, slurp the filenames into memory, return
1343 * SCP_SINK_DIR (unless this is a wildcard match), and
1344 * set targetisdir. The next time we're called, we will
1345 * run through the list of filenames one by one,
1346 * matching them against a wildcard if present.
1348 * If targetisdir is _already_ set (meaning we're
1349 * already in the middle of going through another such
1350 * list), we must push the other (target,namelist) pair
1353 dirhandle
= fxp_opendir(fname
);
1355 tell_user(stderr
, "scp: unable to open directory %s: %s",
1356 fname
, fxp_error());
1357 if (must_free_fname
) sfree(fname
);
1361 nnames
= namesize
= 0;
1366 names
= fxp_readdir(dirhandle
);
1367 if (names
== NULL
) {
1368 if (fxp_error_type() == SSH_FX_EOF
)
1370 tell_user(stderr
, "scp: reading directory %s: %s\n",
1371 fname
, fxp_error());
1372 if (must_free_fname
) sfree(fname
);
1377 if (names
->nnames
== 0) {
1378 fxp_free_names(names
);
1381 if (nnames
+ names
->nnames
>= namesize
) {
1382 namesize
+= names
->nnames
+ 128;
1384 srealloc(ournames
, namesize
* sizeof(*ournames
));
1386 for (i
= 0; i
< names
->nnames
; i
++)
1387 ournames
[nnames
++] = names
->names
[i
];
1388 names
->nnames
= 0; /* prevent free_names */
1389 fxp_free_names(names
);
1391 fxp_close(dirhandle
);
1393 newitem
= smalloc(sizeof(struct scp_sftp_dirstack
));
1394 newitem
->next
= scp_sftp_dirstack_head
;
1395 newitem
->names
= ournames
;
1396 newitem
->namepos
= 0;
1397 newitem
->namelen
= nnames
;
1398 if (must_free_fname
)
1399 newitem
->dirpath
= fname
;
1401 newitem
->dirpath
= dupstr(fname
);
1402 if (scp_sftp_wildcard
) {
1403 newitem
->wildcard
= scp_sftp_wildcard
;
1404 newitem
->matched_something
= 0;
1405 scp_sftp_wildcard
= NULL
;
1407 newitem
->wildcard
= NULL
;
1409 scp_sftp_dirstack_head
= newitem
;
1411 if (newitem
->wildcard
) {
1412 act
->action
= SCP_SINK_RETRY
;
1414 act
->action
= SCP_SINK_DIR
;
1415 act
->buf
= dupstr(stripslashes(fname
, 0));
1416 act
->name
= act
->buf
;
1417 act
->size
= 0; /* duhh, it's a directory */
1418 act
->mode
= 07777 & attrs
.permissions
;
1419 if (scp_sftp_preserve
&&
1420 (attrs
.flags
& SSH_FILEXFER_ATTR_ACMODTIME
)) {
1421 act
->atime
= attrs
.atime
;
1422 act
->mtime
= attrs
.mtime
;
1431 * It's a file. Return SCP_SINK_FILE.
1433 act
->action
= SCP_SINK_FILE
;
1434 act
->buf
= dupstr(stripslashes(fname
, 0));
1435 act
->name
= act
->buf
;
1436 if (attrs
.flags
& SSH_FILEXFER_ATTR_SIZE
) {
1437 if (uint64_compare(attrs
.size
,
1438 uint64_make(0, ULONG_MAX
)) > 0) {
1439 act
->size
= ULONG_MAX
; /* *boggle* */
1441 act
->size
= attrs
.size
.lo
;
1443 act
->size
= ULONG_MAX
; /* no idea */
1444 act
->mode
= 07777 & attrs
.permissions
;
1445 if (scp_sftp_preserve
&&
1446 (attrs
.flags
& SSH_FILEXFER_ATTR_ACMODTIME
)) {
1447 act
->atime
= attrs
.atime
;
1448 act
->mtime
= attrs
.mtime
;
1452 if (must_free_fname
)
1453 scp_sftp_currentname
= fname
;
1455 scp_sftp_currentname
= dupstr(fname
);
1470 if (ssh_scp_recv(&ch
, 1) <= 0)
1473 bump("Protocol error: Unexpected newline");
1477 if (ssh_scp_recv(&ch
, 1) <= 0)
1478 bump("Lost connection");
1481 act
->buf
= srealloc(act
->buf
, bufsize
);
1484 } while (ch
!= '\n');
1485 act
->buf
[i
- 1] = '\0';
1487 case '\01': /* error */
1488 tell_user(stderr
, "%s\n", act
->buf
);
1490 continue; /* go round again */
1491 case '\02': /* fatal error */
1492 bump("%s", act
->buf
);
1495 act
->action
= SCP_SINK_ENDDIR
;
1498 if (sscanf(act
->buf
, "%ld %*d %ld %*d",
1499 &act
->mtime
, &act
->atime
) == 2) {
1502 continue; /* go round again */
1504 bump("Protocol error: Illegal time format");
1507 act
->action
= (action
== 'C' ? SCP_SINK_FILE
: SCP_SINK_DIR
);
1510 bump("Protocol error: Expected control record");
1513 * We will go round this loop only once, unless we hit
1520 * If we get here, we must have seen SCP_SINK_FILE or
1523 if (sscanf(act
->buf
, "%o %lu %n", &act
->mode
, &act
->size
, &i
) != 2)
1524 bump("Protocol error: Illegal file descriptor format");
1525 act
->name
= act
->buf
+ i
;
1530 int scp_accept_filexfer(void)
1533 scp_sftp_filehandle
=
1534 fxp_open(scp_sftp_currentname
, SSH_FXF_READ
);
1535 if (!scp_sftp_filehandle
) {
1536 tell_user(stderr
, "pscp: unable to open %s: %s",
1537 scp_sftp_currentname
, fxp_error());
1541 scp_sftp_fileoffset
= uint64_make(0, 0);
1542 sfree(scp_sftp_currentname
);
1546 return 0; /* can't fail */
1550 int scp_recv_filedata(char *data
, int len
)
1553 int actuallen
= fxp_read(scp_sftp_filehandle
, data
,
1554 scp_sftp_fileoffset
, len
);
1555 if (actuallen
== -1 && fxp_error_type() != SSH_FX_EOF
) {
1556 tell_user(stderr
, "pscp: error while reading: %s", fxp_error());
1563 scp_sftp_fileoffset
= uint64_add32(scp_sftp_fileoffset
, actuallen
);
1567 return ssh_scp_recv(data
, len
);
1571 int scp_finish_filerecv(void)
1574 fxp_close(scp_sftp_filehandle
);
1582 /* ----------------------------------------------------------------------
1583 * Send an error message to the other side and to the screen.
1584 * Increment error counter.
1586 static void run_err(const char *fmt
, ...)
1592 strcpy(str
, "scp: ");
1593 vsprintf(str
+ strlen(str
), fmt
, ap
);
1595 scp_send_errmsg(str
);
1596 tell_user(stderr
, "%s", str
);
1601 * Execute the source part of the SCP protocol.
1603 static void source(char *src
)
1610 unsigned long stat_bytes
;
1611 time_t stat_starttime
, stat_lasttime
;
1613 attr
= GetFileAttributes(src
);
1614 if (attr
== (DWORD
) - 1) {
1615 run_err("%s: No such file or directory", src
);
1619 if ((attr
& FILE_ATTRIBUTE_DIRECTORY
) != 0) {
1622 * Avoid . and .. directories.
1625 p
= strrchr(src
, '/');
1627 p
= strrchr(src
, '\\');
1632 if (!strcmp(p
, ".") || !strcmp(p
, ".."))
1633 /* skip . and .. */ ;
1637 run_err("%s: not a regular file", src
);
1642 if ((last
= strrchr(src
, '/')) == NULL
)
1646 if (strrchr(last
, '\\') != NULL
)
1647 last
= strrchr(last
, '\\') + 1;
1648 if (last
== src
&& strchr(src
, ':') != NULL
)
1649 last
= strchr(src
, ':') + 1;
1651 f
= CreateFile(src
, GENERIC_READ
, FILE_SHARE_READ
, NULL
,
1652 OPEN_EXISTING
, 0, 0);
1653 if (f
== INVALID_HANDLE_VALUE
) {
1654 run_err("%s: Cannot open file", src
);
1659 FILETIME actime
, wrtime
;
1660 unsigned long mtime
, atime
;
1661 GetFileTime(f
, NULL
, &actime
, &wrtime
);
1662 TIME_WIN_TO_POSIX(actime
, atime
);
1663 TIME_WIN_TO_POSIX(wrtime
, mtime
);
1664 if (scp_send_filetimes(mtime
, atime
))
1668 size
= GetFileSize(f
, NULL
);
1670 tell_user(stderr
, "Sending file %s, size=%lu", last
, size
);
1671 if (scp_send_filename(last
, size
, 0644))
1675 stat_starttime
= time(NULL
);
1678 for (i
= 0; i
< size
; i
+= 4096) {
1679 char transbuf
[4096];
1684 if (!ReadFile(f
, transbuf
, k
, &j
, NULL
) || j
!= k
) {
1687 bump("%s: Read error", src
);
1689 if (scp_send_filedata(transbuf
, k
))
1690 bump("%s: Network error occurred", src
);
1694 if (time(NULL
) != stat_lasttime
|| i
+ k
== size
) {
1695 stat_lasttime
= time(NULL
);
1696 print_stats(last
, size
, stat_bytes
,
1697 stat_starttime
, stat_lasttime
);
1704 (void) scp_send_finish();
1708 * Recursively send the contents of a directory.
1710 static void rsource(char *src
)
1712 char *last
, *findfile
;
1715 WIN32_FIND_DATA fdat
;
1718 if ((last
= strrchr(src
, '/')) == NULL
)
1722 if (strrchr(last
, '\\') != NULL
)
1723 last
= strrchr(last
, '\\') + 1;
1724 if (last
== src
&& strchr(src
, ':') != NULL
)
1725 last
= strchr(src
, ':') + 1;
1727 /* maybe send filetime */
1729 save_target
= scp_save_remotepath();
1732 tell_user(stderr
, "Entering directory: %s", last
);
1733 if (scp_send_dirname(last
, 0755))
1736 findfile
= dupcat(src
, "/*", NULL
);
1737 dir
= FindFirstFile(findfile
, &fdat
);
1738 ok
= (dir
!= INVALID_HANDLE_VALUE
);
1740 if (strcmp(fdat
.cFileName
, ".") == 0 ||
1741 strcmp(fdat
.cFileName
, "..") == 0) {
1742 /* ignore . and .. */
1744 char *foundfile
= dupcat(src
, "/", fdat
.cFileName
, NULL
);
1748 ok
= FindNextFile(dir
, &fdat
);
1753 (void) scp_send_enddir();
1755 scp_restore_remotepath(save_target
);
1759 * Execute the sink part of the SCP protocol.
1761 static void sink(char *targ
, char *src
)
1768 unsigned long received
;
1770 unsigned long stat_bytes
;
1771 time_t stat_starttime
, stat_lasttime
;
1774 attr
= GetFileAttributes(targ
);
1775 if (attr
!= (DWORD
) - 1 && (attr
& FILE_ATTRIBUTE_DIRECTORY
) != 0)
1778 if (targetshouldbedirectory
&& !targisdir
)
1779 bump("%s: Not a directory", targ
);
1783 struct scp_sink_action act
;
1784 if (scp_get_sink_action(&act
))
1787 if (act
.action
== SCP_SINK_ENDDIR
)
1790 if (act
.action
== SCP_SINK_RETRY
)
1795 * Prevent the remote side from maliciously writing to
1796 * files outside the target area by sending a filename
1797 * containing `../'. In fact, it shouldn't be sending
1798 * filenames with any slashes or colons in at all; so
1799 * we'll find the last slash, backslash or colon in the
1800 * filename and use only the part after that. (And
1803 * In addition, we also ensure here that if we're
1804 * copying a single file and the target is a directory
1805 * (common usage: `pscp host:filename .') the remote
1806 * can't send us a _different_ file name. We can
1807 * distinguish this case because `src' will be non-NULL
1808 * and the last component of that will fail to match
1809 * (the last component of) the name sent.
1811 * Well, not always; if `src' is a wildcard, we do
1812 * expect to get back filenames that don't correspond
1813 * exactly to it. Ideally in this case, we would like
1814 * to ensure that the returned filename actually
1815 * matches the wildcard pattern - but one of SCP's
1816 * protocol infelicities is that wildcard matching is
1817 * done at the server end _by the server's rules_ and
1818 * so in general this is infeasible. Hence, we only
1819 * accept filenames that don't correspond to `src' if
1820 * unsafe mode is enabled or we are using SFTP (which
1821 * resolves remote wildcards on the client side and can
1824 char *striptarget
, *stripsrc
;
1826 striptarget
= stripslashes(act
.name
, 1);
1827 if (striptarget
!= act
.name
) {
1828 tell_user(stderr
, "warning: remote host sent a compound"
1829 " pathname '%s'", act
.name
);
1830 tell_user(stderr
, " renaming local file to '%s'",
1835 * Also check to see if the target filename is '.' or
1836 * '..', or indeed '...' and so on because Windows
1837 * appears to interpret those like '..'.
1839 if (is_dots(striptarget
)) {
1840 bump("security violation: remote host attempted to write to"
1841 " a '.' or '..' path!");
1845 stripsrc
= stripslashes(src
, 1);
1846 if (strcmp(striptarget
, stripsrc
) &&
1847 !using_sftp
&& !scp_unsafe_mode
) {
1848 tell_user(stderr
, "warning: remote host tried to write "
1849 "to a file called '%s'", striptarget
);
1850 tell_user(stderr
, " when we requested a file "
1851 "called '%s'.", stripsrc
);
1852 tell_user(stderr
, " If this is a wildcard, "
1853 "consider upgrading to SSH 2 or using");
1854 tell_user(stderr
, " the '-unsafe' option. Renaming"
1855 " of this file has been disallowed.");
1856 /* Override the name the server provided with our own. */
1857 striptarget
= stripsrc
;
1861 if (targ
[0] != '\0')
1862 destfname
= dupcat(targ
, "\\", striptarget
, NULL
);
1864 destfname
= dupstr(striptarget
);
1867 * In this branch of the if, the target area is a
1868 * single file with an explicitly specified name in any
1869 * case, so there's no danger.
1871 destfname
= dupstr(targ
);
1873 attr
= GetFileAttributes(destfname
);
1874 exists
= (attr
!= (DWORD
) - 1);
1876 if (act
.action
== SCP_SINK_DIR
) {
1877 if (exists
&& (attr
& FILE_ATTRIBUTE_DIRECTORY
) == 0) {
1878 run_err("%s: Not a directory", destfname
);
1882 if (!CreateDirectory(destfname
, NULL
)) {
1883 run_err("%s: Cannot create directory", destfname
);
1887 sink(destfname
, NULL
);
1888 /* can we set the timestamp for directories ? */
1892 f
= CreateFile(destfname
, GENERIC_WRITE
, 0, NULL
,
1893 CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, 0);
1894 if (f
== INVALID_HANDLE_VALUE
) {
1895 run_err("%s: Cannot create file", destfname
);
1899 if (scp_accept_filexfer())
1903 stat_starttime
= time(NULL
);
1905 stat_name
= stripslashes(destfname
, 1);
1908 while (received
< act
.size
) {
1909 char transbuf
[4096];
1910 DWORD blksize
, read
, written
;
1912 if (blksize
> act
.size
- received
)
1913 blksize
= act
.size
- received
;
1914 read
= scp_recv_filedata(transbuf
, blksize
);
1916 bump("Lost connection");
1919 if (!WriteFile(f
, transbuf
, read
, &written
, NULL
) ||
1922 /* FIXME: in sftp we can actually abort the transfer */
1924 printf("\r%-25.25s | %50s\n",
1926 "Write error.. waiting for end of file");
1931 if (time(NULL
) > stat_lasttime
||
1932 received
+ read
== act
.size
) {
1933 stat_lasttime
= time(NULL
);
1934 print_stats(stat_name
, act
.size
, stat_bytes
,
1935 stat_starttime
, stat_lasttime
);
1941 FILETIME actime
, wrtime
;
1942 TIME_POSIX_TO_WIN(act
.atime
, actime
);
1943 TIME_POSIX_TO_WIN(act
.mtime
, wrtime
);
1944 SetFileTime(f
, NULL
, &actime
, &wrtime
);
1949 run_err("%s: Write error", destfname
);
1952 (void) scp_finish_filerecv();
1959 * We will copy local files to a remote server.
1961 static void toremote(int argc
, char *argv
[])
1963 char *src
, *targ
, *host
, *user
;
1967 targ
= argv
[argc
- 1];
1969 /* Separate host from filename */
1973 bump("targ == NULL in toremote()");
1977 /* Substitute "." for emtpy target */
1979 /* Separate host and username */
1981 host
= strrchr(host
, '@');
1992 /* Find out if the source filespec covers multiple files
1993 if so, we should set the targetshouldbedirectory flag */
1995 WIN32_FIND_DATA fdat
;
1996 if (colon(argv
[0]) != NULL
)
1997 bump("%s: Remote to remote not supported", argv
[0]);
1998 fh
= FindFirstFile(argv
[0], &fdat
);
1999 if (fh
== INVALID_HANDLE_VALUE
)
2000 bump("%s: No such file or directory\n", argv
[0]);
2001 if (FindNextFile(fh
, &fdat
))
2002 targetshouldbedirectory
= 1;
2006 cmd
= smalloc(strlen(targ
) + 100);
2007 sprintf(cmd
, "scp%s%s%s%s -t %s",
2008 verbose ?
" -v" : "",
2009 recursive ?
" -r" : "",
2010 preserve ?
" -p" : "",
2011 targetshouldbedirectory ?
" -d" : "", targ
);
2012 do_cmd(host
, user
, cmd
);
2015 scp_source_setup(targ
, targetshouldbedirectory
);
2017 for (i
= 0; i
< argc
- 1; i
++) {
2018 char *srcpath
, *last
;
2020 WIN32_FIND_DATA fdat
;
2022 if (colon(src
) != NULL
) {
2023 tell_user(stderr
, "%s: Remote to remote not supported\n", src
);
2029 * Trim off the last pathname component of `src', to
2030 * provide the base pathname which will be prepended to
2031 * filenames returned from Find{First,Next}File.
2033 srcpath
= dupstr(src
);
2034 last
= stripslashes(srcpath
, 1);
2037 dir
= FindFirstFile(src
, &fdat
);
2038 if (dir
== INVALID_HANDLE_VALUE
) {
2039 run_err("%s: No such file or directory", src
);
2045 * Ensure that . and .. are never matched by wildcards,
2046 * but only by deliberate action.
2048 if (!strcmp(fdat
.cFileName
, ".") ||
2049 !strcmp(fdat
.cFileName
, "..")) {
2051 * Find*File has returned a special dir. We require
2052 * that _either_ `src' ends in a backslash followed
2053 * by that string, _or_ `src' is precisely that
2056 int len
= strlen(src
), dlen
= strlen(fdat
.cFileName
);
2057 if (len
== dlen
&& !strcmp(src
, fdat
.cFileName
)) {
2059 } else if (len
> dlen
+ 1 && src
[len
- dlen
- 1] == '\\' &&
2060 !strcmp(src
+ len
- dlen
, fdat
.cFileName
)) {
2063 continue; /* ignore this one */
2065 filename
= dupcat(srcpath
, fdat
.cFileName
, NULL
);
2068 } while (FindNextFile(dir
, &fdat
));
2075 * We will copy files from a remote server to the local machine.
2077 static void tolocal(int argc
, char *argv
[])
2079 char *src
, *targ
, *host
, *user
;
2083 bump("More than one remote source not supported");
2088 /* Separate host from filename */
2092 bump("Local to local copy not supported");
2096 /* Substitute "." for empty filename */
2098 /* Separate username and hostname */
2100 host
= strrchr(host
, '@');
2110 cmd
= smalloc(strlen(src
) + 100);
2111 sprintf(cmd
, "scp%s%s%s%s -f %s",
2112 verbose ?
" -v" : "",
2113 recursive ?
" -r" : "",
2114 preserve ?
" -p" : "",
2115 targetshouldbedirectory ?
" -d" : "", src
);
2116 do_cmd(host
, user
, cmd
);
2119 if (scp_sink_setup(src
, preserve
, recursive
))
2126 * We will issue a list command to get a remote directory.
2128 static void get_dir_list(int argc
, char *argv
[])
2130 char *src
, *host
, *user
;
2136 /* Separate host from filename */
2140 bump("Local to local copy not supported");
2144 /* Substitute "." for empty filename */
2146 /* Separate username and hostname */
2148 host
= strrchr(host
, '@');
2158 cmd
= smalloc(4 * strlen(src
) + 100);
2159 strcpy(cmd
, "ls -la '");
2160 p
= cmd
+ strlen(cmd
);
2161 for (q
= src
; *q
; q
++) {
2174 do_cmd(host
, user
, cmd
);
2178 scp_sftp_listdir(src
);
2180 while (ssh_scp_recv(&c
, 1) > 0)
2181 tell_char(stdout
, c
);
2186 * Initialize the Win$ock driver.
2188 static void init_winsock(void)
2193 winsock_ver
= MAKEWORD(1, 1);
2194 if (WSAStartup(winsock_ver
, &wsadata
))
2195 bump("Unable to initialise WinSock");
2196 if (LOBYTE(wsadata
.wVersion
) != 1 || HIBYTE(wsadata
.wVersion
) != 1)
2197 bump("WinSock version is incompatible with 1.1");
2201 * Short description of parameters.
2203 static void usage(void)
2205 printf("PuTTY Secure Copy client\n");
2206 printf("%s\n", ver
);
2207 printf("Usage: pscp [options] [user@]host:source target\n");
2209 (" pscp [options] source [source...] [user@]host:target\n");
2210 printf(" pscp [options] -ls user@host:filespec\n");
2211 printf("Options:\n");
2212 printf(" -p preserve file attributes\n");
2213 printf(" -q quiet, don't show statistics\n");
2214 printf(" -r copy directories recursively\n");
2215 printf(" -v show verbose messages\n");
2216 printf(" -P port connect to specified port\n");
2217 printf(" -pw passw login with specified password\n");
2218 printf(" -unsafe allow server-side wildcards (DANGEROUS)\n");
2221 * -gui is an internal option, used by GUI front ends to get
2222 * pscp to pass progress reports back to them. It's not an
2223 * ordinary user-accessible option, so it shouldn't be part of
2224 * the command-line help. The only people who need to know
2225 * about it are programmers, and they can read the source.
2228 (" -gui hWnd GUI mode with the windows handle for receiving messages\n");
2234 * Main program (no, really?)
2236 int main(int argc
, char *argv
[])
2240 default_protocol
= PROT_TELNET
;
2242 flags
= FLAG_STDERR
;
2243 ssh_get_line
= &get_line
;
2247 for (i
= 1; i
< argc
; i
++) {
2248 if (argv
[i
][0] != '-')
2250 if (strcmp(argv
[i
], "-v") == 0)
2251 verbose
= 1, flags
|= FLAG_VERBOSE
;
2252 else if (strcmp(argv
[i
], "-r") == 0)
2254 else if (strcmp(argv
[i
], "-p") == 0)
2256 else if (strcmp(argv
[i
], "-q") == 0)
2258 else if (strcmp(argv
[i
], "-h") == 0 || strcmp(argv
[i
], "-?") == 0)
2260 else if (strcmp(argv
[i
], "-P") == 0 && i
+ 1 < argc
)
2261 portnumber
= atoi(argv
[++i
]);
2262 else if (strcmp(argv
[i
], "-pw") == 0 && i
+ 1 < argc
)
2263 password
= argv
[++i
];
2264 else if (strcmp(argv
[i
], "-gui") == 0 && i
+ 1 < argc
) {
2265 gui_hwnd
= argv
[++i
];
2267 } else if (strcmp(argv
[i
], "-ls") == 0)
2269 else if (strcmp(argv
[i
], "-unsafe") == 0)
2270 scp_unsafe_mode
= 1;
2271 else if (strcmp(argv
[i
], "--") == 0) {
2284 get_dir_list(argc
, argv
);
2291 targetshouldbedirectory
= 1;
2293 if (colon(argv
[argc
- 1]) != NULL
)
2294 toremote(argc
, argv
);
2296 tolocal(argc
, argv
);
2299 if (back
!= NULL
&& back
->socket() != NULL
) {
2301 back
->special(TS_EOF
);
2302 ssh_scp_recv(&ch
, 1);
2307 /* GUI Adaptation - August 2000 */
2309 unsigned int msg_id
= WM_RET_ERR_CNT
;
2311 msg_id
= WM_LS_RET_ERR_CNT
;
2313 ((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) errs
,
2314 0 /*lParam */ ))SleepEx(1000, TRUE
);
2316 return (errs
== 0 ?
0 : 1);