2 * scp.c - Scp (Secure Copy) client for PuTTY.
3 * Joris van Rantwijk, Simon Tatham
5 * This is mainly based on ssh-1.2.26/scp.c by Timo Rinne & Tatu Ylonen.
6 * They, in turn, used stuff from BSD rcp.
8 * Adaptations to enable connecting a GUI by L. Gunnarsson - Sept 2000
25 /* GUI Adaptation - Sept 2000 */
29 #define PUTTY_DO_GLOBALS
36 #define TIME_POSIX_TO_WIN(t, ft) (*(LONGLONG*)&(ft) = \
37 ((LONGLONG) (t) + (LONGLONG) 11644473600) * (LONGLONG) 10000000)
38 #define TIME_WIN_TO_POSIX(ft, t) ((t) = (unsigned long) \
39 ((*(LONGLONG*)&(ft)) / (LONGLONG) 10000000 - (LONGLONG) 11644473600))
41 /* GUI Adaptation - Sept 2000 */
42 #define WM_APP_BASE 0x8000
43 #define WM_STD_OUT_CHAR ( WM_APP_BASE+400 )
44 #define WM_STD_ERR_CHAR ( WM_APP_BASE+401 )
45 #define WM_STATS_CHAR ( WM_APP_BASE+402 )
46 #define WM_STATS_SIZE ( WM_APP_BASE+403 )
47 #define WM_STATS_PERCENT ( WM_APP_BASE+404 )
48 #define WM_STATS_ELAPSED ( WM_APP_BASE+405 )
49 #define WM_RET_ERR_CNT ( WM_APP_BASE+406 )
50 #define WM_LS_RET_ERR_CNT ( WM_APP_BASE+407 )
53 static int verbose
= 0;
54 static int recursive
= 0;
55 static int preserve
= 0;
56 static int targetshouldbedirectory
= 0;
57 static int statistics
= 1;
58 static int portnumber
= 0;
59 static int prev_stats_len
= 0;
60 static int scp_unsafe_mode
= 0;
61 static char *password
= NULL
;
63 /* GUI Adaptation - Sept 2000 */
64 #define NAME_STR_MAX 2048
65 static char statname
[NAME_STR_MAX
+ 1];
66 static unsigned long statsize
= 0;
67 static int statperct
= 0;
68 static unsigned long statelapsed
= 0;
69 static int gui_mode
= 0;
70 static char *gui_hwnd
= NULL
;
71 static int using_sftp
= 0;
73 static void source(char *src
);
74 static void rsource(char *src
);
75 static void sink(char *targ
, char *src
);
76 /* GUI Adaptation - Sept 2000 */
77 static void tell_char(FILE * stream
, char c
);
78 static void tell_str(FILE * stream
, char *str
);
79 static void tell_user(FILE * stream
, char *fmt
, ...);
80 static void gui_update_stats(char *name
, unsigned long size
,
81 int percentage
, unsigned long elapsed
);
84 * The maximum amount of queued data we accept before we stop and
85 * wait for the server to process some.
87 #define MAX_SCP_BUFSIZE 16384
89 void logevent(char *string
)
93 void ldisc_send(char *buf
, int len
)
96 * This is only here because of the calls to ldisc_send(NULL,
97 * 0) in ssh.c. Nothing in PSCP actually needs to use the ldisc
98 * as an ldisc. So if we get called with any real data, I want
104 void verify_ssh_host_key(char *host
, int port
, char *keytype
,
105 char *keystr
, char *fingerprint
)
111 static const char absentmsg
[] =
112 "The server's host key is not cached in the registry. You\n"
113 "have no guarantee that the server is the computer you\n"
115 "The server's key fingerprint is:\n"
117 "If you trust this host, enter \"y\" to add the key to\n"
118 "PuTTY's cache and carry on connecting.\n"
119 "If you want to carry on connecting just once, without\n"
120 "adding the key to the cache, enter \"n\".\n"
121 "If you do not trust this host, press Return to abandon the\n"
123 "Store key in cache? (y/n) ";
125 static const char wrongmsg
[] =
126 "WARNING - POTENTIAL SECURITY BREACH!\n"
127 "The server's host key does not match the one PuTTY has\n"
128 "cached in the registry. This means that either the\n"
129 "server administrator has changed the host key, or you\n"
130 "have actually connected to another computer pretending\n"
131 "to be the server.\n"
132 "The new key fingerprint is:\n"
134 "If you were expecting this change and trust the new key,\n"
135 "enter \"y\" to update PuTTY's cache and continue connecting.\n"
136 "If you want to carry on connecting but without updating\n"
137 "the cache, enter \"n\".\n"
138 "If you want to abandon the connection completely, press\n"
139 "Return to cancel. Pressing Return is the ONLY guaranteed\n"
141 "Update cached key? (y/n, Return cancels connection) ";
143 static const char abandoned
[] = "Connection abandoned.\n";
148 * Verify the key against the registry.
150 ret
= verify_host_key(host
, port
, keytype
, keystr
);
152 if (ret
== 0) /* success - key matched OK */
155 if (ret
== 2) { /* key was different */
156 fprintf(stderr
, wrongmsg
, fingerprint
);
159 if (ret
== 1) { /* key was absent */
160 fprintf(stderr
, absentmsg
, fingerprint
);
164 hin
= GetStdHandle(STD_INPUT_HANDLE
);
165 GetConsoleMode(hin
, &savemode
);
166 SetConsoleMode(hin
, (savemode
| ENABLE_ECHO_INPUT
|
167 ENABLE_PROCESSED_INPUT
| ENABLE_LINE_INPUT
));
168 ReadFile(hin
, line
, sizeof(line
) - 1, &i
, NULL
);
169 SetConsoleMode(hin
, savemode
);
171 if (line
[0] != '\0' && line
[0] != '\r' && line
[0] != '\n') {
172 if (line
[0] == 'y' || line
[0] == 'Y')
173 store_host_key(host
, port
, keytype
, keystr
);
175 fprintf(stderr
, abandoned
);
181 * Ask whether the selected cipher is acceptable (since it was
182 * below the configured 'warn' threshold).
183 * cs: 0 = both ways, 1 = client->server, 2 = server->client
185 void askcipher(char *ciphername
, int cs
)
190 static const char msg
[] =
191 "The first %scipher supported by the server is\n"
192 "%s, which is below the configured warning threshold.\n"
193 "Continue with connection? (y/n) ";
194 static const char abandoned
[] = "Connection abandoned.\n";
200 (cs
== 1) ?
"client-to-server " :
205 hin
= GetStdHandle(STD_INPUT_HANDLE
);
206 GetConsoleMode(hin
, &savemode
);
207 SetConsoleMode(hin
, (savemode
| ENABLE_ECHO_INPUT
|
208 ENABLE_PROCESSED_INPUT
| ENABLE_LINE_INPUT
));
209 ReadFile(hin
, line
, sizeof(line
) - 1, &i
, NULL
);
210 SetConsoleMode(hin
, savemode
);
212 if (line
[0] == 'y' || line
[0] == 'Y') {
215 fprintf(stderr
, abandoned
);
220 /* GUI Adaptation - Sept 2000 */
221 static void send_msg(HWND h
, UINT message
, WPARAM wParam
)
223 while (!PostMessage(h
, message
, wParam
, 0))
227 static void tell_char(FILE * stream
, char c
)
232 unsigned int msg_id
= WM_STD_OUT_CHAR
;
233 if (stream
== stderr
)
234 msg_id
= WM_STD_ERR_CHAR
;
235 send_msg((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) c
);
239 static void tell_str(FILE * stream
, char *str
)
243 for (i
= 0; i
< strlen(str
); ++i
)
244 tell_char(stream
, str
[i
]);
247 static void tell_user(FILE * stream
, char *fmt
, ...)
249 char str
[0x100]; /* Make the size big enough */
252 vsprintf(str
, fmt
, ap
);
255 tell_str(stream
, str
);
258 static void gui_update_stats(char *name
, unsigned long size
,
259 int percentage
, unsigned long elapsed
)
263 if (strcmp(name
, statname
) != 0) {
264 for (i
= 0; i
< strlen(name
); ++i
)
265 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_CHAR
,
267 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_CHAR
, (WPARAM
) '\n');
268 strcpy(statname
, name
);
270 if (statsize
!= size
) {
271 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_SIZE
, (WPARAM
) size
);
274 if (statelapsed
!= elapsed
) {
275 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_ELAPSED
,
277 statelapsed
= elapsed
;
279 if (statperct
!= percentage
) {
280 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_PERCENT
,
281 (WPARAM
) percentage
);
282 statperct
= percentage
;
287 * Print an error message and perform a fatal exit.
289 void fatalbox(char *fmt
, ...)
291 char str
[0x100]; /* Make the size big enough */
294 strcpy(str
, "Fatal: ");
295 vsprintf(str
+ strlen(str
), fmt
, ap
);
298 tell_str(stderr
, str
);
302 unsigned int msg_id
= WM_RET_ERR_CNT
;
304 msg_id
= WM_LS_RET_ERR_CNT
;
306 ((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) errs
,
307 0 /*lParam */ ))SleepEx(1000, TRUE
);
312 void connection_fatal(char *fmt
, ...)
314 char str
[0x100]; /* Make the size big enough */
317 strcpy(str
, "Fatal: ");
318 vsprintf(str
+ strlen(str
), fmt
, ap
);
321 tell_str(stderr
, str
);
325 unsigned int msg_id
= WM_RET_ERR_CNT
;
327 msg_id
= WM_LS_RET_ERR_CNT
;
329 ((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) errs
,
330 0 /*lParam */ ))SleepEx(1000, TRUE
);
337 * Be told what socket we're supposed to be using.
339 static SOCKET scp_ssh_socket
;
340 char *do_select(SOCKET skt
, int startup
)
343 scp_ssh_socket
= skt
;
345 scp_ssh_socket
= INVALID_SOCKET
;
348 extern int select_result(WPARAM
, LPARAM
);
351 * Receive a block of data from the SSH link. Block until all data
354 * To do this, we repeatedly call the SSH protocol module, with our
355 * own trap in from_backend() to catch the data that comes back. We
356 * do this until we have enough data.
359 static unsigned char *outptr
; /* where to put the data */
360 static unsigned outlen
; /* how much data required */
361 static unsigned char *pending
= NULL
; /* any spare data */
362 static unsigned pendlen
= 0, pendsize
= 0; /* length and phys. size of buffer */
363 int from_backend(int is_stderr
, char *data
, int datalen
)
365 unsigned char *p
= (unsigned char *) data
;
366 unsigned len
= (unsigned) datalen
;
369 * stderr data is just spouted to local stderr and otherwise
373 fwrite(data
, 1, len
, stderr
);
380 * If this is before the real session begins, just return.
386 unsigned used
= outlen
;
389 memcpy(outptr
, p
, used
);
397 if (pendsize
< pendlen
+ len
) {
398 pendsize
= pendlen
+ len
+ 4096;
399 pending
= (pending ?
srealloc(pending
, pendsize
) :
402 fatalbox("Out of memory");
404 memcpy(pending
+ pendlen
, p
, len
);
410 static int scp_process_network_event(void)
415 FD_SET(scp_ssh_socket
, &readfds
);
416 if (select(1, &readfds
, NULL
, NULL
, NULL
) < 0)
418 select_result((WPARAM
) scp_ssh_socket
, (LPARAM
) FD_READ
);
421 static int ssh_scp_recv(unsigned char *buf
, int len
)
427 * See if the pending-input block contains some of what we
431 unsigned pendused
= pendlen
;
432 if (pendused
> outlen
)
434 memcpy(outptr
, pending
, pendused
);
435 memmove(pending
, pending
+ pendused
, pendlen
- pendused
);
449 if (!scp_process_network_event())
457 * Loop through the ssh connection and authentication process.
459 static void ssh_scp_init(void)
461 if (scp_ssh_socket
== INVALID_SOCKET
)
463 while (!back
->sendok()) {
466 FD_SET(scp_ssh_socket
, &readfds
);
467 if (select(1, &readfds
, NULL
, NULL
, NULL
) < 0)
469 select_result((WPARAM
) scp_ssh_socket
, (LPARAM
) FD_READ
);
471 using_sftp
= !ssh_fallback_cmd
;
475 * Print an error message and exit after closing the SSH link.
477 static void bump(char *fmt
, ...)
479 char str
[0x100]; /* Make the size big enough */
482 strcpy(str
, "Fatal: ");
483 vsprintf(str
+ strlen(str
), fmt
, ap
);
486 tell_str(stderr
, str
);
489 if (back
!= NULL
&& back
->socket() != NULL
) {
491 back
->special(TS_EOF
);
492 ssh_scp_recv(&ch
, 1);
496 unsigned int msg_id
= WM_RET_ERR_CNT
;
498 msg_id
= WM_LS_RET_ERR_CNT
;
500 ((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) errs
,
501 0 /*lParam */ ))SleepEx(1000, TRUE
);
507 static int get_line(const char *prompt
, char *str
, int maxlen
, int is_pw
)
510 DWORD savemode
, newmode
, i
;
512 if (is_pw
&& password
) {
513 static int tried_once
= 0;
518 strncpy(str
, password
, maxlen
);
519 str
[maxlen
- 1] = '\0';
525 /* GUI Adaptation - Sept 2000 */
530 hin
= GetStdHandle(STD_INPUT_HANDLE
);
531 hout
= GetStdHandle(STD_OUTPUT_HANDLE
);
532 if (hin
== INVALID_HANDLE_VALUE
|| hout
== INVALID_HANDLE_VALUE
)
533 bump("Cannot get standard input/output handles");
535 GetConsoleMode(hin
, &savemode
);
536 newmode
= savemode
| ENABLE_PROCESSED_INPUT
| ENABLE_LINE_INPUT
;
538 newmode
&= ~ENABLE_ECHO_INPUT
;
540 newmode
|= ENABLE_ECHO_INPUT
;
541 SetConsoleMode(hin
, newmode
);
543 WriteFile(hout
, prompt
, strlen(prompt
), &i
, NULL
);
544 ReadFile(hin
, str
, maxlen
- 1, &i
, NULL
);
546 SetConsoleMode(hin
, savemode
);
548 if ((int) i
> maxlen
)
555 WriteFile(hout
, "\r\n", 2, &i
, NULL
);
562 * Open an SSH connection to user@host and execute cmd.
564 static void do_cmd(char *host
, char *user
, char *cmd
)
566 char *err
, *realhost
;
569 if (host
== NULL
|| host
[0] == '\0')
570 bump("Empty host name");
572 /* Try to load settings for this host */
573 do_defaults(host
, &cfg
);
574 if (cfg
.host
[0] == '\0') {
575 /* No settings for this host; use defaults */
576 do_defaults(NULL
, &cfg
);
577 strncpy(cfg
.host
, host
, sizeof(cfg
.host
) - 1);
578 cfg
.host
[sizeof(cfg
.host
) - 1] = '\0';
583 if (user
!= NULL
&& user
[0] != '\0') {
584 strncpy(cfg
.username
, user
, sizeof(cfg
.username
) - 1);
585 cfg
.username
[sizeof(cfg
.username
) - 1] = '\0';
586 } else if (cfg
.username
[0] == '\0') {
588 if (GetUserName(user
, &namelen
) == FALSE
)
589 bump("Empty user name");
590 user
= smalloc(namelen
* sizeof(char));
591 GetUserName(user
, &namelen
);
593 tell_user(stderr
, "Guessing user name: %s", user
);
594 strncpy(cfg
.username
, user
, sizeof(cfg
.username
) - 1);
595 cfg
.username
[sizeof(cfg
.username
) - 1] = '\0';
599 if (cfg
.protocol
!= PROT_SSH
)
603 cfg
.port
= portnumber
;
606 * Attempt to start the SFTP subsystem as a first choice,
607 * falling back to the provided scp command if that fails.
609 strcpy(cfg
.remote_cmd
, "sftp");
610 cfg
.ssh_subsys
= TRUE
;
611 cfg
.remote_cmd_ptr2
= cmd
;
612 cfg
.ssh_subsys2
= FALSE
;
617 err
= back
->init(cfg
.host
, cfg
.port
, &realhost
);
619 bump("ssh_init: %s", err
);
621 if (verbose
&& realhost
!= NULL
)
622 tell_user(stderr
, "Connected to %s\n", realhost
);
627 * Update statistic information about current file.
629 static void print_stats(char *name
, unsigned long size
, unsigned long done
,
630 time_t start
, time_t now
)
638 /* GUI Adaptation - Sept 2000 */
640 gui_update_stats(name
, size
, (int) (100 * (done
* 1.0 / size
)),
641 (unsigned long) difftime(now
, start
));
644 ratebs
= (float) done
/ (now
- start
);
646 ratebs
= (float) done
;
651 eta
= (unsigned long) ((size
- done
) / ratebs
);
652 sprintf(etastr
, "%02ld:%02ld:%02ld",
653 eta
/ 3600, (eta
% 3600) / 60, eta
% 60);
655 pct
= (int) (100.0 * (float) done
/ size
);
657 len
= printf("\r%-25.25s | %10ld kB | %5.1f kB/s | ETA: %8s | %3d%%",
658 name
, done
/ 1024, ratebs
/ 1024.0, etastr
, pct
);
659 if (len
< prev_stats_len
)
660 printf("%*s", prev_stats_len
- len
, "");
661 prev_stats_len
= len
;
669 * Find a colon in str and return a pointer to the colon.
670 * This is used to separate hostname from filename.
672 static char *colon(char *str
)
674 /* We ignore a leading colon, since the hostname cannot be
675 empty. We also ignore a colon as second character because
676 of filenames like f:myfile.txt. */
677 if (str
[0] == '\0' || str
[0] == ':' || str
[1] == ':')
679 while (*str
!= '\0' && *str
!= ':' && *str
!= '/' && *str
!= '\\')
688 * Return a pointer to the portion of str that comes after the last
689 * slash (or backslash, if `local' is TRUE).
691 static char *stripslashes(char *str
, int local
)
695 p
= strrchr(str
, '/');
699 p
= strrchr(str
, '\\');
707 * Determine whether a string is entirely composed of dots.
709 static int is_dots(char *str
)
711 return str
[strspn(str
, ".")] == '\0';
715 * Wait for a response from the other side.
716 * Return 0 if ok, -1 if error.
718 static int response(void)
720 char ch
, resp
, rbuf
[2048];
723 if (ssh_scp_recv(&resp
, 1) <= 0)
724 bump("Lost connection");
734 case 2: /* fatal error */
736 if (ssh_scp_recv(&ch
, 1) <= 0)
737 bump("Protocol error: Lost connection");
739 } while (p
< sizeof(rbuf
) && ch
!= '\n');
742 tell_user(stderr
, "%s\n", rbuf
);
750 int sftp_recvdata(char *buf
, int len
)
752 return ssh_scp_recv(buf
, len
);
754 int sftp_senddata(char *buf
, int len
)
756 back
->send((unsigned char *) buf
, len
);
760 /* ----------------------------------------------------------------------
761 * sftp-based replacement for the hacky `pscp -ls'.
763 static int sftp_ls_compare(const void *av
, const void *bv
)
765 const struct fxp_name
*a
= (const struct fxp_name
*) av
;
766 const struct fxp_name
*b
= (const struct fxp_name
*) bv
;
767 return strcmp(a
->filename
, b
->filename
);
769 void scp_sftp_listdir(char *dirname
)
771 struct fxp_handle
*dirh
;
772 struct fxp_names
*names
;
773 struct fxp_name
*ournames
;
774 int nnames
, namesize
;
777 printf("Listing directory %s\n", dirname
);
779 dirh
= fxp_opendir(dirname
);
781 printf("Unable to open %s: %s\n", dirname
, fxp_error());
783 nnames
= namesize
= 0;
788 names
= fxp_readdir(dirh
);
790 if (fxp_error_type() == SSH_FX_EOF
)
792 printf("Reading directory %s: %s\n", dirname
, fxp_error());
795 if (names
->nnames
== 0) {
796 fxp_free_names(names
);
800 if (nnames
+ names
->nnames
>= namesize
) {
801 namesize
+= names
->nnames
+ 128;
803 srealloc(ournames
, namesize
* sizeof(*ournames
));
806 for (i
= 0; i
< names
->nnames
; i
++)
807 ournames
[nnames
++] = names
->names
[i
];
809 names
->nnames
= 0; /* prevent free_names */
810 fxp_free_names(names
);
815 * Now we have our filenames. Sort them by actual file
816 * name, and then output the longname parts.
818 qsort(ournames
, nnames
, sizeof(*ournames
), sftp_ls_compare
);
823 for (i
= 0; i
< nnames
; i
++)
824 printf("%s\n", ournames
[i
].longname
);
828 /* ----------------------------------------------------------------------
829 * Helper routines that contain the actual SCP protocol elements,
830 * implemented both as SCP1 and SFTP.
833 static struct scp_sftp_dirstack
{
834 struct scp_sftp_dirstack
*next
;
835 struct fxp_name
*names
;
836 int namepos
, namelen
;
839 } *scp_sftp_dirstack_head
;
840 static char *scp_sftp_remotepath
, *scp_sftp_currentname
;
841 static char *scp_sftp_wildcard
;
842 static int scp_sftp_targetisdir
, scp_sftp_donethistarget
;
843 static int scp_sftp_preserve
, scp_sftp_recursive
;
844 static unsigned long scp_sftp_mtime
, scp_sftp_atime
;
845 static int scp_has_times
;
846 static struct fxp_handle
*scp_sftp_filehandle
;
847 static uint64 scp_sftp_fileoffset
;
849 void scp_source_setup(char *target
, int shouldbedir
)
853 * Find out whether the target filespec is in fact a
856 struct fxp_attrs attrs
;
858 if (!fxp_stat(target
, &attrs
) ||
859 !(attrs
.flags
& SSH_FILEXFER_ATTR_PERMISSIONS
))
860 scp_sftp_targetisdir
= 0;
862 scp_sftp_targetisdir
= (attrs
.permissions
& 0040000) != 0;
864 if (shouldbedir
&& !scp_sftp_targetisdir
) {
865 bump("pscp: remote filespec %s: not a directory\n", target
);
868 scp_sftp_remotepath
= dupstr(target
);
876 int scp_send_errmsg(char *str
)
879 /* do nothing; we never need to send our errors to the server */
881 back
->send("\001", 1); /* scp protocol error prefix */
882 back
->send(str
, strlen(str
));
884 return 0; /* can't fail */
887 int scp_send_filetimes(unsigned long mtime
, unsigned long atime
)
890 scp_sftp_mtime
= mtime
;
891 scp_sftp_atime
= atime
;
896 sprintf(buf
, "T%lu 0 %lu 0\n", mtime
, atime
);
897 back
->send(buf
, strlen(buf
));
902 int scp_send_filename(char *name
, unsigned long size
, int modes
)
906 if (scp_sftp_targetisdir
) {
907 fullname
= dupcat(scp_sftp_remotepath
, "/", name
, NULL
);
909 fullname
= dupstr(scp_sftp_remotepath
);
911 scp_sftp_filehandle
=
912 fxp_open(fullname
, SSH_FXF_WRITE
| SSH_FXF_CREAT
| SSH_FXF_TRUNC
);
913 if (!scp_sftp_filehandle
) {
914 tell_user(stderr
, "pscp: unable to open %s: %s",
915 fullname
, fxp_error());
919 scp_sftp_fileoffset
= uint64_make(0, 0);
924 sprintf(buf
, "C%04o %lu ", modes
, size
);
925 back
->send(buf
, strlen(buf
));
926 back
->send(name
, strlen(name
));
932 int scp_send_filedata(char *data
, int len
)
935 if (!scp_sftp_filehandle
) {
938 if (!fxp_write(scp_sftp_filehandle
, data
, scp_sftp_fileoffset
, len
)) {
939 tell_user(stderr
, "error while writing: %s\n", fxp_error());
943 scp_sftp_fileoffset
= uint64_add32(scp_sftp_fileoffset
, len
);
946 int bufsize
= back
->send(data
, len
);
949 * If the network transfer is backing up - that is, the
950 * remote site is not accepting data as fast as we can
951 * produce it - then we must loop on network events until
952 * we have space in the buffer again.
954 while (bufsize
> MAX_SCP_BUFSIZE
) {
955 if (!scp_process_network_event())
957 bufsize
= back
->sendbuffer();
964 int scp_send_finish(void)
967 struct fxp_attrs attrs
;
968 if (!scp_sftp_filehandle
) {
972 attrs
.flags
= SSH_FILEXFER_ATTR_ACMODTIME
;
973 attrs
.atime
= scp_sftp_atime
;
974 attrs
.mtime
= scp_sftp_mtime
;
975 if (!fxp_fsetstat(scp_sftp_filehandle
, attrs
)) {
976 tell_user(stderr
, "unable to set file times: %s\n", fxp_error());
980 fxp_close(scp_sftp_filehandle
);
989 char *scp_save_remotepath(void)
992 return scp_sftp_remotepath
;
997 void scp_restore_remotepath(char *data
)
1000 scp_sftp_remotepath
= data
;
1003 int scp_send_dirname(char *name
, int modes
)
1008 struct fxp_attrs attrs
;
1009 if (scp_sftp_targetisdir
) {
1010 fullname
= dupcat(scp_sftp_remotepath
, "/", name
, NULL
);
1012 fullname
= dupstr(scp_sftp_remotepath
);
1016 * We don't worry about whether we managed to create the
1017 * directory, because if it exists already it's OK just to
1018 * use it. Instead, we will stat it afterwards, and if it
1019 * exists and is a directory we will assume we were either
1020 * successful or it didn't matter.
1022 if (!fxp_mkdir(fullname
))
1025 err
= "server reported no error";
1026 if (!fxp_stat(fullname
, &attrs
) ||
1027 !(attrs
.flags
& SSH_FILEXFER_ATTR_PERMISSIONS
) ||
1028 !(attrs
.permissions
& 0040000)) {
1029 tell_user(stderr
, "unable to create directory %s: %s",
1035 scp_sftp_remotepath
= fullname
;
1040 sprintf(buf
, "D%04o 0 ", modes
);
1041 back
->send(buf
, strlen(buf
));
1042 back
->send(name
, strlen(name
));
1043 back
->send("\n", 1);
1048 int scp_send_enddir(void)
1051 sfree(scp_sftp_remotepath
);
1054 back
->send("E\n", 2);
1060 * Yes, I know; I have an scp_sink_setup _and_ an scp_sink_init.
1061 * That's bad. The difference is that scp_sink_setup is called once
1062 * right at the start, whereas scp_sink_init is called to
1063 * initialise every level of recursion in the protocol.
1065 int scp_sink_setup(char *source
, int preserve
, int recursive
)
1070 * It's possible that the source string we've been given
1071 * contains a wildcard. If so, we must split the directory
1072 * away from the wildcard itself (throwing an error if any
1073 * wildcardness comes before the final slash) and arrange
1074 * things so that a dirstack entry will be set up.
1076 newsource
= smalloc(1+strlen(source
));
1077 if (!wc_unescape(newsource
, source
)) {
1078 /* Yes, here we go; it's a wildcard. Bah. */
1079 char *dupsource
, *lastpart
, *dirpart
, *wildcard
;
1080 dupsource
= dupstr(source
);
1081 lastpart
= stripslashes(dupsource
, 0);
1082 wildcard
= dupstr(lastpart
);
1084 if (*dupsource
&& dupsource
[1]) {
1086 * The remains of dupsource are at least two
1087 * characters long, meaning the pathname wasn't
1088 * empty or just `/'. Hence, we remove the trailing
1091 lastpart
[-1] = '\0';
1092 } else if (!*dupsource
) {
1094 * The remains of dupsource are _empty_ - the whole
1095 * pathname was a wildcard. Hence we need to
1096 * replace it with ".".
1099 dupsource
= dupstr(".");
1103 * Now we have separated our string into dupsource (the
1104 * directory part) and wildcard. Both of these will
1105 * need freeing at some point. Next step is to remove
1106 * wildcard escapes from the directory part, throwing
1107 * an error if it contains a real wildcard.
1109 dirpart
= smalloc(1+strlen(dupsource
));
1110 if (!wc_unescape(dirpart
, dupsource
)) {
1111 tell_user(stderr
, "%s: multiple-level wildcards unsupported",
1121 * Now we have dirpart (unescaped, ie a valid remote
1122 * path), and wildcard (a wildcard). This will be
1123 * sufficient to arrange a dirstack entry.
1125 scp_sftp_remotepath
= dirpart
;
1126 scp_sftp_wildcard
= wildcard
;
1129 scp_sftp_remotepath
= newsource
;
1130 scp_sftp_wildcard
= NULL
;
1132 scp_sftp_preserve
= preserve
;
1133 scp_sftp_recursive
= recursive
;
1134 scp_sftp_donethistarget
= 0;
1135 scp_sftp_dirstack_head
= NULL
;
1140 int scp_sink_init(void)
1148 #define SCP_SINK_FILE 1
1149 #define SCP_SINK_DIR 2
1150 #define SCP_SINK_ENDDIR 3
1151 #define SCP_SINK_RETRY 4 /* not an action; just try again */
1152 struct scp_sink_action
{
1153 int action
; /* FILE, DIR, ENDDIR */
1154 char *buf
; /* will need freeing after use */
1155 char *name
; /* filename or dirname (not ENDDIR) */
1156 int mode
; /* access mode (not ENDDIR) */
1157 unsigned long size
; /* file size (not ENDDIR) */
1158 int settime
; /* 1 if atime and mtime are filled */
1159 unsigned long atime
, mtime
; /* access times for the file */
1162 int scp_get_sink_action(struct scp_sink_action
*act
)
1166 int must_free_fname
;
1167 struct fxp_attrs attrs
;
1170 if (!scp_sftp_dirstack_head
) {
1171 if (!scp_sftp_donethistarget
) {
1173 * Simple case: we are only dealing with one file.
1175 fname
= scp_sftp_remotepath
;
1176 must_free_fname
= 0;
1177 scp_sftp_donethistarget
= 1;
1180 * Even simpler case: one file _which we've done_.
1181 * Return 1 (finished).
1187 * We're now in the middle of stepping through a list
1188 * of names returned from fxp_readdir(); so let's carry
1191 struct scp_sftp_dirstack
*head
= scp_sftp_dirstack_head
;
1192 while (head
->namepos
< head
->namelen
&&
1193 (is_dots(head
->names
[head
->namepos
].filename
) ||
1195 !wc_match(head
->wildcard
,
1196 head
->names
[head
->namepos
].filename
))))
1197 head
->namepos
++; /* skip . and .. */
1198 if (head
->namepos
< head
->namelen
) {
1199 fname
= dupcat(head
->dirpath
, "/",
1200 head
->names
[head
->namepos
++].filename
,
1202 must_free_fname
= 1;
1205 * We've come to the end of the list; pop it off
1206 * the stack and return an ENDDIR action (or RETRY
1207 * if this was a wildcard match).
1209 if (head
->wildcard
) {
1210 act
->action
= SCP_SINK_RETRY
;
1211 sfree(head
->wildcard
);
1213 act
->action
= SCP_SINK_ENDDIR
;
1216 sfree(head
->dirpath
);
1218 scp_sftp_dirstack_head
= head
->next
;
1226 * Now we have a filename. Stat it, and see if it's a file
1229 ret
= fxp_stat(fname
, &attrs
);
1230 if (!ret
|| !(attrs
.flags
& SSH_FILEXFER_ATTR_PERMISSIONS
)) {
1231 tell_user(stderr
, "unable to identify %s: %s", fname
,
1232 ret ?
"file type not supplied" : fxp_error());
1237 if (attrs
.permissions
& 0040000) {
1238 struct scp_sftp_dirstack
*newitem
;
1239 struct fxp_handle
*dirhandle
;
1240 int nnames
, namesize
;
1241 struct fxp_name
*ournames
;
1242 struct fxp_names
*names
;
1245 * It's a directory. If we're not in recursive mode,
1246 * this merits a complaint (which is fatal if the name
1247 * was specified directly, but not if it was matched by
1250 * We skip this complaint completely if
1251 * scp_sftp_wildcard is set, because that's an
1252 * indication that we're not actually supposed to
1253 * _recursively_ transfer the dir, just scan it for
1254 * things matching the wildcard.
1256 if (!scp_sftp_recursive
&& !scp_sftp_wildcard
) {
1257 tell_user(stderr
, "pscp: %s: is a directory", fname
);
1259 if (must_free_fname
) sfree(fname
);
1260 if (scp_sftp_dirstack_head
) {
1261 act
->action
= SCP_SINK_RETRY
;
1269 * Otherwise, the fun begins. We must fxp_opendir() the
1270 * directory, slurp the filenames into memory, return
1271 * SCP_SINK_DIR (unless this is a wildcard match), and
1272 * set targetisdir. The next time we're called, we will
1273 * run through the list of filenames one by one,
1274 * matching them against a wildcard if present.
1276 * If targetisdir is _already_ set (meaning we're
1277 * already in the middle of going through another such
1278 * list), we must push the other (target,namelist) pair
1281 dirhandle
= fxp_opendir(fname
);
1283 tell_user(stderr
, "scp: unable to open directory %s: %s",
1284 fname
, fxp_error());
1285 if (must_free_fname
) sfree(fname
);
1289 nnames
= namesize
= 0;
1294 names
= fxp_readdir(dirhandle
);
1295 if (names
== NULL
) {
1296 if (fxp_error_type() == SSH_FX_EOF
)
1298 tell_user(stderr
, "scp: reading directory %s: %s\n",
1299 fname
, fxp_error());
1300 if (must_free_fname
) sfree(fname
);
1305 if (names
->nnames
== 0) {
1306 fxp_free_names(names
);
1309 if (nnames
+ names
->nnames
>= namesize
) {
1310 namesize
+= names
->nnames
+ 128;
1312 srealloc(ournames
, namesize
* sizeof(*ournames
));
1314 for (i
= 0; i
< names
->nnames
; i
++)
1315 ournames
[nnames
++] = names
->names
[i
];
1316 names
->nnames
= 0; /* prevent free_names */
1317 fxp_free_names(names
);
1319 fxp_close(dirhandle
);
1321 newitem
= smalloc(sizeof(struct scp_sftp_dirstack
));
1322 newitem
->next
= scp_sftp_dirstack_head
;
1323 newitem
->names
= ournames
;
1324 newitem
->namepos
= 0;
1325 newitem
->namelen
= nnames
;
1326 if (must_free_fname
)
1327 newitem
->dirpath
= fname
;
1329 newitem
->dirpath
= dupstr(fname
);
1330 if (scp_sftp_wildcard
) {
1331 newitem
->wildcard
= scp_sftp_wildcard
;
1332 scp_sftp_wildcard
= NULL
;
1334 newitem
->wildcard
= NULL
;
1336 scp_sftp_dirstack_head
= newitem
;
1338 if (newitem
->wildcard
) {
1339 act
->action
= SCP_SINK_RETRY
;
1341 act
->action
= SCP_SINK_DIR
;
1342 act
->buf
= dupstr(stripslashes(fname
, 0));
1343 act
->name
= act
->buf
;
1344 act
->size
= 0; /* duhh, it's a directory */
1345 act
->mode
= 07777 & attrs
.permissions
;
1346 if (scp_sftp_preserve
&&
1347 (attrs
.flags
& SSH_FILEXFER_ATTR_ACMODTIME
)) {
1348 act
->atime
= attrs
.atime
;
1349 act
->mtime
= attrs
.mtime
;
1358 * It's a file. Return SCP_SINK_FILE.
1360 act
->action
= SCP_SINK_FILE
;
1361 act
->buf
= dupstr(stripslashes(fname
, 0));
1362 act
->name
= act
->buf
;
1363 if (attrs
.flags
& SSH_FILEXFER_ATTR_SIZE
) {
1364 if (uint64_compare(attrs
.size
,
1365 uint64_make(0, ULONG_MAX
)) > 0) {
1366 act
->size
= ULONG_MAX
; /* *boggle* */
1368 act
->size
= attrs
.size
.lo
;
1370 act
->size
= ULONG_MAX
; /* no idea */
1371 act
->mode
= 07777 & attrs
.permissions
;
1372 if (scp_sftp_preserve
&&
1373 (attrs
.flags
& SSH_FILEXFER_ATTR_ACMODTIME
)) {
1374 act
->atime
= attrs
.atime
;
1375 act
->mtime
= attrs
.mtime
;
1379 if (must_free_fname
)
1380 scp_sftp_currentname
= fname
;
1382 scp_sftp_currentname
= dupstr(fname
);
1397 if (ssh_scp_recv(&ch
, 1) <= 0)
1400 bump("Protocol error: Unexpected newline");
1404 if (ssh_scp_recv(&ch
, 1) <= 0)
1405 bump("Lost connection");
1408 act
->buf
= srealloc(act
->buf
, bufsize
);
1411 } while (ch
!= '\n');
1412 act
->buf
[i
- 1] = '\0';
1414 case '\01': /* error */
1415 tell_user(stderr
, "%s\n", act
->buf
);
1417 continue; /* go round again */
1418 case '\02': /* fatal error */
1419 bump("%s", act
->buf
);
1422 act
->action
= SCP_SINK_ENDDIR
;
1425 if (sscanf(act
->buf
, "%ld %*d %ld %*d",
1426 &act
->mtime
, &act
->atime
) == 2) {
1429 continue; /* go round again */
1431 bump("Protocol error: Illegal time format");
1434 act
->action
= (action
== 'C' ? SCP_SINK_FILE
: SCP_SINK_DIR
);
1437 bump("Protocol error: Expected control record");
1440 * We will go round this loop only once, unless we hit
1447 * If we get here, we must have seen SCP_SINK_FILE or
1450 if (sscanf(act
->buf
, "%o %lu %n", &act
->mode
, &act
->size
, &i
) != 2)
1451 bump("Protocol error: Illegal file descriptor format");
1452 act
->name
= act
->buf
+ i
;
1457 int scp_accept_filexfer(void)
1460 scp_sftp_filehandle
=
1461 fxp_open(scp_sftp_currentname
, SSH_FXF_READ
);
1462 if (!scp_sftp_filehandle
) {
1463 tell_user(stderr
, "pscp: unable to open %s: %s",
1464 scp_sftp_currentname
, fxp_error());
1468 scp_sftp_fileoffset
= uint64_make(0, 0);
1469 sfree(scp_sftp_currentname
);
1473 return 0; /* can't fail */
1477 int scp_recv_filedata(char *data
, int len
)
1480 int actuallen
= fxp_read(scp_sftp_filehandle
, data
,
1481 scp_sftp_fileoffset
, len
);
1482 if (actuallen
== -1 && fxp_error_type() != SSH_FX_EOF
) {
1483 tell_user(stderr
, "pscp: error while reading: %s", fxp_error());
1490 scp_sftp_fileoffset
= uint64_add32(scp_sftp_fileoffset
, actuallen
);
1494 return ssh_scp_recv(data
, len
);
1498 int scp_finish_filerecv(void)
1501 fxp_close(scp_sftp_filehandle
);
1509 /* ----------------------------------------------------------------------
1510 * Send an error message to the other side and to the screen.
1511 * Increment error counter.
1513 static void run_err(const char *fmt
, ...)
1519 strcpy(str
, "scp: ");
1520 vsprintf(str
+ strlen(str
), fmt
, ap
);
1522 scp_send_errmsg(str
);
1523 tell_user(stderr
, "%s", str
);
1528 * Execute the source part of the SCP protocol.
1530 static void source(char *src
)
1537 unsigned long stat_bytes
;
1538 time_t stat_starttime
, stat_lasttime
;
1540 attr
= GetFileAttributes(src
);
1541 if (attr
== (DWORD
) - 1) {
1542 run_err("%s: No such file or directory", src
);
1546 if ((attr
& FILE_ATTRIBUTE_DIRECTORY
) != 0) {
1549 * Avoid . and .. directories.
1552 p
= strrchr(src
, '/');
1554 p
= strrchr(src
, '\\');
1559 if (!strcmp(p
, ".") || !strcmp(p
, ".."))
1560 /* skip . and .. */ ;
1564 run_err("%s: not a regular file", src
);
1569 if ((last
= strrchr(src
, '/')) == NULL
)
1573 if (strrchr(last
, '\\') != NULL
)
1574 last
= strrchr(last
, '\\') + 1;
1575 if (last
== src
&& strchr(src
, ':') != NULL
)
1576 last
= strchr(src
, ':') + 1;
1578 f
= CreateFile(src
, GENERIC_READ
, FILE_SHARE_READ
, NULL
,
1579 OPEN_EXISTING
, 0, 0);
1580 if (f
== INVALID_HANDLE_VALUE
) {
1581 run_err("%s: Cannot open file", src
);
1586 FILETIME actime
, wrtime
;
1587 unsigned long mtime
, atime
;
1588 GetFileTime(f
, NULL
, &actime
, &wrtime
);
1589 TIME_WIN_TO_POSIX(actime
, atime
);
1590 TIME_WIN_TO_POSIX(wrtime
, mtime
);
1591 if (scp_send_filetimes(mtime
, atime
))
1595 size
= GetFileSize(f
, NULL
);
1597 tell_user(stderr
, "Sending file %s, size=%lu", last
, size
);
1598 if (scp_send_filename(last
, size
, 0644))
1602 stat_starttime
= time(NULL
);
1605 for (i
= 0; i
< size
; i
+= 4096) {
1606 char transbuf
[4096];
1611 if (!ReadFile(f
, transbuf
, k
, &j
, NULL
) || j
!= k
) {
1614 bump("%s: Read error", src
);
1616 if (scp_send_filedata(transbuf
, k
))
1617 bump("%s: Network error occurred", src
);
1621 if (time(NULL
) != stat_lasttime
|| i
+ k
== size
) {
1622 stat_lasttime
= time(NULL
);
1623 print_stats(last
, size
, stat_bytes
,
1624 stat_starttime
, stat_lasttime
);
1631 (void) scp_send_finish();
1635 * Recursively send the contents of a directory.
1637 static void rsource(char *src
)
1639 char *last
, *findfile
;
1642 WIN32_FIND_DATA fdat
;
1645 if ((last
= strrchr(src
, '/')) == NULL
)
1649 if (strrchr(last
, '\\') != NULL
)
1650 last
= strrchr(last
, '\\') + 1;
1651 if (last
== src
&& strchr(src
, ':') != NULL
)
1652 last
= strchr(src
, ':') + 1;
1654 /* maybe send filetime */
1656 save_target
= scp_save_remotepath();
1659 tell_user(stderr
, "Entering directory: %s", last
);
1660 if (scp_send_dirname(last
, 0755))
1663 findfile
= dupcat(src
, "/*", NULL
);
1664 dir
= FindFirstFile(findfile
, &fdat
);
1665 ok
= (dir
!= INVALID_HANDLE_VALUE
);
1667 if (strcmp(fdat
.cFileName
, ".") == 0 ||
1668 strcmp(fdat
.cFileName
, "..") == 0) {
1669 /* ignore . and .. */
1671 char *foundfile
= dupcat(src
, "/", fdat
.cFileName
, NULL
);
1675 ok
= FindNextFile(dir
, &fdat
);
1680 (void) scp_send_enddir();
1682 scp_restore_remotepath(save_target
);
1686 * Execute the sink part of the SCP protocol.
1688 static void sink(char *targ
, char *src
)
1695 unsigned long received
;
1697 unsigned long stat_bytes
;
1698 time_t stat_starttime
, stat_lasttime
;
1701 attr
= GetFileAttributes(targ
);
1702 if (attr
!= (DWORD
) - 1 && (attr
& FILE_ATTRIBUTE_DIRECTORY
) != 0)
1705 if (targetshouldbedirectory
&& !targisdir
)
1706 bump("%s: Not a directory", targ
);
1710 struct scp_sink_action act
;
1711 if (scp_get_sink_action(&act
))
1714 if (act
.action
== SCP_SINK_ENDDIR
)
1717 if (act
.action
== SCP_SINK_RETRY
)
1722 * Prevent the remote side from maliciously writing to
1723 * files outside the target area by sending a filename
1724 * containing `../'. In fact, it shouldn't be sending
1725 * filenames with any slashes in at all; so we'll find
1726 * the last slash or backslash in the filename and use
1727 * only the part after that. (And warn!)
1729 * In addition, we also ensure here that if we're
1730 * copying a single file and the target is a directory
1731 * (common usage: `pscp host:filename .') the remote
1732 * can't send us a _different_ file name. We can
1733 * distinguish this case because `src' will be non-NULL
1734 * and the last component of that will fail to match
1735 * (the last component of) the name sent.
1737 * Well, not always; if `src' is a wildcard, we do
1738 * expect to get back filenames that don't correspond
1739 * exactly to it. Ideally in this case, we would like
1740 * to ensure that the returned filename actually
1741 * matches the wildcard pattern - but one of SCP's
1742 * protocol infelicities is that wildcard matching is
1743 * done at the server end _by the server's rules_ and
1744 * so in general this is infeasible. Hence, we only
1745 * accept filenames that don't correspond to `src' if
1746 * unsafe mode is enabled or we are using SFTP (which
1747 * resolves remote wildcards on the client side and can
1750 char *striptarget
, *stripsrc
;
1752 striptarget
= stripslashes(act
.name
, 1);
1753 if (striptarget
!= act
.name
) {
1754 tell_user(stderr
, "warning: remote host sent a compound"
1755 " pathname - possibly malicious! (ignored)");
1759 * Also check to see if the target filename is '.' or
1760 * '..', or indeed '...' and so on because Windows
1761 * appears to interpret those like '..'.
1763 if (is_dots(striptarget
)) {
1764 bump("security violation: remote host attempted to write to"
1765 " a '.' or '..' path!");
1769 stripsrc
= stripslashes(src
, 1);
1770 if (strcmp(striptarget
, stripsrc
) &&
1771 !using_sftp
&& !scp_unsafe_mode
) {
1772 tell_user(stderr
, "warning: remote host tried to write "
1773 "to a file called '%s'", striptarget
);
1774 tell_user(stderr
, " when we requested a file "
1775 "called '%s'.", stripsrc
);
1776 tell_user(stderr
, " If this is a wildcard, "
1777 "consider upgrading to SSH 2 or using");
1778 tell_user(stderr
, " the '-unsafe' option. Renaming"
1779 " of this file has been disallowed.");
1780 /* Override the name the server provided with our own. */
1781 striptarget
= stripsrc
;
1785 if (targ
[0] != '\0')
1786 destfname
= dupcat(targ
, "\\", striptarget
, NULL
);
1788 destfname
= dupstr(striptarget
);
1791 * In this branch of the if, the target area is a
1792 * single file with an explicitly specified name in any
1793 * case, so there's no danger.
1795 destfname
= dupstr(targ
);
1797 attr
= GetFileAttributes(destfname
);
1798 exists
= (attr
!= (DWORD
) - 1);
1800 if (act
.action
== SCP_SINK_DIR
) {
1801 if (exists
&& (attr
& FILE_ATTRIBUTE_DIRECTORY
) == 0) {
1802 run_err("%s: Not a directory", destfname
);
1806 if (!CreateDirectory(destfname
, NULL
)) {
1807 run_err("%s: Cannot create directory", destfname
);
1811 sink(destfname
, NULL
);
1812 /* can we set the timestamp for directories ? */
1816 f
= CreateFile(destfname
, GENERIC_WRITE
, 0, NULL
,
1817 CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, 0);
1818 if (f
== INVALID_HANDLE_VALUE
) {
1819 run_err("%s: Cannot create file", destfname
);
1823 if (scp_accept_filexfer())
1827 stat_starttime
= time(NULL
);
1829 stat_name
= stripslashes(destfname
, 1);
1832 while (received
< act
.size
) {
1833 char transbuf
[4096];
1834 DWORD blksize
, read
, written
;
1836 if (blksize
> act
.size
- received
)
1837 blksize
= act
.size
- received
;
1838 read
= scp_recv_filedata(transbuf
, blksize
);
1840 bump("Lost connection");
1843 if (!WriteFile(f
, transbuf
, read
, &written
, NULL
) ||
1846 /* FIXME: in sftp we can actually abort the transfer */
1848 printf("\r%-25.25s | %50s\n",
1850 "Write error.. waiting for end of file");
1855 if (time(NULL
) > stat_lasttime
||
1856 received
+ read
== act
.size
) {
1857 stat_lasttime
= time(NULL
);
1858 print_stats(stat_name
, act
.size
, stat_bytes
,
1859 stat_starttime
, stat_lasttime
);
1865 FILETIME actime
, wrtime
;
1866 TIME_POSIX_TO_WIN(act
.atime
, actime
);
1867 TIME_POSIX_TO_WIN(act
.mtime
, wrtime
);
1868 SetFileTime(f
, NULL
, &actime
, &wrtime
);
1873 run_err("%s: Write error", destfname
);
1876 (void) scp_finish_filerecv();
1883 * We will copy local files to a remote server.
1885 static void toremote(int argc
, char *argv
[])
1887 char *src
, *targ
, *host
, *user
;
1891 targ
= argv
[argc
- 1];
1893 /* Separate host from filename */
1897 bump("targ == NULL in toremote()");
1901 /* Substitute "." for emtpy target */
1903 /* Separate host and username */
1905 host
= strrchr(host
, '@');
1916 /* Find out if the source filespec covers multiple files
1917 if so, we should set the targetshouldbedirectory flag */
1919 WIN32_FIND_DATA fdat
;
1920 if (colon(argv
[0]) != NULL
)
1921 bump("%s: Remote to remote not supported", argv
[0]);
1922 fh
= FindFirstFile(argv
[0], &fdat
);
1923 if (fh
== INVALID_HANDLE_VALUE
)
1924 bump("%s: No such file or directory\n", argv
[0]);
1925 if (FindNextFile(fh
, &fdat
))
1926 targetshouldbedirectory
= 1;
1930 cmd
= smalloc(strlen(targ
) + 100);
1931 sprintf(cmd
, "scp%s%s%s%s -t %s",
1932 verbose ?
" -v" : "",
1933 recursive ?
" -r" : "",
1934 preserve ?
" -p" : "",
1935 targetshouldbedirectory ?
" -d" : "", targ
);
1936 do_cmd(host
, user
, cmd
);
1939 scp_source_setup(targ
, targetshouldbedirectory
);
1941 for (i
= 0; i
< argc
- 1; i
++) {
1942 char *srcpath
, *last
;
1944 WIN32_FIND_DATA fdat
;
1946 if (colon(src
) != NULL
) {
1947 tell_user(stderr
, "%s: Remote to remote not supported\n", src
);
1953 * Trim off the last pathname component of `src', to
1954 * provide the base pathname which will be prepended to
1955 * filenames returned from Find{First,Next}File.
1957 srcpath
= dupstr(src
);
1958 last
= stripslashes(srcpath
, 1);
1959 if (last
== srcpath
) {
1960 last
= strchr(srcpath
, ':');
1968 dir
= FindFirstFile(src
, &fdat
);
1969 if (dir
== INVALID_HANDLE_VALUE
) {
1970 run_err("%s: No such file or directory", src
);
1976 * Ensure that . and .. are never matched by wildcards,
1977 * but only by deliberate action.
1979 if (!strcmp(fdat
.cFileName
, ".") ||
1980 !strcmp(fdat
.cFileName
, "..")) {
1982 * Find*File has returned a special dir. We require
1983 * that _either_ `src' ends in a backslash followed
1984 * by that string, _or_ `src' is precisely that
1987 int len
= strlen(src
), dlen
= strlen(fdat
.cFileName
);
1988 if (len
== dlen
&& !strcmp(src
, fdat
.cFileName
)) {
1990 } else if (len
> dlen
+ 1 && src
[len
- dlen
- 1] == '\\' &&
1991 !strcmp(src
+ len
- dlen
, fdat
.cFileName
)) {
1994 continue; /* ignore this one */
1996 filename
= dupcat(srcpath
, fdat
.cFileName
, NULL
);
1999 } while (FindNextFile(dir
, &fdat
));
2006 * We will copy files from a remote server to the local machine.
2008 static void tolocal(int argc
, char *argv
[])
2010 char *src
, *targ
, *host
, *user
;
2014 bump("More than one remote source not supported");
2019 /* Separate host from filename */
2023 bump("Local to local copy not supported");
2027 /* Substitute "." for empty filename */
2029 /* Separate username and hostname */
2031 host
= strrchr(host
, '@');
2041 cmd
= smalloc(strlen(src
) + 100);
2042 sprintf(cmd
, "scp%s%s%s%s -f %s",
2043 verbose ?
" -v" : "",
2044 recursive ?
" -r" : "",
2045 preserve ?
" -p" : "",
2046 targetshouldbedirectory ?
" -d" : "", src
);
2047 do_cmd(host
, user
, cmd
);
2050 if (scp_sink_setup(src
, preserve
, recursive
))
2057 * We will issue a list command to get a remote directory.
2059 static void get_dir_list(int argc
, char *argv
[])
2061 char *src
, *host
, *user
;
2067 /* Separate host from filename */
2071 bump("Local to local copy not supported");
2075 /* Substitute "." for empty filename */
2077 /* Separate username and hostname */
2079 host
= strrchr(host
, '@');
2089 cmd
= smalloc(4 * strlen(src
) + 100);
2090 strcpy(cmd
, "ls -la '");
2091 p
= cmd
+ strlen(cmd
);
2092 for (q
= src
; *q
; q
++) {
2105 do_cmd(host
, user
, cmd
);
2109 scp_sftp_listdir(src
);
2111 while (ssh_scp_recv(&c
, 1) > 0)
2112 tell_char(stdout
, c
);
2117 * Initialize the Win$ock driver.
2119 static void init_winsock(void)
2124 winsock_ver
= MAKEWORD(1, 1);
2125 if (WSAStartup(winsock_ver
, &wsadata
))
2126 bump("Unable to initialise WinSock");
2127 if (LOBYTE(wsadata
.wVersion
) != 1 || HIBYTE(wsadata
.wVersion
) != 1)
2128 bump("WinSock version is incompatible with 1.1");
2132 * Short description of parameters.
2134 static void usage(void)
2136 printf("PuTTY Secure Copy client\n");
2137 printf("%s\n", ver
);
2138 printf("Usage: pscp [options] [user@]host:source target\n");
2140 (" pscp [options] source [source...] [user@]host:target\n");
2141 printf(" pscp [options] -ls user@host:filespec\n");
2142 printf("Options:\n");
2143 printf(" -p preserve file attributes\n");
2144 printf(" -q quiet, don't show statistics\n");
2145 printf(" -r copy directories recursively\n");
2146 printf(" -v show verbose messages\n");
2147 printf(" -P port connect to specified port\n");
2148 printf(" -pw passw login with specified password\n");
2149 printf(" -unsafe allow server-side wildcards (DANGEROUS)\n");
2152 * -gui is an internal option, used by GUI front ends to get
2153 * pscp to pass progress reports back to them. It's not an
2154 * ordinary user-accessible option, so it shouldn't be part of
2155 * the command-line help. The only people who need to know
2156 * about it are programmers, and they can read the source.
2159 (" -gui hWnd GUI mode with the windows handle for receiving messages\n");
2165 * Main program (no, really?)
2167 int main(int argc
, char *argv
[])
2171 default_protocol
= PROT_TELNET
;
2173 flags
= FLAG_STDERR
;
2174 ssh_get_line
= &get_line
;
2178 for (i
= 1; i
< argc
; i
++) {
2179 if (argv
[i
][0] != '-')
2181 if (strcmp(argv
[i
], "-v") == 0)
2182 verbose
= 1, flags
|= FLAG_VERBOSE
;
2183 else if (strcmp(argv
[i
], "-r") == 0)
2185 else if (strcmp(argv
[i
], "-p") == 0)
2187 else if (strcmp(argv
[i
], "-q") == 0)
2189 else if (strcmp(argv
[i
], "-h") == 0 || strcmp(argv
[i
], "-?") == 0)
2191 else if (strcmp(argv
[i
], "-P") == 0 && i
+ 1 < argc
)
2192 portnumber
= atoi(argv
[++i
]);
2193 else if (strcmp(argv
[i
], "-pw") == 0 && i
+ 1 < argc
)
2194 password
= argv
[++i
];
2195 else if (strcmp(argv
[i
], "-gui") == 0 && i
+ 1 < argc
) {
2196 gui_hwnd
= argv
[++i
];
2198 } else if (strcmp(argv
[i
], "-ls") == 0)
2200 else if (strcmp(argv
[i
], "-unsafe") == 0)
2201 scp_unsafe_mode
= 1;
2202 else if (strcmp(argv
[i
], "--") == 0) {
2215 get_dir_list(argc
, argv
);
2222 targetshouldbedirectory
= 1;
2224 if (colon(argv
[argc
- 1]) != NULL
)
2225 toremote(argc
, argv
);
2227 tolocal(argc
, argv
);
2230 if (back
!= NULL
&& back
->socket() != NULL
) {
2232 back
->special(TS_EOF
);
2233 ssh_scp_recv(&ch
, 1);
2238 /* GUI Adaptation - August 2000 */
2240 unsigned int msg_id
= WM_RET_ERR_CNT
;
2242 msg_id
= WM_LS_RET_ERR_CNT
;
2244 ((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) errs
,
2245 0 /*lParam */ ))SleepEx(1000, TRUE
);
2247 return (errs
== 0 ?
0 : 1);