2 * scp.c - Scp (Secure Copy) client for PuTTY.
3 * Joris van Rantwijk, Simon Tatham
5 * This is mainly based on ssh-1.2.26/scp.c by Timo Rinne & Tatu Ylonen.
6 * They, in turn, used stuff from BSD rcp.
8 * (SGT, 2001-09-10: Joris van Rantwijk assures me that although
9 * this file as originally submitted was inspired by, and
10 * _structurally_ based on, ssh-1.2.26's scp.c, there wasn't any
11 * actual code duplicated, so the above comment shouldn't give rise
12 * to licensing issues.)
30 #define PUTTY_DO_GLOBALS
37 #define TIME_POSIX_TO_WIN(t, ft) (*(LONGLONG*)&(ft) = \
38 ((LONGLONG) (t) + (LONGLONG) 11644473600) * (LONGLONG) 10000000)
39 #define TIME_WIN_TO_POSIX(ft, t) ((t) = (unsigned long) \
40 ((*(LONGLONG*)&(ft)) / (LONGLONG) 10000000 - (LONGLONG) 11644473600))
42 /* GUI Adaptation - Sept 2000 */
43 #define WM_APP_BASE 0x8000
44 #define WM_STD_OUT_CHAR ( WM_APP_BASE+400 )
45 #define WM_STD_ERR_CHAR ( WM_APP_BASE+401 )
46 #define WM_STATS_CHAR ( WM_APP_BASE+402 )
47 #define WM_STATS_SIZE ( WM_APP_BASE+403 )
48 #define WM_STATS_PERCENT ( WM_APP_BASE+404 )
49 #define WM_STATS_ELAPSED ( WM_APP_BASE+405 )
50 #define WM_RET_ERR_CNT ( WM_APP_BASE+406 )
51 #define WM_LS_RET_ERR_CNT ( WM_APP_BASE+407 )
54 static int verbose
= 0;
55 static int recursive
= 0;
56 static int preserve
= 0;
57 static int targetshouldbedirectory
= 0;
58 static int statistics
= 1;
59 static int portnumber
= 0;
60 static int prev_stats_len
= 0;
61 static int scp_unsafe_mode
= 0;
62 static char *password
= NULL
;
64 /* GUI Adaptation - Sept 2000 */
65 #define NAME_STR_MAX 2048
66 static char statname
[NAME_STR_MAX
+ 1];
67 static unsigned long statsize
= 0;
68 static int statperct
= 0;
69 static unsigned long statelapsed
= 0;
70 static int gui_mode
= 0;
71 static char *gui_hwnd
= NULL
;
72 static int using_sftp
= 0;
74 static void source(char *src
);
75 static void rsource(char *src
);
76 static void sink(char *targ
, char *src
);
77 /* GUI Adaptation - Sept 2000 */
78 static void tell_char(FILE * stream
, char c
);
79 static void tell_str(FILE * stream
, char *str
);
80 static void tell_user(FILE * stream
, char *fmt
, ...);
81 static void gui_update_stats(char *name
, unsigned long size
,
82 int percentage
, unsigned long elapsed
);
85 * The maximum amount of queued data we accept before we stop and
86 * wait for the server to process some.
88 #define MAX_SCP_BUFSIZE 16384
90 void logevent(char *string
)
94 void ldisc_send(char *buf
, int len
, int interactive
)
97 * This is only here because of the calls to ldisc_send(NULL,
98 * 0) in ssh.c. Nothing in PSCP actually needs to use the ldisc
99 * as an ldisc. So if we get called with any real data, I want
105 void verify_ssh_host_key(char *host
, int port
, char *keytype
,
106 char *keystr
, char *fingerprint
)
112 static const char absentmsg
[] =
113 "The server's host key is not cached in the registry. You\n"
114 "have no guarantee that the server is the computer you\n"
116 "The server's key fingerprint is:\n"
118 "If you trust this host, enter \"y\" to add the key to\n"
119 "PuTTY's cache and carry on connecting.\n"
120 "If you want to carry on connecting just once, without\n"
121 "adding the key to the cache, enter \"n\".\n"
122 "If you do not trust this host, press Return to abandon the\n"
124 "Store key in cache? (y/n) ";
126 static const char wrongmsg
[] =
127 "WARNING - POTENTIAL SECURITY BREACH!\n"
128 "The server's host key does not match the one PuTTY has\n"
129 "cached in the registry. This means that either the\n"
130 "server administrator has changed the host key, or you\n"
131 "have actually connected to another computer pretending\n"
132 "to be the server.\n"
133 "The new key fingerprint is:\n"
135 "If you were expecting this change and trust the new key,\n"
136 "enter \"y\" to update PuTTY's cache and continue connecting.\n"
137 "If you want to carry on connecting but without updating\n"
138 "the cache, enter \"n\".\n"
139 "If you want to abandon the connection completely, press\n"
140 "Return to cancel. Pressing Return is the ONLY guaranteed\n"
142 "Update cached key? (y/n, Return cancels connection) ";
144 static const char abandoned
[] = "Connection abandoned.\n";
149 * Verify the key against the registry.
151 ret
= verify_host_key(host
, port
, keytype
, keystr
);
153 if (ret
== 0) /* success - key matched OK */
156 if (ret
== 2) { /* key was different */
157 fprintf(stderr
, wrongmsg
, fingerprint
);
160 if (ret
== 1) { /* key was absent */
161 fprintf(stderr
, absentmsg
, fingerprint
);
165 hin
= GetStdHandle(STD_INPUT_HANDLE
);
166 GetConsoleMode(hin
, &savemode
);
167 SetConsoleMode(hin
, (savemode
| ENABLE_ECHO_INPUT
|
168 ENABLE_PROCESSED_INPUT
| ENABLE_LINE_INPUT
));
169 ReadFile(hin
, line
, sizeof(line
) - 1, &i
, NULL
);
170 SetConsoleMode(hin
, savemode
);
172 if (line
[0] != '\0' && line
[0] != '\r' && line
[0] != '\n') {
173 if (line
[0] == 'y' || line
[0] == 'Y')
174 store_host_key(host
, port
, keytype
, keystr
);
176 fprintf(stderr
, abandoned
);
182 * Ask whether the selected cipher is acceptable (since it was
183 * below the configured 'warn' threshold).
184 * cs: 0 = both ways, 1 = client->server, 2 = server->client
186 void askcipher(char *ciphername
, int cs
)
191 static const char msg
[] =
192 "The first %scipher supported by the server is\n"
193 "%s, which is below the configured warning threshold.\n"
194 "Continue with connection? (y/n) ";
195 static const char abandoned
[] = "Connection abandoned.\n";
201 (cs
== 1) ?
"client-to-server " :
206 hin
= GetStdHandle(STD_INPUT_HANDLE
);
207 GetConsoleMode(hin
, &savemode
);
208 SetConsoleMode(hin
, (savemode
| ENABLE_ECHO_INPUT
|
209 ENABLE_PROCESSED_INPUT
| ENABLE_LINE_INPUT
));
210 ReadFile(hin
, line
, sizeof(line
) - 1, &i
, NULL
);
211 SetConsoleMode(hin
, savemode
);
213 if (line
[0] == 'y' || line
[0] == 'Y') {
216 fprintf(stderr
, abandoned
);
221 /* GUI Adaptation - Sept 2000 */
222 static void send_msg(HWND h
, UINT message
, WPARAM wParam
)
224 while (!PostMessage(h
, message
, wParam
, 0))
228 static void tell_char(FILE * stream
, char c
)
233 unsigned int msg_id
= WM_STD_OUT_CHAR
;
234 if (stream
== stderr
)
235 msg_id
= WM_STD_ERR_CHAR
;
236 send_msg((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) c
);
240 static void tell_str(FILE * stream
, char *str
)
244 for (i
= 0; i
< strlen(str
); ++i
)
245 tell_char(stream
, str
[i
]);
248 static void tell_user(FILE * stream
, char *fmt
, ...)
250 char str
[0x100]; /* Make the size big enough */
253 vsprintf(str
, fmt
, ap
);
256 tell_str(stream
, str
);
259 static void gui_update_stats(char *name
, unsigned long size
,
260 int percentage
, unsigned long elapsed
)
264 if (strcmp(name
, statname
) != 0) {
265 for (i
= 0; i
< strlen(name
); ++i
)
266 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_CHAR
,
268 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_CHAR
, (WPARAM
) '\n');
269 strcpy(statname
, name
);
271 if (statsize
!= size
) {
272 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_SIZE
, (WPARAM
) size
);
275 if (statelapsed
!= elapsed
) {
276 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_ELAPSED
,
278 statelapsed
= elapsed
;
280 if (statperct
!= percentage
) {
281 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_PERCENT
,
282 (WPARAM
) percentage
);
283 statperct
= percentage
;
288 * Print an error message and perform a fatal exit.
290 void fatalbox(char *fmt
, ...)
292 char str
[0x100]; /* Make the size big enough */
295 strcpy(str
, "Fatal: ");
296 vsprintf(str
+ strlen(str
), fmt
, ap
);
299 tell_str(stderr
, str
);
303 unsigned int msg_id
= WM_RET_ERR_CNT
;
305 msg_id
= WM_LS_RET_ERR_CNT
;
307 ((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) errs
,
308 0 /*lParam */ ))SleepEx(1000, TRUE
);
313 void connection_fatal(char *fmt
, ...)
315 char str
[0x100]; /* Make the size big enough */
318 strcpy(str
, "Fatal: ");
319 vsprintf(str
+ strlen(str
), fmt
, ap
);
322 tell_str(stderr
, str
);
326 unsigned int msg_id
= WM_RET_ERR_CNT
;
328 msg_id
= WM_LS_RET_ERR_CNT
;
330 ((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) errs
,
331 0 /*lParam */ ))SleepEx(1000, TRUE
);
338 * Be told what socket we're supposed to be using.
340 static SOCKET scp_ssh_socket
;
341 char *do_select(SOCKET skt
, int startup
)
344 scp_ssh_socket
= skt
;
346 scp_ssh_socket
= INVALID_SOCKET
;
349 extern int select_result(WPARAM
, LPARAM
);
352 * Receive a block of data from the SSH link. Block until all data
355 * To do this, we repeatedly call the SSH protocol module, with our
356 * own trap in from_backend() to catch the data that comes back. We
357 * do this until we have enough data.
360 static unsigned char *outptr
; /* where to put the data */
361 static unsigned outlen
; /* how much data required */
362 static unsigned char *pending
= NULL
; /* any spare data */
363 static unsigned pendlen
= 0, pendsize
= 0; /* length and phys. size of buffer */
364 int from_backend(int is_stderr
, char *data
, int datalen
)
366 unsigned char *p
= (unsigned char *) data
;
367 unsigned len
= (unsigned) datalen
;
370 * stderr data is just spouted to local stderr and otherwise
374 fwrite(data
, 1, len
, stderr
);
379 * If this is before the real session begins, just return.
385 unsigned used
= outlen
;
388 memcpy(outptr
, p
, used
);
396 if (pendsize
< pendlen
+ len
) {
397 pendsize
= pendlen
+ len
+ 4096;
398 pending
= (pending ?
srealloc(pending
, pendsize
) :
401 fatalbox("Out of memory");
403 memcpy(pending
+ pendlen
, p
, len
);
409 static int scp_process_network_event(void)
414 FD_SET(scp_ssh_socket
, &readfds
);
415 if (select(1, &readfds
, NULL
, NULL
, NULL
) < 0)
417 select_result((WPARAM
) scp_ssh_socket
, (LPARAM
) FD_READ
);
420 static int ssh_scp_recv(unsigned char *buf
, int len
)
426 * See if the pending-input block contains some of what we
430 unsigned pendused
= pendlen
;
431 if (pendused
> outlen
)
433 memcpy(outptr
, pending
, pendused
);
434 memmove(pending
, pending
+ pendused
, pendlen
- pendused
);
448 if (!scp_process_network_event())
456 * Loop through the ssh connection and authentication process.
458 static void ssh_scp_init(void)
460 if (scp_ssh_socket
== INVALID_SOCKET
)
462 while (!back
->sendok()) {
465 FD_SET(scp_ssh_socket
, &readfds
);
466 if (select(1, &readfds
, NULL
, NULL
, NULL
) < 0)
468 select_result((WPARAM
) scp_ssh_socket
, (LPARAM
) FD_READ
);
470 using_sftp
= !ssh_fallback_cmd
;
474 * Print an error message and exit after closing the SSH link.
476 static void bump(char *fmt
, ...)
478 char str
[0x100]; /* Make the size big enough */
481 strcpy(str
, "Fatal: ");
482 vsprintf(str
+ strlen(str
), fmt
, ap
);
485 tell_str(stderr
, str
);
488 if (back
!= NULL
&& back
->socket() != NULL
) {
490 back
->special(TS_EOF
);
491 ssh_scp_recv(&ch
, 1);
495 unsigned int msg_id
= WM_RET_ERR_CNT
;
497 msg_id
= WM_LS_RET_ERR_CNT
;
499 ((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) errs
,
500 0 /*lParam */ ))SleepEx(1000, TRUE
);
506 static int get_line(const char *prompt
, char *str
, int maxlen
, int is_pw
)
509 DWORD savemode
, newmode
, i
;
511 if (is_pw
&& password
) {
512 static int tried_once
= 0;
517 strncpy(str
, password
, maxlen
);
518 str
[maxlen
- 1] = '\0';
524 /* GUI Adaptation - Sept 2000 */
529 hin
= GetStdHandle(STD_INPUT_HANDLE
);
530 hout
= GetStdHandle(STD_OUTPUT_HANDLE
);
531 if (hin
== INVALID_HANDLE_VALUE
|| hout
== INVALID_HANDLE_VALUE
)
532 bump("Cannot get standard input/output handles");
534 GetConsoleMode(hin
, &savemode
);
535 newmode
= savemode
| ENABLE_PROCESSED_INPUT
| ENABLE_LINE_INPUT
;
537 newmode
&= ~ENABLE_ECHO_INPUT
;
539 newmode
|= ENABLE_ECHO_INPUT
;
540 SetConsoleMode(hin
, newmode
);
542 WriteFile(hout
, prompt
, strlen(prompt
), &i
, NULL
);
543 ReadFile(hin
, str
, maxlen
- 1, &i
, NULL
);
545 SetConsoleMode(hin
, savemode
);
547 if ((int) i
> maxlen
)
554 WriteFile(hout
, "\r\n", 2, &i
, NULL
);
561 * Open an SSH connection to user@host and execute cmd.
563 static void do_cmd(char *host
, char *user
, char *cmd
)
565 char *err
, *realhost
;
568 if (host
== NULL
|| host
[0] == '\0')
569 bump("Empty host name");
571 /* Try to load settings for this host */
572 do_defaults(host
, &cfg
);
573 if (cfg
.host
[0] == '\0') {
574 /* No settings for this host; use defaults */
575 do_defaults(NULL
, &cfg
);
576 strncpy(cfg
.host
, host
, sizeof(cfg
.host
) - 1);
577 cfg
.host
[sizeof(cfg
.host
) - 1] = '\0';
582 * Trim leading whitespace off the hostname if it's there.
585 int space
= strspn(cfg
.host
, " \t");
586 memmove(cfg
.host
, cfg
.host
+space
, 1+strlen(cfg
.host
)-space
);
589 /* See if host is of the form user@host */
590 if (cfg
.host
[0] != '\0') {
591 char *atsign
= strchr(cfg
.host
, '@');
592 /* Make sure we're not overflowing the user field */
594 if (atsign
- cfg
.host
< sizeof cfg
.username
) {
595 strncpy(cfg
.username
, cfg
.host
, atsign
- cfg
.host
);
596 cfg
.username
[atsign
- cfg
.host
] = '\0';
598 memmove(cfg
.host
, atsign
+ 1, 1 + strlen(atsign
+ 1));
603 * Trim a colon suffix off the hostname if it's there.
605 cfg
.host
[strcspn(cfg
.host
, ":")] = '\0';
608 if (user
!= NULL
&& user
[0] != '\0') {
609 strncpy(cfg
.username
, user
, sizeof(cfg
.username
) - 1);
610 cfg
.username
[sizeof(cfg
.username
) - 1] = '\0';
611 } else if (cfg
.username
[0] == '\0') {
613 if (GetUserName(user
, &namelen
) == FALSE
)
614 bump("Empty user name");
615 user
= smalloc(namelen
* sizeof(char));
616 GetUserName(user
, &namelen
);
618 tell_user(stderr
, "Guessing user name: %s", user
);
619 strncpy(cfg
.username
, user
, sizeof(cfg
.username
) - 1);
620 cfg
.username
[sizeof(cfg
.username
) - 1] = '\0';
624 if (cfg
.protocol
!= PROT_SSH
)
628 cfg
.port
= portnumber
;
631 * Disable scary things which shouldn't be enabled for simple
632 * things like SCP and SFTP: agent forwarding, port forwarding,
637 cfg
.portfwd
[0] = cfg
.portfwd
[1] = '\0';
640 * Attempt to start the SFTP subsystem as a first choice,
641 * falling back to the provided scp command if that fails.
643 strcpy(cfg
.remote_cmd
, "sftp");
644 cfg
.ssh_subsys
= TRUE
;
645 cfg
.remote_cmd_ptr2
= cmd
;
646 cfg
.ssh_subsys2
= FALSE
;
651 err
= back
->init(cfg
.host
, cfg
.port
, &realhost
);
653 bump("ssh_init: %s", err
);
655 if (verbose
&& realhost
!= NULL
)
656 tell_user(stderr
, "Connected to %s\n", realhost
);
661 * Update statistic information about current file.
663 static void print_stats(char *name
, unsigned long size
, unsigned long done
,
664 time_t start
, time_t now
)
672 /* GUI Adaptation - Sept 2000 */
674 gui_update_stats(name
, size
, (int) (100 * (done
* 1.0 / size
)),
675 (unsigned long) difftime(now
, start
));
678 ratebs
= (float) done
/ (now
- start
);
680 ratebs
= (float) done
;
685 eta
= (unsigned long) ((size
- done
) / ratebs
);
686 sprintf(etastr
, "%02ld:%02ld:%02ld",
687 eta
/ 3600, (eta
% 3600) / 60, eta
% 60);
689 pct
= (int) (100 * (done
* 1.0 / size
));
691 len
= printf("\r%-25.25s | %10ld kB | %5.1f kB/s | ETA: %8s | %3d%%",
692 name
, done
/ 1024, ratebs
/ 1024.0, etastr
, pct
);
693 if (len
< prev_stats_len
)
694 printf("%*s", prev_stats_len
- len
, "");
695 prev_stats_len
= len
;
703 * Find a colon in str and return a pointer to the colon.
704 * This is used to separate hostname from filename.
706 static char *colon(char *str
)
708 /* We ignore a leading colon, since the hostname cannot be
709 empty. We also ignore a colon as second character because
710 of filenames like f:myfile.txt. */
711 if (str
[0] == '\0' || str
[0] == ':' || str
[1] == ':')
713 while (*str
!= '\0' && *str
!= ':' && *str
!= '/' && *str
!= '\\')
722 * Return a pointer to the portion of str that comes after the last
723 * slash (or backslash or colon, if `local' is TRUE).
725 static char *stripslashes(char *str
, int local
)
730 p
= strchr(str
, ':');
734 p
= strrchr(str
, '/');
738 p
= strrchr(str
, '\\');
746 * Determine whether a string is entirely composed of dots.
748 static int is_dots(char *str
)
750 return str
[strspn(str
, ".")] == '\0';
754 * Wait for a response from the other side.
755 * Return 0 if ok, -1 if error.
757 static int response(void)
759 char ch
, resp
, rbuf
[2048];
762 if (ssh_scp_recv(&resp
, 1) <= 0)
763 bump("Lost connection");
773 case 2: /* fatal error */
775 if (ssh_scp_recv(&ch
, 1) <= 0)
776 bump("Protocol error: Lost connection");
778 } while (p
< sizeof(rbuf
) && ch
!= '\n');
781 tell_user(stderr
, "%s\n", rbuf
);
789 int sftp_recvdata(char *buf
, int len
)
791 return ssh_scp_recv(buf
, len
);
793 int sftp_senddata(char *buf
, int len
)
795 back
->send((unsigned char *) buf
, len
);
799 /* ----------------------------------------------------------------------
800 * sftp-based replacement for the hacky `pscp -ls'.
802 static int sftp_ls_compare(const void *av
, const void *bv
)
804 const struct fxp_name
*a
= (const struct fxp_name
*) av
;
805 const struct fxp_name
*b
= (const struct fxp_name
*) bv
;
806 return strcmp(a
->filename
, b
->filename
);
808 void scp_sftp_listdir(char *dirname
)
810 struct fxp_handle
*dirh
;
811 struct fxp_names
*names
;
812 struct fxp_name
*ournames
;
813 int nnames
, namesize
;
816 printf("Listing directory %s\n", dirname
);
818 dirh
= fxp_opendir(dirname
);
820 printf("Unable to open %s: %s\n", dirname
, fxp_error());
822 nnames
= namesize
= 0;
827 names
= fxp_readdir(dirh
);
829 if (fxp_error_type() == SSH_FX_EOF
)
831 printf("Reading directory %s: %s\n", dirname
, fxp_error());
834 if (names
->nnames
== 0) {
835 fxp_free_names(names
);
839 if (nnames
+ names
->nnames
>= namesize
) {
840 namesize
+= names
->nnames
+ 128;
842 srealloc(ournames
, namesize
* sizeof(*ournames
));
845 for (i
= 0; i
< names
->nnames
; i
++)
846 ournames
[nnames
++] = names
->names
[i
];
848 names
->nnames
= 0; /* prevent free_names */
849 fxp_free_names(names
);
854 * Now we have our filenames. Sort them by actual file
855 * name, and then output the longname parts.
857 qsort(ournames
, nnames
, sizeof(*ournames
), sftp_ls_compare
);
862 for (i
= 0; i
< nnames
; i
++)
863 printf("%s\n", ournames
[i
].longname
);
867 /* ----------------------------------------------------------------------
868 * Helper routines that contain the actual SCP protocol elements,
869 * implemented both as SCP1 and SFTP.
872 static struct scp_sftp_dirstack
{
873 struct scp_sftp_dirstack
*next
;
874 struct fxp_name
*names
;
875 int namepos
, namelen
;
878 int matched_something
; /* wildcard match set was non-empty */
879 } *scp_sftp_dirstack_head
;
880 static char *scp_sftp_remotepath
, *scp_sftp_currentname
;
881 static char *scp_sftp_wildcard
;
882 static int scp_sftp_targetisdir
, scp_sftp_donethistarget
;
883 static int scp_sftp_preserve
, scp_sftp_recursive
;
884 static unsigned long scp_sftp_mtime
, scp_sftp_atime
;
885 static int scp_has_times
;
886 static struct fxp_handle
*scp_sftp_filehandle
;
887 static uint64 scp_sftp_fileoffset
;
889 void scp_source_setup(char *target
, int shouldbedir
)
893 * Find out whether the target filespec is in fact a
896 struct fxp_attrs attrs
;
898 if (!fxp_stat(target
, &attrs
) ||
899 !(attrs
.flags
& SSH_FILEXFER_ATTR_PERMISSIONS
))
900 scp_sftp_targetisdir
= 0;
902 scp_sftp_targetisdir
= (attrs
.permissions
& 0040000) != 0;
904 if (shouldbedir
&& !scp_sftp_targetisdir
) {
905 bump("pscp: remote filespec %s: not a directory\n", target
);
908 scp_sftp_remotepath
= dupstr(target
);
916 int scp_send_errmsg(char *str
)
919 /* do nothing; we never need to send our errors to the server */
921 back
->send("\001", 1); /* scp protocol error prefix */
922 back
->send(str
, strlen(str
));
924 return 0; /* can't fail */
927 int scp_send_filetimes(unsigned long mtime
, unsigned long atime
)
930 scp_sftp_mtime
= mtime
;
931 scp_sftp_atime
= atime
;
936 sprintf(buf
, "T%lu 0 %lu 0\n", mtime
, atime
);
937 back
->send(buf
, strlen(buf
));
942 int scp_send_filename(char *name
, unsigned long size
, int modes
)
946 if (scp_sftp_targetisdir
) {
947 fullname
= dupcat(scp_sftp_remotepath
, "/", name
, NULL
);
949 fullname
= dupstr(scp_sftp_remotepath
);
951 scp_sftp_filehandle
=
952 fxp_open(fullname
, SSH_FXF_WRITE
| SSH_FXF_CREAT
| SSH_FXF_TRUNC
);
953 if (!scp_sftp_filehandle
) {
954 tell_user(stderr
, "pscp: unable to open %s: %s",
955 fullname
, fxp_error());
959 scp_sftp_fileoffset
= uint64_make(0, 0);
964 sprintf(buf
, "C%04o %lu ", modes
, size
);
965 back
->send(buf
, strlen(buf
));
966 back
->send(name
, strlen(name
));
972 int scp_send_filedata(char *data
, int len
)
975 if (!scp_sftp_filehandle
) {
978 if (!fxp_write(scp_sftp_filehandle
, data
, scp_sftp_fileoffset
, len
)) {
979 tell_user(stderr
, "error while writing: %s\n", fxp_error());
983 scp_sftp_fileoffset
= uint64_add32(scp_sftp_fileoffset
, len
);
986 int bufsize
= back
->send(data
, len
);
989 * If the network transfer is backing up - that is, the
990 * remote site is not accepting data as fast as we can
991 * produce it - then we must loop on network events until
992 * we have space in the buffer again.
994 while (bufsize
> MAX_SCP_BUFSIZE
) {
995 if (!scp_process_network_event())
997 bufsize
= back
->sendbuffer();
1004 int scp_send_finish(void)
1007 struct fxp_attrs attrs
;
1008 if (!scp_sftp_filehandle
) {
1011 if (scp_has_times
) {
1012 attrs
.flags
= SSH_FILEXFER_ATTR_ACMODTIME
;
1013 attrs
.atime
= scp_sftp_atime
;
1014 attrs
.mtime
= scp_sftp_mtime
;
1015 if (!fxp_fsetstat(scp_sftp_filehandle
, attrs
)) {
1016 tell_user(stderr
, "unable to set file times: %s\n", fxp_error());
1020 fxp_close(scp_sftp_filehandle
);
1029 char *scp_save_remotepath(void)
1032 return scp_sftp_remotepath
;
1037 void scp_restore_remotepath(char *data
)
1040 scp_sftp_remotepath
= data
;
1043 int scp_send_dirname(char *name
, int modes
)
1048 struct fxp_attrs attrs
;
1049 if (scp_sftp_targetisdir
) {
1050 fullname
= dupcat(scp_sftp_remotepath
, "/", name
, NULL
);
1052 fullname
= dupstr(scp_sftp_remotepath
);
1056 * We don't worry about whether we managed to create the
1057 * directory, because if it exists already it's OK just to
1058 * use it. Instead, we will stat it afterwards, and if it
1059 * exists and is a directory we will assume we were either
1060 * successful or it didn't matter.
1062 if (!fxp_mkdir(fullname
))
1065 err
= "server reported no error";
1066 if (!fxp_stat(fullname
, &attrs
) ||
1067 !(attrs
.flags
& SSH_FILEXFER_ATTR_PERMISSIONS
) ||
1068 !(attrs
.permissions
& 0040000)) {
1069 tell_user(stderr
, "unable to create directory %s: %s",
1075 scp_sftp_remotepath
= fullname
;
1080 sprintf(buf
, "D%04o 0 ", modes
);
1081 back
->send(buf
, strlen(buf
));
1082 back
->send(name
, strlen(name
));
1083 back
->send("\n", 1);
1088 int scp_send_enddir(void)
1091 sfree(scp_sftp_remotepath
);
1094 back
->send("E\n", 2);
1100 * Yes, I know; I have an scp_sink_setup _and_ an scp_sink_init.
1101 * That's bad. The difference is that scp_sink_setup is called once
1102 * right at the start, whereas scp_sink_init is called to
1103 * initialise every level of recursion in the protocol.
1105 int scp_sink_setup(char *source
, int preserve
, int recursive
)
1110 * It's possible that the source string we've been given
1111 * contains a wildcard. If so, we must split the directory
1112 * away from the wildcard itself (throwing an error if any
1113 * wildcardness comes before the final slash) and arrange
1114 * things so that a dirstack entry will be set up.
1116 newsource
= smalloc(1+strlen(source
));
1117 if (!wc_unescape(newsource
, source
)) {
1118 /* Yes, here we go; it's a wildcard. Bah. */
1119 char *dupsource
, *lastpart
, *dirpart
, *wildcard
;
1120 dupsource
= dupstr(source
);
1121 lastpart
= stripslashes(dupsource
, 0);
1122 wildcard
= dupstr(lastpart
);
1124 if (*dupsource
&& dupsource
[1]) {
1126 * The remains of dupsource are at least two
1127 * characters long, meaning the pathname wasn't
1128 * empty or just `/'. Hence, we remove the trailing
1131 lastpart
[-1] = '\0';
1132 } else if (!*dupsource
) {
1134 * The remains of dupsource are _empty_ - the whole
1135 * pathname was a wildcard. Hence we need to
1136 * replace it with ".".
1139 dupsource
= dupstr(".");
1143 * Now we have separated our string into dupsource (the
1144 * directory part) and wildcard. Both of these will
1145 * need freeing at some point. Next step is to remove
1146 * wildcard escapes from the directory part, throwing
1147 * an error if it contains a real wildcard.
1149 dirpart
= smalloc(1+strlen(dupsource
));
1150 if (!wc_unescape(dirpart
, dupsource
)) {
1151 tell_user(stderr
, "%s: multiple-level wildcards unsupported",
1161 * Now we have dirpart (unescaped, ie a valid remote
1162 * path), and wildcard (a wildcard). This will be
1163 * sufficient to arrange a dirstack entry.
1165 scp_sftp_remotepath
= dirpart
;
1166 scp_sftp_wildcard
= wildcard
;
1169 scp_sftp_remotepath
= newsource
;
1170 scp_sftp_wildcard
= NULL
;
1172 scp_sftp_preserve
= preserve
;
1173 scp_sftp_recursive
= recursive
;
1174 scp_sftp_donethistarget
= 0;
1175 scp_sftp_dirstack_head
= NULL
;
1180 int scp_sink_init(void)
1188 #define SCP_SINK_FILE 1
1189 #define SCP_SINK_DIR 2
1190 #define SCP_SINK_ENDDIR 3
1191 #define SCP_SINK_RETRY 4 /* not an action; just try again */
1192 struct scp_sink_action
{
1193 int action
; /* FILE, DIR, ENDDIR */
1194 char *buf
; /* will need freeing after use */
1195 char *name
; /* filename or dirname (not ENDDIR) */
1196 int mode
; /* access mode (not ENDDIR) */
1197 unsigned long size
; /* file size (not ENDDIR) */
1198 int settime
; /* 1 if atime and mtime are filled */
1199 unsigned long atime
, mtime
; /* access times for the file */
1202 int scp_get_sink_action(struct scp_sink_action
*act
)
1206 int must_free_fname
;
1207 struct fxp_attrs attrs
;
1210 if (!scp_sftp_dirstack_head
) {
1211 if (!scp_sftp_donethistarget
) {
1213 * Simple case: we are only dealing with one file.
1215 fname
= scp_sftp_remotepath
;
1216 must_free_fname
= 0;
1217 scp_sftp_donethistarget
= 1;
1220 * Even simpler case: one file _which we've done_.
1221 * Return 1 (finished).
1227 * We're now in the middle of stepping through a list
1228 * of names returned from fxp_readdir(); so let's carry
1231 struct scp_sftp_dirstack
*head
= scp_sftp_dirstack_head
;
1232 while (head
->namepos
< head
->namelen
&&
1233 (is_dots(head
->names
[head
->namepos
].filename
) ||
1235 !wc_match(head
->wildcard
,
1236 head
->names
[head
->namepos
].filename
))))
1237 head
->namepos
++; /* skip . and .. */
1238 if (head
->namepos
< head
->namelen
) {
1239 head
->matched_something
= 1;
1240 fname
= dupcat(head
->dirpath
, "/",
1241 head
->names
[head
->namepos
++].filename
,
1243 must_free_fname
= 1;
1246 * We've come to the end of the list; pop it off
1247 * the stack and return an ENDDIR action (or RETRY
1248 * if this was a wildcard match).
1250 if (head
->wildcard
) {
1251 act
->action
= SCP_SINK_RETRY
;
1252 if (!head
->matched_something
) {
1253 tell_user(stderr
, "pscp: wildcard '%s' matched "
1254 "no files", head
->wildcard
);
1257 sfree(head
->wildcard
);
1260 act
->action
= SCP_SINK_ENDDIR
;
1263 sfree(head
->dirpath
);
1265 scp_sftp_dirstack_head
= head
->next
;
1273 * Now we have a filename. Stat it, and see if it's a file
1276 ret
= fxp_stat(fname
, &attrs
);
1277 if (!ret
|| !(attrs
.flags
& SSH_FILEXFER_ATTR_PERMISSIONS
)) {
1278 tell_user(stderr
, "unable to identify %s: %s", fname
,
1279 ret ?
"file type not supplied" : fxp_error());
1284 if (attrs
.permissions
& 0040000) {
1285 struct scp_sftp_dirstack
*newitem
;
1286 struct fxp_handle
*dirhandle
;
1287 int nnames
, namesize
;
1288 struct fxp_name
*ournames
;
1289 struct fxp_names
*names
;
1292 * It's a directory. If we're not in recursive mode,
1293 * this merits a complaint (which is fatal if the name
1294 * was specified directly, but not if it was matched by
1297 * We skip this complaint completely if
1298 * scp_sftp_wildcard is set, because that's an
1299 * indication that we're not actually supposed to
1300 * _recursively_ transfer the dir, just scan it for
1301 * things matching the wildcard.
1303 if (!scp_sftp_recursive
&& !scp_sftp_wildcard
) {
1304 tell_user(stderr
, "pscp: %s: is a directory", fname
);
1306 if (must_free_fname
) sfree(fname
);
1307 if (scp_sftp_dirstack_head
) {
1308 act
->action
= SCP_SINK_RETRY
;
1316 * Otherwise, the fun begins. We must fxp_opendir() the
1317 * directory, slurp the filenames into memory, return
1318 * SCP_SINK_DIR (unless this is a wildcard match), and
1319 * set targetisdir. The next time we're called, we will
1320 * run through the list of filenames one by one,
1321 * matching them against a wildcard if present.
1323 * If targetisdir is _already_ set (meaning we're
1324 * already in the middle of going through another such
1325 * list), we must push the other (target,namelist) pair
1328 dirhandle
= fxp_opendir(fname
);
1330 tell_user(stderr
, "scp: unable to open directory %s: %s",
1331 fname
, fxp_error());
1332 if (must_free_fname
) sfree(fname
);
1336 nnames
= namesize
= 0;
1341 names
= fxp_readdir(dirhandle
);
1342 if (names
== NULL
) {
1343 if (fxp_error_type() == SSH_FX_EOF
)
1345 tell_user(stderr
, "scp: reading directory %s: %s\n",
1346 fname
, fxp_error());
1347 if (must_free_fname
) sfree(fname
);
1352 if (names
->nnames
== 0) {
1353 fxp_free_names(names
);
1356 if (nnames
+ names
->nnames
>= namesize
) {
1357 namesize
+= names
->nnames
+ 128;
1359 srealloc(ournames
, namesize
* sizeof(*ournames
));
1361 for (i
= 0; i
< names
->nnames
; i
++)
1362 ournames
[nnames
++] = names
->names
[i
];
1363 names
->nnames
= 0; /* prevent free_names */
1364 fxp_free_names(names
);
1366 fxp_close(dirhandle
);
1368 newitem
= smalloc(sizeof(struct scp_sftp_dirstack
));
1369 newitem
->next
= scp_sftp_dirstack_head
;
1370 newitem
->names
= ournames
;
1371 newitem
->namepos
= 0;
1372 newitem
->namelen
= nnames
;
1373 if (must_free_fname
)
1374 newitem
->dirpath
= fname
;
1376 newitem
->dirpath
= dupstr(fname
);
1377 if (scp_sftp_wildcard
) {
1378 newitem
->wildcard
= scp_sftp_wildcard
;
1379 newitem
->matched_something
= 0;
1380 scp_sftp_wildcard
= NULL
;
1382 newitem
->wildcard
= NULL
;
1384 scp_sftp_dirstack_head
= newitem
;
1386 if (newitem
->wildcard
) {
1387 act
->action
= SCP_SINK_RETRY
;
1389 act
->action
= SCP_SINK_DIR
;
1390 act
->buf
= dupstr(stripslashes(fname
, 0));
1391 act
->name
= act
->buf
;
1392 act
->size
= 0; /* duhh, it's a directory */
1393 act
->mode
= 07777 & attrs
.permissions
;
1394 if (scp_sftp_preserve
&&
1395 (attrs
.flags
& SSH_FILEXFER_ATTR_ACMODTIME
)) {
1396 act
->atime
= attrs
.atime
;
1397 act
->mtime
= attrs
.mtime
;
1406 * It's a file. Return SCP_SINK_FILE.
1408 act
->action
= SCP_SINK_FILE
;
1409 act
->buf
= dupstr(stripslashes(fname
, 0));
1410 act
->name
= act
->buf
;
1411 if (attrs
.flags
& SSH_FILEXFER_ATTR_SIZE
) {
1412 if (uint64_compare(attrs
.size
,
1413 uint64_make(0, ULONG_MAX
)) > 0) {
1414 act
->size
= ULONG_MAX
; /* *boggle* */
1416 act
->size
= attrs
.size
.lo
;
1418 act
->size
= ULONG_MAX
; /* no idea */
1419 act
->mode
= 07777 & attrs
.permissions
;
1420 if (scp_sftp_preserve
&&
1421 (attrs
.flags
& SSH_FILEXFER_ATTR_ACMODTIME
)) {
1422 act
->atime
= attrs
.atime
;
1423 act
->mtime
= attrs
.mtime
;
1427 if (must_free_fname
)
1428 scp_sftp_currentname
= fname
;
1430 scp_sftp_currentname
= dupstr(fname
);
1445 if (ssh_scp_recv(&ch
, 1) <= 0)
1448 bump("Protocol error: Unexpected newline");
1452 if (ssh_scp_recv(&ch
, 1) <= 0)
1453 bump("Lost connection");
1456 act
->buf
= srealloc(act
->buf
, bufsize
);
1459 } while (ch
!= '\n');
1460 act
->buf
[i
- 1] = '\0';
1462 case '\01': /* error */
1463 tell_user(stderr
, "%s\n", act
->buf
);
1465 continue; /* go round again */
1466 case '\02': /* fatal error */
1467 bump("%s", act
->buf
);
1470 act
->action
= SCP_SINK_ENDDIR
;
1473 if (sscanf(act
->buf
, "%ld %*d %ld %*d",
1474 &act
->mtime
, &act
->atime
) == 2) {
1477 continue; /* go round again */
1479 bump("Protocol error: Illegal time format");
1482 act
->action
= (action
== 'C' ? SCP_SINK_FILE
: SCP_SINK_DIR
);
1485 bump("Protocol error: Expected control record");
1488 * We will go round this loop only once, unless we hit
1495 * If we get here, we must have seen SCP_SINK_FILE or
1498 if (sscanf(act
->buf
, "%o %lu %n", &act
->mode
, &act
->size
, &i
) != 2)
1499 bump("Protocol error: Illegal file descriptor format");
1500 act
->name
= act
->buf
+ i
;
1505 int scp_accept_filexfer(void)
1508 scp_sftp_filehandle
=
1509 fxp_open(scp_sftp_currentname
, SSH_FXF_READ
);
1510 if (!scp_sftp_filehandle
) {
1511 tell_user(stderr
, "pscp: unable to open %s: %s",
1512 scp_sftp_currentname
, fxp_error());
1516 scp_sftp_fileoffset
= uint64_make(0, 0);
1517 sfree(scp_sftp_currentname
);
1521 return 0; /* can't fail */
1525 int scp_recv_filedata(char *data
, int len
)
1528 int actuallen
= fxp_read(scp_sftp_filehandle
, data
,
1529 scp_sftp_fileoffset
, len
);
1530 if (actuallen
== -1 && fxp_error_type() != SSH_FX_EOF
) {
1531 tell_user(stderr
, "pscp: error while reading: %s", fxp_error());
1538 scp_sftp_fileoffset
= uint64_add32(scp_sftp_fileoffset
, actuallen
);
1542 return ssh_scp_recv(data
, len
);
1546 int scp_finish_filerecv(void)
1549 fxp_close(scp_sftp_filehandle
);
1557 /* ----------------------------------------------------------------------
1558 * Send an error message to the other side and to the screen.
1559 * Increment error counter.
1561 static void run_err(const char *fmt
, ...)
1567 strcpy(str
, "scp: ");
1568 vsprintf(str
+ strlen(str
), fmt
, ap
);
1570 scp_send_errmsg(str
);
1571 tell_user(stderr
, "%s", str
);
1576 * Execute the source part of the SCP protocol.
1578 static void source(char *src
)
1585 unsigned long stat_bytes
;
1586 time_t stat_starttime
, stat_lasttime
;
1588 attr
= GetFileAttributes(src
);
1589 if (attr
== (DWORD
) - 1) {
1590 run_err("%s: No such file or directory", src
);
1594 if ((attr
& FILE_ATTRIBUTE_DIRECTORY
) != 0) {
1597 * Avoid . and .. directories.
1600 p
= strrchr(src
, '/');
1602 p
= strrchr(src
, '\\');
1607 if (!strcmp(p
, ".") || !strcmp(p
, ".."))
1608 /* skip . and .. */ ;
1612 run_err("%s: not a regular file", src
);
1617 if ((last
= strrchr(src
, '/')) == NULL
)
1621 if (strrchr(last
, '\\') != NULL
)
1622 last
= strrchr(last
, '\\') + 1;
1623 if (last
== src
&& strchr(src
, ':') != NULL
)
1624 last
= strchr(src
, ':') + 1;
1626 f
= CreateFile(src
, GENERIC_READ
, FILE_SHARE_READ
, NULL
,
1627 OPEN_EXISTING
, 0, 0);
1628 if (f
== INVALID_HANDLE_VALUE
) {
1629 run_err("%s: Cannot open file", src
);
1634 FILETIME actime
, wrtime
;
1635 unsigned long mtime
, atime
;
1636 GetFileTime(f
, NULL
, &actime
, &wrtime
);
1637 TIME_WIN_TO_POSIX(actime
, atime
);
1638 TIME_WIN_TO_POSIX(wrtime
, mtime
);
1639 if (scp_send_filetimes(mtime
, atime
))
1643 size
= GetFileSize(f
, NULL
);
1645 tell_user(stderr
, "Sending file %s, size=%lu", last
, size
);
1646 if (scp_send_filename(last
, size
, 0644))
1650 stat_starttime
= time(NULL
);
1653 for (i
= 0; i
< size
; i
+= 4096) {
1654 char transbuf
[4096];
1659 if (!ReadFile(f
, transbuf
, k
, &j
, NULL
) || j
!= k
) {
1662 bump("%s: Read error", src
);
1664 if (scp_send_filedata(transbuf
, k
))
1665 bump("%s: Network error occurred", src
);
1669 if (time(NULL
) != stat_lasttime
|| i
+ k
== size
) {
1670 stat_lasttime
= time(NULL
);
1671 print_stats(last
, size
, stat_bytes
,
1672 stat_starttime
, stat_lasttime
);
1679 (void) scp_send_finish();
1683 * Recursively send the contents of a directory.
1685 static void rsource(char *src
)
1687 char *last
, *findfile
;
1690 WIN32_FIND_DATA fdat
;
1693 if ((last
= strrchr(src
, '/')) == NULL
)
1697 if (strrchr(last
, '\\') != NULL
)
1698 last
= strrchr(last
, '\\') + 1;
1699 if (last
== src
&& strchr(src
, ':') != NULL
)
1700 last
= strchr(src
, ':') + 1;
1702 /* maybe send filetime */
1704 save_target
= scp_save_remotepath();
1707 tell_user(stderr
, "Entering directory: %s", last
);
1708 if (scp_send_dirname(last
, 0755))
1711 findfile
= dupcat(src
, "/*", NULL
);
1712 dir
= FindFirstFile(findfile
, &fdat
);
1713 ok
= (dir
!= INVALID_HANDLE_VALUE
);
1715 if (strcmp(fdat
.cFileName
, ".") == 0 ||
1716 strcmp(fdat
.cFileName
, "..") == 0) {
1717 /* ignore . and .. */
1719 char *foundfile
= dupcat(src
, "/", fdat
.cFileName
, NULL
);
1723 ok
= FindNextFile(dir
, &fdat
);
1728 (void) scp_send_enddir();
1730 scp_restore_remotepath(save_target
);
1734 * Execute the sink part of the SCP protocol.
1736 static void sink(char *targ
, char *src
)
1743 unsigned long received
;
1745 unsigned long stat_bytes
;
1746 time_t stat_starttime
, stat_lasttime
;
1749 attr
= GetFileAttributes(targ
);
1750 if (attr
!= (DWORD
) - 1 && (attr
& FILE_ATTRIBUTE_DIRECTORY
) != 0)
1753 if (targetshouldbedirectory
&& !targisdir
)
1754 bump("%s: Not a directory", targ
);
1758 struct scp_sink_action act
;
1759 if (scp_get_sink_action(&act
))
1762 if (act
.action
== SCP_SINK_ENDDIR
)
1765 if (act
.action
== SCP_SINK_RETRY
)
1770 * Prevent the remote side from maliciously writing to
1771 * files outside the target area by sending a filename
1772 * containing `../'. In fact, it shouldn't be sending
1773 * filenames with any slashes or colons in at all; so
1774 * we'll find the last slash, backslash or colon in the
1775 * filename and use only the part after that. (And
1778 * In addition, we also ensure here that if we're
1779 * copying a single file and the target is a directory
1780 * (common usage: `pscp host:filename .') the remote
1781 * can't send us a _different_ file name. We can
1782 * distinguish this case because `src' will be non-NULL
1783 * and the last component of that will fail to match
1784 * (the last component of) the name sent.
1786 * Well, not always; if `src' is a wildcard, we do
1787 * expect to get back filenames that don't correspond
1788 * exactly to it. Ideally in this case, we would like
1789 * to ensure that the returned filename actually
1790 * matches the wildcard pattern - but one of SCP's
1791 * protocol infelicities is that wildcard matching is
1792 * done at the server end _by the server's rules_ and
1793 * so in general this is infeasible. Hence, we only
1794 * accept filenames that don't correspond to `src' if
1795 * unsafe mode is enabled or we are using SFTP (which
1796 * resolves remote wildcards on the client side and can
1799 char *striptarget
, *stripsrc
;
1801 striptarget
= stripslashes(act
.name
, 1);
1802 if (striptarget
!= act
.name
) {
1803 tell_user(stderr
, "warning: remote host sent a compound"
1804 " pathname '%s'", act
.name
);
1805 tell_user(stderr
, " renaming local file to '%s'",
1810 * Also check to see if the target filename is '.' or
1811 * '..', or indeed '...' and so on because Windows
1812 * appears to interpret those like '..'.
1814 if (is_dots(striptarget
)) {
1815 bump("security violation: remote host attempted to write to"
1816 " a '.' or '..' path!");
1820 stripsrc
= stripslashes(src
, 1);
1821 if (strcmp(striptarget
, stripsrc
) &&
1822 !using_sftp
&& !scp_unsafe_mode
) {
1823 tell_user(stderr
, "warning: remote host tried to write "
1824 "to a file called '%s'", striptarget
);
1825 tell_user(stderr
, " when we requested a file "
1826 "called '%s'.", stripsrc
);
1827 tell_user(stderr
, " If this is a wildcard, "
1828 "consider upgrading to SSH 2 or using");
1829 tell_user(stderr
, " the '-unsafe' option. Renaming"
1830 " of this file has been disallowed.");
1831 /* Override the name the server provided with our own. */
1832 striptarget
= stripsrc
;
1836 if (targ
[0] != '\0')
1837 destfname
= dupcat(targ
, "\\", striptarget
, NULL
);
1839 destfname
= dupstr(striptarget
);
1842 * In this branch of the if, the target area is a
1843 * single file with an explicitly specified name in any
1844 * case, so there's no danger.
1846 destfname
= dupstr(targ
);
1848 attr
= GetFileAttributes(destfname
);
1849 exists
= (attr
!= (DWORD
) - 1);
1851 if (act
.action
== SCP_SINK_DIR
) {
1852 if (exists
&& (attr
& FILE_ATTRIBUTE_DIRECTORY
) == 0) {
1853 run_err("%s: Not a directory", destfname
);
1857 if (!CreateDirectory(destfname
, NULL
)) {
1858 run_err("%s: Cannot create directory", destfname
);
1862 sink(destfname
, NULL
);
1863 /* can we set the timestamp for directories ? */
1867 f
= CreateFile(destfname
, GENERIC_WRITE
, 0, NULL
,
1868 CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, 0);
1869 if (f
== INVALID_HANDLE_VALUE
) {
1870 run_err("%s: Cannot create file", destfname
);
1874 if (scp_accept_filexfer())
1878 stat_starttime
= time(NULL
);
1880 stat_name
= stripslashes(destfname
, 1);
1883 while (received
< act
.size
) {
1884 char transbuf
[4096];
1885 DWORD blksize
, read
, written
;
1887 if (blksize
> act
.size
- received
)
1888 blksize
= act
.size
- received
;
1889 read
= scp_recv_filedata(transbuf
, blksize
);
1891 bump("Lost connection");
1894 if (!WriteFile(f
, transbuf
, read
, &written
, NULL
) ||
1897 /* FIXME: in sftp we can actually abort the transfer */
1899 printf("\r%-25.25s | %50s\n",
1901 "Write error.. waiting for end of file");
1906 if (time(NULL
) > stat_lasttime
||
1907 received
+ read
== act
.size
) {
1908 stat_lasttime
= time(NULL
);
1909 print_stats(stat_name
, act
.size
, stat_bytes
,
1910 stat_starttime
, stat_lasttime
);
1916 FILETIME actime
, wrtime
;
1917 TIME_POSIX_TO_WIN(act
.atime
, actime
);
1918 TIME_POSIX_TO_WIN(act
.mtime
, wrtime
);
1919 SetFileTime(f
, NULL
, &actime
, &wrtime
);
1924 run_err("%s: Write error", destfname
);
1927 (void) scp_finish_filerecv();
1934 * We will copy local files to a remote server.
1936 static void toremote(int argc
, char *argv
[])
1938 char *src
, *targ
, *host
, *user
;
1942 targ
= argv
[argc
- 1];
1944 /* Separate host from filename */
1948 bump("targ == NULL in toremote()");
1952 /* Substitute "." for emtpy target */
1954 /* Separate host and username */
1956 host
= strrchr(host
, '@');
1967 /* Find out if the source filespec covers multiple files
1968 if so, we should set the targetshouldbedirectory flag */
1970 WIN32_FIND_DATA fdat
;
1971 if (colon(argv
[0]) != NULL
)
1972 bump("%s: Remote to remote not supported", argv
[0]);
1973 fh
= FindFirstFile(argv
[0], &fdat
);
1974 if (fh
== INVALID_HANDLE_VALUE
)
1975 bump("%s: No such file or directory\n", argv
[0]);
1976 if (FindNextFile(fh
, &fdat
))
1977 targetshouldbedirectory
= 1;
1981 cmd
= smalloc(strlen(targ
) + 100);
1982 sprintf(cmd
, "scp%s%s%s%s -t %s",
1983 verbose ?
" -v" : "",
1984 recursive ?
" -r" : "",
1985 preserve ?
" -p" : "",
1986 targetshouldbedirectory ?
" -d" : "", targ
);
1987 do_cmd(host
, user
, cmd
);
1990 scp_source_setup(targ
, targetshouldbedirectory
);
1992 for (i
= 0; i
< argc
- 1; i
++) {
1993 char *srcpath
, *last
;
1995 WIN32_FIND_DATA fdat
;
1997 if (colon(src
) != NULL
) {
1998 tell_user(stderr
, "%s: Remote to remote not supported\n", src
);
2004 * Trim off the last pathname component of `src', to
2005 * provide the base pathname which will be prepended to
2006 * filenames returned from Find{First,Next}File.
2008 srcpath
= dupstr(src
);
2009 last
= stripslashes(srcpath
, 1);
2012 dir
= FindFirstFile(src
, &fdat
);
2013 if (dir
== INVALID_HANDLE_VALUE
) {
2014 run_err("%s: No such file or directory", src
);
2020 * Ensure that . and .. are never matched by wildcards,
2021 * but only by deliberate action.
2023 if (!strcmp(fdat
.cFileName
, ".") ||
2024 !strcmp(fdat
.cFileName
, "..")) {
2026 * Find*File has returned a special dir. We require
2027 * that _either_ `src' ends in a backslash followed
2028 * by that string, _or_ `src' is precisely that
2031 int len
= strlen(src
), dlen
= strlen(fdat
.cFileName
);
2032 if (len
== dlen
&& !strcmp(src
, fdat
.cFileName
)) {
2034 } else if (len
> dlen
+ 1 && src
[len
- dlen
- 1] == '\\' &&
2035 !strcmp(src
+ len
- dlen
, fdat
.cFileName
)) {
2038 continue; /* ignore this one */
2040 filename
= dupcat(srcpath
, fdat
.cFileName
, NULL
);
2043 } while (FindNextFile(dir
, &fdat
));
2050 * We will copy files from a remote server to the local machine.
2052 static void tolocal(int argc
, char *argv
[])
2054 char *src
, *targ
, *host
, *user
;
2058 bump("More than one remote source not supported");
2063 /* Separate host from filename */
2067 bump("Local to local copy not supported");
2071 /* Substitute "." for empty filename */
2073 /* Separate username and hostname */
2075 host
= strrchr(host
, '@');
2085 cmd
= smalloc(strlen(src
) + 100);
2086 sprintf(cmd
, "scp%s%s%s%s -f %s",
2087 verbose ?
" -v" : "",
2088 recursive ?
" -r" : "",
2089 preserve ?
" -p" : "",
2090 targetshouldbedirectory ?
" -d" : "", src
);
2091 do_cmd(host
, user
, cmd
);
2094 if (scp_sink_setup(src
, preserve
, recursive
))
2101 * We will issue a list command to get a remote directory.
2103 static void get_dir_list(int argc
, char *argv
[])
2105 char *src
, *host
, *user
;
2111 /* Separate host from filename */
2115 bump("Local to local copy not supported");
2119 /* Substitute "." for empty filename */
2121 /* Separate username and hostname */
2123 host
= strrchr(host
, '@');
2133 cmd
= smalloc(4 * strlen(src
) + 100);
2134 strcpy(cmd
, "ls -la '");
2135 p
= cmd
+ strlen(cmd
);
2136 for (q
= src
; *q
; q
++) {
2149 do_cmd(host
, user
, cmd
);
2153 scp_sftp_listdir(src
);
2155 while (ssh_scp_recv(&c
, 1) > 0)
2156 tell_char(stdout
, c
);
2161 * Initialize the Win$ock driver.
2163 static void init_winsock(void)
2168 winsock_ver
= MAKEWORD(1, 1);
2169 if (WSAStartup(winsock_ver
, &wsadata
))
2170 bump("Unable to initialise WinSock");
2171 if (LOBYTE(wsadata
.wVersion
) != 1 || HIBYTE(wsadata
.wVersion
) != 1)
2172 bump("WinSock version is incompatible with 1.1");
2176 * Short description of parameters.
2178 static void usage(void)
2180 printf("PuTTY Secure Copy client\n");
2181 printf("%s\n", ver
);
2182 printf("Usage: pscp [options] [user@]host:source target\n");
2184 (" pscp [options] source [source...] [user@]host:target\n");
2185 printf(" pscp [options] -ls user@host:filespec\n");
2186 printf("Options:\n");
2187 printf(" -p preserve file attributes\n");
2188 printf(" -q quiet, don't show statistics\n");
2189 printf(" -r copy directories recursively\n");
2190 printf(" -v show verbose messages\n");
2191 printf(" -P port connect to specified port\n");
2192 printf(" -pw passw login with specified password\n");
2193 printf(" -unsafe allow server-side wildcards (DANGEROUS)\n");
2196 * -gui is an internal option, used by GUI front ends to get
2197 * pscp to pass progress reports back to them. It's not an
2198 * ordinary user-accessible option, so it shouldn't be part of
2199 * the command-line help. The only people who need to know
2200 * about it are programmers, and they can read the source.
2203 (" -gui hWnd GUI mode with the windows handle for receiving messages\n");
2209 * Main program (no, really?)
2211 int main(int argc
, char *argv
[])
2215 default_protocol
= PROT_TELNET
;
2217 flags
= FLAG_STDERR
;
2218 ssh_get_line
= &get_line
;
2222 for (i
= 1; i
< argc
; i
++) {
2223 if (argv
[i
][0] != '-')
2225 if (strcmp(argv
[i
], "-v") == 0)
2226 verbose
= 1, flags
|= FLAG_VERBOSE
;
2227 else if (strcmp(argv
[i
], "-r") == 0)
2229 else if (strcmp(argv
[i
], "-p") == 0)
2231 else if (strcmp(argv
[i
], "-q") == 0)
2233 else if (strcmp(argv
[i
], "-h") == 0 || strcmp(argv
[i
], "-?") == 0)
2235 else if (strcmp(argv
[i
], "-P") == 0 && i
+ 1 < argc
)
2236 portnumber
= atoi(argv
[++i
]);
2237 else if (strcmp(argv
[i
], "-pw") == 0 && i
+ 1 < argc
)
2238 password
= argv
[++i
];
2239 else if (strcmp(argv
[i
], "-gui") == 0 && i
+ 1 < argc
) {
2240 gui_hwnd
= argv
[++i
];
2242 } else if (strcmp(argv
[i
], "-ls") == 0)
2244 else if (strcmp(argv
[i
], "-unsafe") == 0)
2245 scp_unsafe_mode
= 1;
2246 else if (strcmp(argv
[i
], "--") == 0) {
2259 get_dir_list(argc
, argv
);
2266 targetshouldbedirectory
= 1;
2268 if (colon(argv
[argc
- 1]) != NULL
)
2269 toremote(argc
, argv
);
2271 tolocal(argc
, argv
);
2274 if (back
!= NULL
&& back
->socket() != NULL
) {
2276 back
->special(TS_EOF
);
2277 ssh_scp_recv(&ch
, 1);
2282 /* GUI Adaptation - August 2000 */
2284 unsigned int msg_id
= WM_RET_ERR_CNT
;
2286 msg_id
= WM_LS_RET_ERR_CNT
;
2288 ((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) errs
,
2289 0 /*lParam */ ))SleepEx(1000, TRUE
);
2291 return (errs
== 0 ?
0 : 1);