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 char *password
= NULL
;
62 /* GUI Adaptation - Sept 2000 */
63 #define NAME_STR_MAX 2048
64 static char statname
[NAME_STR_MAX
+ 1];
65 static unsigned long statsize
= 0;
66 static int statperct
= 0;
67 static unsigned long statelapsed
= 0;
68 static int gui_mode
= 0;
69 static char *gui_hwnd
= NULL
;
70 static int using_sftp
= 0;
72 static void source(char *src
);
73 static void rsource(char *src
);
74 static void sink(char *targ
, char *src
);
75 /* GUI Adaptation - Sept 2000 */
76 static void tell_char(FILE * stream
, char c
);
77 static void tell_str(FILE * stream
, char *str
);
78 static void tell_user(FILE * stream
, char *fmt
, ...);
79 static void gui_update_stats(char *name
, unsigned long size
,
80 int percentage
, unsigned long elapsed
);
83 * The maximum amount of queued data we accept before we stop and
84 * wait for the server to process some.
86 #define MAX_SCP_BUFSIZE 16384
88 void logevent(char *string
)
92 void ldisc_send(char *buf
, int len
)
95 * This is only here because of the calls to ldisc_send(NULL,
96 * 0) in ssh.c. Nothing in PSCP actually needs to use the ldisc
97 * as an ldisc. So if we get called with any real data, I want
103 void verify_ssh_host_key(char *host
, int port
, char *keytype
,
104 char *keystr
, char *fingerprint
)
110 static const char absentmsg
[] =
111 "The server's host key is not cached in the registry. You\n"
112 "have no guarantee that the server is the computer you\n"
114 "The server's key fingerprint is:\n"
116 "If you trust this host, enter \"y\" to add the key to\n"
117 "PuTTY's cache and carry on connecting.\n"
118 "If you want to carry on connecting just once, without\n"
119 "adding the key to the cache, enter \"n\".\n"
120 "If you do not trust this host, press Return to abandon the\n"
122 "Store key in cache? (y/n) ";
124 static const char wrongmsg
[] =
125 "WARNING - POTENTIAL SECURITY BREACH!\n"
126 "The server's host key does not match the one PuTTY has\n"
127 "cached in the registry. This means that either the\n"
128 "server administrator has changed the host key, or you\n"
129 "have actually connected to another computer pretending\n"
130 "to be the server.\n"
131 "The new key fingerprint is:\n"
133 "If you were expecting this change and trust the new key,\n"
134 "enter \"y\" to update PuTTY's cache and continue connecting.\n"
135 "If you want to carry on connecting but without updating\n"
136 "the cache, enter \"n\".\n"
137 "If you want to abandon the connection completely, press\n"
138 "Return to cancel. Pressing Return is the ONLY guaranteed\n"
140 "Update cached key? (y/n, Return cancels connection) ";
142 static const char abandoned
[] = "Connection abandoned.\n";
147 * Verify the key against the registry.
149 ret
= verify_host_key(host
, port
, keytype
, keystr
);
151 if (ret
== 0) /* success - key matched OK */
154 if (ret
== 2) { /* key was different */
155 fprintf(stderr
, wrongmsg
, fingerprint
);
158 if (ret
== 1) { /* key was absent */
159 fprintf(stderr
, absentmsg
, fingerprint
);
163 hin
= GetStdHandle(STD_INPUT_HANDLE
);
164 GetConsoleMode(hin
, &savemode
);
165 SetConsoleMode(hin
, (savemode
| ENABLE_ECHO_INPUT
|
166 ENABLE_PROCESSED_INPUT
| ENABLE_LINE_INPUT
));
167 ReadFile(hin
, line
, sizeof(line
) - 1, &i
, NULL
);
168 SetConsoleMode(hin
, savemode
);
170 if (line
[0] != '\0' && line
[0] != '\r' && line
[0] != '\n') {
171 if (line
[0] == 'y' || line
[0] == 'Y')
172 store_host_key(host
, port
, keytype
, keystr
);
174 fprintf(stderr
, abandoned
);
180 * Ask whether the selected cipher is acceptable (since it was
181 * below the configured 'warn' threshold).
182 * cs: 0 = both ways, 1 = client->server, 2 = server->client
184 void askcipher(char *ciphername
, int cs
)
189 static const char msg
[] =
190 "The first %scipher supported by the server is\n"
191 "%s, which is below the configured warning threshold.\n"
192 "Continue with connection? (y/n) ";
193 static const char abandoned
[] = "Connection abandoned.\n";
199 (cs
== 1) ?
"client-to-server " :
204 hin
= GetStdHandle(STD_INPUT_HANDLE
);
205 GetConsoleMode(hin
, &savemode
);
206 SetConsoleMode(hin
, (savemode
| ENABLE_ECHO_INPUT
|
207 ENABLE_PROCESSED_INPUT
| ENABLE_LINE_INPUT
));
208 ReadFile(hin
, line
, sizeof(line
) - 1, &i
, NULL
);
209 SetConsoleMode(hin
, savemode
);
211 if (line
[0] == 'y' || line
[0] == 'Y') {
214 fprintf(stderr
, abandoned
);
219 /* GUI Adaptation - Sept 2000 */
220 static void send_msg(HWND h
, UINT message
, WPARAM wParam
)
222 while (!PostMessage(h
, message
, wParam
, 0))
226 static void tell_char(FILE * stream
, char c
)
231 unsigned int msg_id
= WM_STD_OUT_CHAR
;
232 if (stream
== stderr
)
233 msg_id
= WM_STD_ERR_CHAR
;
234 send_msg((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) c
);
238 static void tell_str(FILE * stream
, char *str
)
242 for (i
= 0; i
< strlen(str
); ++i
)
243 tell_char(stream
, str
[i
]);
246 static void tell_user(FILE * stream
, char *fmt
, ...)
248 char str
[0x100]; /* Make the size big enough */
251 vsprintf(str
, fmt
, ap
);
254 tell_str(stream
, str
);
257 static void gui_update_stats(char *name
, unsigned long size
,
258 int percentage
, unsigned long elapsed
)
262 if (strcmp(name
, statname
) != 0) {
263 for (i
= 0; i
< strlen(name
); ++i
)
264 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_CHAR
,
266 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_CHAR
, (WPARAM
) '\n');
267 strcpy(statname
, name
);
269 if (statsize
!= size
) {
270 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_SIZE
, (WPARAM
) size
);
273 if (statelapsed
!= elapsed
) {
274 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_ELAPSED
,
276 statelapsed
= elapsed
;
278 if (statperct
!= percentage
) {
279 send_msg((HWND
) atoi(gui_hwnd
), WM_STATS_PERCENT
,
280 (WPARAM
) percentage
);
281 statperct
= percentage
;
286 * Print an error message and perform a fatal exit.
288 void fatalbox(char *fmt
, ...)
290 char str
[0x100]; /* Make the size big enough */
293 strcpy(str
, "Fatal: ");
294 vsprintf(str
+ strlen(str
), fmt
, ap
);
297 tell_str(stderr
, str
);
301 unsigned int msg_id
= WM_RET_ERR_CNT
;
303 msg_id
= WM_LS_RET_ERR_CNT
;
305 ((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) errs
,
306 0 /*lParam */ ))SleepEx(1000, TRUE
);
311 void connection_fatal(char *fmt
, ...)
313 char str
[0x100]; /* Make the size big enough */
316 strcpy(str
, "Fatal: ");
317 vsprintf(str
+ strlen(str
), fmt
, ap
);
320 tell_str(stderr
, str
);
324 unsigned int msg_id
= WM_RET_ERR_CNT
;
326 msg_id
= WM_LS_RET_ERR_CNT
;
328 ((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) errs
,
329 0 /*lParam */ ))SleepEx(1000, TRUE
);
336 * Be told what socket we're supposed to be using.
338 static SOCKET scp_ssh_socket
;
339 char *do_select(SOCKET skt
, int startup
)
342 scp_ssh_socket
= skt
;
344 scp_ssh_socket
= INVALID_SOCKET
;
347 extern int select_result(WPARAM
, LPARAM
);
350 * Receive a block of data from the SSH link. Block until all data
353 * To do this, we repeatedly call the SSH protocol module, with our
354 * own trap in from_backend() to catch the data that comes back. We
355 * do this until we have enough data.
358 static unsigned char *outptr
; /* where to put the data */
359 static unsigned outlen
; /* how much data required */
360 static unsigned char *pending
= NULL
; /* any spare data */
361 static unsigned pendlen
= 0, pendsize
= 0; /* length and phys. size of buffer */
362 int from_backend(int is_stderr
, char *data
, int datalen
)
364 unsigned char *p
= (unsigned char *) data
;
365 unsigned len
= (unsigned) datalen
;
368 * stderr data is just spouted to local stderr and otherwise
372 fwrite(data
, 1, len
, stderr
);
379 * If this is before the real session begins, just return.
385 unsigned used
= outlen
;
388 memcpy(outptr
, p
, used
);
396 if (pendsize
< pendlen
+ len
) {
397 pendsize
= pendlen
+ len
+ 4096;
398 pending
= (pending ?
srealloc(pending
, pendsize
) :
401 fatalbox("Out of memory");
403 memcpy(pending
+ pendlen
, p
, len
);
409 static int scp_process_network_event(void)
414 FD_SET(scp_ssh_socket
, &readfds
);
415 if (select(1, &readfds
, NULL
, NULL
, NULL
) < 0)
417 select_result((WPARAM
) scp_ssh_socket
, (LPARAM
) FD_READ
);
420 static int ssh_scp_recv(unsigned char *buf
, int len
)
426 * See if the pending-input block contains some of what we
430 unsigned pendused
= pendlen
;
431 if (pendused
> outlen
)
433 memcpy(outptr
, pending
, pendused
);
434 memmove(pending
, pending
+ pendused
, pendlen
- pendused
);
448 if (!scp_process_network_event())
456 * Loop through the ssh connection and authentication process.
458 static void ssh_scp_init(void)
460 if (scp_ssh_socket
== INVALID_SOCKET
)
462 while (!back
->sendok()) {
465 FD_SET(scp_ssh_socket
, &readfds
);
466 if (select(1, &readfds
, NULL
, NULL
, NULL
) < 0)
468 select_result((WPARAM
) scp_ssh_socket
, (LPARAM
) FD_READ
);
470 using_sftp
= !ssh_fallback_cmd
;
474 * Print an error message and exit after closing the SSH link.
476 static void bump(char *fmt
, ...)
478 char str
[0x100]; /* Make the size big enough */
481 strcpy(str
, "Fatal: ");
482 vsprintf(str
+ strlen(str
), fmt
, ap
);
485 tell_str(stderr
, str
);
488 if (back
!= NULL
&& back
->socket() != NULL
) {
490 back
->special(TS_EOF
);
491 ssh_scp_recv(&ch
, 1);
495 unsigned int msg_id
= WM_RET_ERR_CNT
;
497 msg_id
= WM_LS_RET_ERR_CNT
;
499 ((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) errs
,
500 0 /*lParam */ ))SleepEx(1000, TRUE
);
506 static int get_line(const char *prompt
, char *str
, int maxlen
, int is_pw
)
509 DWORD savemode
, newmode
, i
;
511 if (is_pw
&& password
) {
512 static int tried_once
= 0;
517 strncpy(str
, password
, maxlen
);
518 str
[maxlen
- 1] = '\0';
524 /* GUI Adaptation - Sept 2000 */
529 hin
= GetStdHandle(STD_INPUT_HANDLE
);
530 hout
= GetStdHandle(STD_OUTPUT_HANDLE
);
531 if (hin
== INVALID_HANDLE_VALUE
|| hout
== INVALID_HANDLE_VALUE
)
532 bump("Cannot get standard input/output handles");
534 GetConsoleMode(hin
, &savemode
);
535 newmode
= savemode
| ENABLE_PROCESSED_INPUT
| ENABLE_LINE_INPUT
;
537 newmode
&= ~ENABLE_ECHO_INPUT
;
539 newmode
|= ENABLE_ECHO_INPUT
;
540 SetConsoleMode(hin
, newmode
);
542 WriteFile(hout
, prompt
, strlen(prompt
), &i
, NULL
);
543 ReadFile(hin
, str
, maxlen
- 1, &i
, NULL
);
545 SetConsoleMode(hin
, savemode
);
547 if ((int) i
> maxlen
)
554 WriteFile(hout
, "\r\n", 2, &i
, NULL
);
561 * Open an SSH connection to user@host and execute cmd.
563 static void do_cmd(char *host
, char *user
, char *cmd
)
565 char *err
, *realhost
;
568 if (host
== NULL
|| host
[0] == '\0')
569 bump("Empty host name");
571 /* Try to load settings for this host */
572 do_defaults(host
, &cfg
);
573 if (cfg
.host
[0] == '\0') {
574 /* No settings for this host; use defaults */
575 do_defaults(NULL
, &cfg
);
576 strncpy(cfg
.host
, host
, sizeof(cfg
.host
) - 1);
577 cfg
.host
[sizeof(cfg
.host
) - 1] = '\0';
582 if (user
!= NULL
&& user
[0] != '\0') {
583 strncpy(cfg
.username
, user
, sizeof(cfg
.username
) - 1);
584 cfg
.username
[sizeof(cfg
.username
) - 1] = '\0';
585 } else if (cfg
.username
[0] == '\0') {
587 if (GetUserName(user
, &namelen
) == FALSE
)
588 bump("Empty user name");
589 user
= smalloc(namelen
* sizeof(char));
590 GetUserName(user
, &namelen
);
592 tell_user(stderr
, "Guessing user name: %s", user
);
593 strncpy(cfg
.username
, user
, sizeof(cfg
.username
) - 1);
594 cfg
.username
[sizeof(cfg
.username
) - 1] = '\0';
598 if (cfg
.protocol
!= PROT_SSH
)
602 cfg
.port
= portnumber
;
605 * Attempt to start the SFTP subsystem as a first choice,
606 * falling back to the provided scp command if that fails.
608 strcpy(cfg
.remote_cmd
, "sftp");
609 cfg
.ssh_subsys
= TRUE
;
610 cfg
.remote_cmd_ptr2
= cmd
;
611 cfg
.ssh_subsys2
= FALSE
;
616 err
= back
->init(cfg
.host
, cfg
.port
, &realhost
);
618 bump("ssh_init: %s", err
);
620 if (verbose
&& realhost
!= NULL
)
621 tell_user(stderr
, "Connected to %s\n", realhost
);
626 * Update statistic information about current file.
628 static void print_stats(char *name
, unsigned long size
, unsigned long done
,
629 time_t start
, time_t now
)
637 /* GUI Adaptation - Sept 2000 */
639 gui_update_stats(name
, size
, (int) (100 * (done
* 1.0 / size
)),
640 (unsigned long) difftime(now
, start
));
643 ratebs
= (float) done
/ (now
- start
);
645 ratebs
= (float) done
;
650 eta
= (unsigned long) ((size
- done
) / ratebs
);
651 sprintf(etastr
, "%02ld:%02ld:%02ld",
652 eta
/ 3600, (eta
% 3600) / 60, eta
% 60);
654 pct
= (int) (100.0 * (float) done
/ size
);
656 len
= printf("\r%-25.25s | %10ld kB | %5.1f kB/s | ETA: %8s | %3d%%",
657 name
, done
/ 1024, ratebs
/ 1024.0, etastr
, pct
);
658 if (len
< prev_stats_len
)
659 printf("%*s", prev_stats_len
- len
, "");
660 prev_stats_len
= len
;
668 * Find a colon in str and return a pointer to the colon.
669 * This is used to separate hostname from filename.
671 static char *colon(char *str
)
673 /* We ignore a leading colon, since the hostname cannot be
674 empty. We also ignore a colon as second character because
675 of filenames like f:myfile.txt. */
676 if (str
[0] == '\0' || str
[0] == ':' || str
[1] == ':')
678 while (*str
!= '\0' && *str
!= ':' && *str
!= '/' && *str
!= '\\')
687 * Return a pointer to the portion of str that comes after the last
688 * slash or backslash.
690 static char *stripslashes(char *str
)
694 p
= strrchr(str
, '/');
697 p
= strrchr(str
, '\\');
704 * Determine whether a string is entirely composed of dots.
706 static int is_dots(char *str
)
708 return str
[strspn(str
, ".")] == '\0';
712 * Wait for a response from the other side.
713 * Return 0 if ok, -1 if error.
715 static int response(void)
717 char ch
, resp
, rbuf
[2048];
720 if (ssh_scp_recv(&resp
, 1) <= 0)
721 bump("Lost connection");
731 case 2: /* fatal error */
733 if (ssh_scp_recv(&ch
, 1) <= 0)
734 bump("Protocol error: Lost connection");
736 } while (p
< sizeof(rbuf
) && ch
!= '\n');
739 tell_user(stderr
, "%s\n", rbuf
);
747 int sftp_recvdata(char *buf
, int len
)
749 return ssh_scp_recv(buf
, len
);
751 int sftp_senddata(char *buf
, int len
)
753 back
->send((unsigned char *) buf
, len
);
757 /* ----------------------------------------------------------------------
758 * sftp-based replacement for the hacky `pscp -ls'.
760 static int sftp_ls_compare(const void *av
, const void *bv
)
762 const struct fxp_name
*a
= (const struct fxp_name
*) av
;
763 const struct fxp_name
*b
= (const struct fxp_name
*) bv
;
764 return strcmp(a
->filename
, b
->filename
);
766 void scp_sftp_listdir(char *dirname
)
768 struct fxp_handle
*dirh
;
769 struct fxp_names
*names
;
770 struct fxp_name
*ournames
;
771 int nnames
, namesize
;
775 printf("Listing directory %s\n", dirname
);
777 dirh
= fxp_opendir(dirname
);
779 printf("Unable to open %s: %s\n", dir
, fxp_error());
781 nnames
= namesize
= 0;
786 names
= fxp_readdir(dirh
);
788 if (fxp_error_type() == SSH_FX_EOF
)
790 printf("Reading directory %s: %s\n", dir
, fxp_error());
793 if (names
->nnames
== 0) {
794 fxp_free_names(names
);
798 if (nnames
+ names
->nnames
>= namesize
) {
799 namesize
+= names
->nnames
+ 128;
801 srealloc(ournames
, namesize
* sizeof(*ournames
));
804 for (i
= 0; i
< names
->nnames
; i
++)
805 ournames
[nnames
++] = names
->names
[i
];
807 names
->nnames
= 0; /* prevent free_names */
808 fxp_free_names(names
);
813 * Now we have our filenames. Sort them by actual file
814 * name, and then output the longname parts.
816 qsort(ournames
, nnames
, sizeof(*ournames
), sftp_ls_compare
);
821 for (i
= 0; i
< nnames
; i
++)
822 printf("%s\n", ournames
[i
].longname
);
826 /* ----------------------------------------------------------------------
827 * Helper routines that contain the actual SCP protocol elements,
828 * implemented both as SCP1 and SFTP.
831 static struct scp_sftp_dirstack
{
832 struct scp_sftp_dirstack
*next
;
833 struct fxp_name
*names
;
834 int namepos
, namelen
;
836 } *scp_sftp_dirstack_head
;
837 static char *scp_sftp_remotepath
, *scp_sftp_currentname
;
838 static int scp_sftp_targetisdir
, scp_sftp_donethistarget
;
839 static int scp_sftp_preserve
, scp_sftp_recursive
;
840 static unsigned long scp_sftp_mtime
, scp_sftp_atime
;
841 static int scp_has_times
;
842 static struct fxp_handle
*scp_sftp_filehandle
;
843 static uint64 scp_sftp_fileoffset
;
845 void scp_source_setup(char *target
, int shouldbedir
)
849 * Find out whether the target filespec is in fact a
852 struct fxp_attrs attrs
;
854 if (!fxp_stat(target
, &attrs
) ||
855 !(attrs
.flags
& SSH_FILEXFER_ATTR_PERMISSIONS
))
856 scp_sftp_targetisdir
= 0;
858 scp_sftp_targetisdir
= (attrs
.permissions
& 0040000) != 0;
860 if (shouldbedir
&& !scp_sftp_targetisdir
) {
861 bump("pscp: remote filespec %s: not a directory\n", target
);
864 scp_sftp_remotepath
= dupstr(target
);
872 int scp_send_errmsg(char *str
)
875 /* do nothing; we never need to send our errors to the server */
877 back
->send("\001", 1); /* scp protocol error prefix */
878 back
->send(str
, strlen(str
));
880 return 0; /* can't fail */
883 int scp_send_filetimes(unsigned long mtime
, unsigned long atime
)
886 scp_sftp_mtime
= mtime
;
887 scp_sftp_atime
= atime
;
892 sprintf(buf
, "T%lu 0 %lu 0\n", mtime
, atime
);
893 back
->send(buf
, strlen(buf
));
898 int scp_send_filename(char *name
, unsigned long size
, int modes
)
902 if (scp_sftp_targetisdir
) {
903 fullname
= dupcat(scp_sftp_remotepath
, "/", name
, NULL
);
905 fullname
= dupstr(scp_sftp_remotepath
);
907 scp_sftp_filehandle
=
908 fxp_open(fullname
, SSH_FXF_WRITE
| SSH_FXF_CREAT
| SSH_FXF_TRUNC
);
909 if (!scp_sftp_filehandle
) {
910 tell_user(stderr
, "pscp: unable to open %s: %s",
911 fullname
, fxp_error());
915 scp_sftp_fileoffset
= uint64_make(0, 0);
920 sprintf(buf
, "C%04o %lu ", modes
, size
);
921 back
->send(buf
, strlen(buf
));
922 back
->send(name
, strlen(name
));
928 int scp_send_filedata(char *data
, int len
)
931 if (!scp_sftp_filehandle
) {
934 if (!fxp_write(scp_sftp_filehandle
, data
, scp_sftp_fileoffset
, len
)) {
935 tell_user(stderr
, "error while writing: %s\n", fxp_error());
939 scp_sftp_fileoffset
= uint64_add32(scp_sftp_fileoffset
, len
);
942 int bufsize
= back
->send(data
, len
);
945 * If the network transfer is backing up - that is, the
946 * remote site is not accepting data as fast as we can
947 * produce it - then we must loop on network events until
948 * we have space in the buffer again.
950 while (bufsize
> MAX_SCP_BUFSIZE
) {
951 if (!scp_process_network_event())
953 bufsize
= back
->sendbuffer();
960 int scp_send_finish(void)
963 struct fxp_attrs attrs
;
964 if (!scp_sftp_filehandle
) {
968 attrs
.flags
= SSH_FILEXFER_ATTR_ACMODTIME
;
969 attrs
.atime
= scp_sftp_atime
;
970 attrs
.mtime
= scp_sftp_mtime
;
971 if (!fxp_fsetstat(scp_sftp_filehandle
, attrs
)) {
972 tell_user(stderr
, "unable to set file times: %s\n", fxp_error());
976 fxp_close(scp_sftp_filehandle
);
985 char *scp_save_remotepath(void)
988 return scp_sftp_remotepath
;
993 void scp_restore_remotepath(char *data
)
996 scp_sftp_remotepath
= data
;
999 int scp_send_dirname(char *name
, int modes
)
1004 struct fxp_attrs attrs
;
1005 if (scp_sftp_targetisdir
) {
1006 fullname
= dupcat(scp_sftp_remotepath
, "/", name
, NULL
);
1008 fullname
= dupstr(scp_sftp_remotepath
);
1012 * We don't worry about whether we managed to create the
1013 * directory, because if it exists already it's OK just to
1014 * use it. Instead, we will stat it afterwards, and if it
1015 * exists and is a directory we will assume we were either
1016 * successful or it didn't matter.
1018 if (!fxp_mkdir(fullname
))
1021 err
= "server reported no error";
1022 if (!fxp_stat(fullname
, &attrs
) ||
1023 !(attrs
.flags
& SSH_FILEXFER_ATTR_PERMISSIONS
) ||
1024 !(attrs
.permissions
& 0040000)) {
1025 tell_user(stderr
, "unable to create directory %s: %s",
1031 scp_sftp_remotepath
= fullname
;
1036 sprintf(buf
, "D%04o 0 ", modes
);
1037 back
->send(buf
, strlen(buf
));
1038 back
->send(name
, strlen(name
));
1039 back
->send("\n", 1);
1044 int scp_send_enddir(void)
1047 sfree(scp_sftp_remotepath
);
1050 back
->send("E\n", 2);
1056 * Yes, I know; I have an scp_sink_setup _and_ an scp_sink_init.
1057 * That's bad. The difference is that scp_sink_setup is called once
1058 * right at the start, whereas scp_sink_init is called to
1059 * initialise every level of recursion in the protocol.
1061 void scp_sink_setup(char *source
, int preserve
, int recursive
)
1064 scp_sftp_remotepath
= dupstr(source
);
1065 scp_sftp_preserve
= preserve
;
1066 scp_sftp_recursive
= recursive
;
1067 scp_sftp_donethistarget
= 0;
1068 scp_sftp_dirstack_head
= NULL
;
1072 int scp_sink_init(void)
1080 #define SCP_SINK_FILE 1
1081 #define SCP_SINK_DIR 2
1082 #define SCP_SINK_ENDDIR 3
1083 struct scp_sink_action
{
1084 int action
; /* FILE, DIR, ENDDIR */
1085 char *buf
; /* will need freeing after use */
1086 char *name
; /* filename or dirname (not ENDDIR) */
1087 int mode
; /* access mode (not ENDDIR) */
1088 unsigned long size
; /* file size (not ENDDIR) */
1089 int settime
; /* 1 if atime and mtime are filled */
1090 unsigned long atime
, mtime
; /* access times for the file */
1093 int scp_get_sink_action(struct scp_sink_action
*act
)
1097 int must_free_fname
;
1098 struct fxp_attrs attrs
;
1101 if (!scp_sftp_dirstack_head
) {
1102 if (!scp_sftp_donethistarget
) {
1104 * Simple case: we are only dealing with one file.
1106 fname
= scp_sftp_remotepath
;
1107 must_free_fname
= 0;
1108 scp_sftp_donethistarget
= 1;
1111 * Even simpler case: one file _which we've done_.
1112 * Return 1 (finished).
1118 * We're now in the middle of stepping through a list
1119 * of names returned from fxp_readdir(); so let's carry
1122 struct scp_sftp_dirstack
*head
= scp_sftp_dirstack_head
;
1123 while (head
->namepos
< head
->namelen
&&
1124 is_dots(head
->names
[head
->namepos
].filename
))
1125 head
->namepos
++; /* skip . and .. */
1126 if (head
->namepos
< head
->namelen
) {
1127 fname
= dupcat(head
->dirpath
, "/",
1128 head
->names
[head
->namepos
++].filename
,
1130 must_free_fname
= 1;
1133 * We've come to the end of the list; pop it off
1134 * the stack and return an ENDDIR action.
1137 sfree(head
->dirpath
);
1139 scp_sftp_dirstack_head
= head
->next
;
1142 act
->action
= SCP_SINK_ENDDIR
;
1148 * Now we have a filename. Stat it, and see if it's a file
1151 ret
= fxp_stat(fname
, &attrs
);
1152 if (!ret
|| !(attrs
.flags
& SSH_FILEXFER_ATTR_PERMISSIONS
)) {
1153 tell_user(stderr
, "unable to identify %s: %s", fname
,
1154 ret ?
"file type not supplied" : fxp_error());
1159 if (attrs
.permissions
& 0040000) {
1160 struct scp_sftp_dirstack
*newitem
;
1161 struct fxp_handle
*dirhandle
;
1162 int nnames
, namesize
;
1163 struct fxp_name
*ournames
;
1164 struct fxp_names
*names
;
1167 * It's a directory. If we're not in recursive
1168 * mode, this just merits a complaint.
1170 if (!scp_sftp_recursive
) {
1171 tell_user(stderr
, "pscp: %s: is a directory", fname
);
1173 if (must_free_fname
) sfree(fname
);
1178 * Otherwise, the fun begins. We must fxp_opendir() the
1179 * directory, slurp the filenames into memory, return
1180 * SCP_SINK_DIR, and set targetisdir. The next time
1181 * we're called, we will run through the list of
1182 * filenames one by one.
1184 * If targetisdir is _already_ set (meaning we're
1185 * already in the middle of going through another such
1186 * list), we must push the other (target,namelist) pair
1189 dirhandle
= fxp_opendir(fname
);
1191 tell_user(stderr
, "scp: unable to open directory %s: %s",
1192 fname
, fxp_error());
1193 if (must_free_fname
) sfree(fname
);
1197 nnames
= namesize
= 0;
1202 names
= fxp_readdir(dirhandle
);
1203 if (names
== NULL
) {
1204 if (fxp_error_type() == SSH_FX_EOF
)
1206 tell_user(stderr
, "scp: reading directory %s: %s\n",
1207 fname
, fxp_error());
1208 if (must_free_fname
) sfree(fname
);
1213 if (names
->nnames
== 0) {
1214 fxp_free_names(names
);
1217 if (nnames
+ names
->nnames
>= namesize
) {
1218 namesize
+= names
->nnames
+ 128;
1220 srealloc(ournames
, namesize
* sizeof(*ournames
));
1222 for (i
= 0; i
< names
->nnames
; i
++)
1223 ournames
[nnames
++] = names
->names
[i
];
1224 names
->nnames
= 0; /* prevent free_names */
1225 fxp_free_names(names
);
1227 fxp_close(dirhandle
);
1229 newitem
= smalloc(sizeof(struct scp_sftp_dirstack
));
1230 newitem
->next
= scp_sftp_dirstack_head
;
1231 newitem
->names
= ournames
;
1232 newitem
->namepos
= 0;
1233 newitem
->namelen
= nnames
;
1234 if (must_free_fname
)
1235 newitem
->dirpath
= fname
;
1237 newitem
->dirpath
= dupstr(fname
);
1238 scp_sftp_dirstack_head
= newitem
;
1240 act
->action
= SCP_SINK_DIR
;
1241 act
->buf
= dupstr(stripslashes(fname
));
1242 act
->name
= act
->buf
;
1243 act
->size
= 0; /* duhh, it's a directory */
1244 act
->mode
= 07777 & attrs
.permissions
;
1245 if (scp_sftp_preserve
&&
1246 (attrs
.flags
& SSH_FILEXFER_ATTR_ACMODTIME
)) {
1247 act
->atime
= attrs
.atime
;
1248 act
->mtime
= attrs
.mtime
;
1256 * It's a file. Return SCP_SINK_FILE.
1258 act
->action
= SCP_SINK_FILE
;
1259 act
->buf
= dupstr(stripslashes(fname
));
1260 act
->name
= act
->buf
;
1261 if (attrs
.flags
& SSH_FILEXFER_ATTR_SIZE
) {
1262 if (uint64_compare(attrs
.size
,
1263 uint64_make(0, ULONG_MAX
)) > 0) {
1264 act
->size
= ULONG_MAX
; /* *boggle* */
1266 act
->size
= attrs
.size
.lo
;
1268 act
->size
= ULONG_MAX
; /* no idea */
1269 act
->mode
= 07777 & attrs
.permissions
;
1270 if (scp_sftp_preserve
&&
1271 (attrs
.flags
& SSH_FILEXFER_ATTR_ACMODTIME
)) {
1272 act
->atime
= attrs
.atime
;
1273 act
->mtime
= attrs
.mtime
;
1277 if (must_free_fname
)
1278 scp_sftp_currentname
= fname
;
1280 scp_sftp_currentname
= dupstr(fname
);
1295 if (ssh_scp_recv(&ch
, 1) <= 0)
1298 bump("Protocol error: Unexpected newline");
1302 if (ssh_scp_recv(&ch
, 1) <= 0)
1303 bump("Lost connection");
1306 act
->buf
= srealloc(act
->buf
, bufsize
);
1309 } while (ch
!= '\n');
1310 act
->buf
[i
- 1] = '\0';
1312 case '\01': /* error */
1313 tell_user(stderr
, "%s\n", act
->buf
);
1315 continue; /* go round again */
1316 case '\02': /* fatal error */
1317 bump("%s", act
->buf
);
1320 act
->action
= SCP_SINK_ENDDIR
;
1323 if (sscanf(act
->buf
, "%ld %*d %ld %*d",
1324 &act
->mtime
, &act
->atime
) == 2) {
1327 continue; /* go round again */
1329 bump("Protocol error: Illegal time format");
1332 act
->action
= (action
== 'C' ? SCP_SINK_FILE
: SCP_SINK_DIR
);
1335 bump("Protocol error: Expected control record");
1338 * We will go round this loop only once, unless we hit
1345 * If we get here, we must have seen SCP_SINK_FILE or
1348 if (sscanf(act
->buf
, "%o %lu %n", &act
->mode
, &act
->size
, &i
) != 2)
1349 bump("Protocol error: Illegal file descriptor format");
1350 act
->name
= act
->buf
+ i
;
1355 int scp_accept_filexfer(void)
1358 scp_sftp_filehandle
=
1359 fxp_open(scp_sftp_currentname
, SSH_FXF_READ
);
1360 if (!scp_sftp_filehandle
) {
1361 tell_user(stderr
, "pscp: unable to open %s: %s",
1362 scp_sftp_currentname
, fxp_error());
1366 scp_sftp_fileoffset
= uint64_make(0, 0);
1367 sfree(scp_sftp_currentname
);
1371 return 0; /* can't fail */
1375 int scp_recv_filedata(char *data
, int len
)
1378 int actuallen
= fxp_read(scp_sftp_filehandle
, data
,
1379 scp_sftp_fileoffset
, len
);
1380 if (actuallen
== -1 && fxp_error_type() != SSH_FX_EOF
) {
1381 tell_user(stderr
, "pscp: error while reading: %s", fxp_error());
1388 scp_sftp_fileoffset
= uint64_add32(scp_sftp_fileoffset
, actuallen
);
1392 return ssh_scp_recv(data
, len
);
1396 int scp_finish_filerecv(void)
1399 fxp_close(scp_sftp_filehandle
);
1407 /* ----------------------------------------------------------------------
1408 * Send an error message to the other side and to the screen.
1409 * Increment error counter.
1411 static void run_err(const char *fmt
, ...)
1417 strcpy(str
, "scp: ");
1418 vsprintf(str
+ strlen(str
), fmt
, ap
);
1420 scp_send_errmsg(str
);
1421 tell_user(stderr
, "%s", str
);
1426 * Execute the source part of the SCP protocol.
1428 static void source(char *src
)
1435 unsigned long stat_bytes
;
1436 time_t stat_starttime
, stat_lasttime
;
1438 attr
= GetFileAttributes(src
);
1439 if (attr
== (DWORD
) - 1) {
1440 run_err("%s: No such file or directory", src
);
1444 if ((attr
& FILE_ATTRIBUTE_DIRECTORY
) != 0) {
1447 * Avoid . and .. directories.
1450 p
= strrchr(src
, '/');
1452 p
= strrchr(src
, '\\');
1457 if (!strcmp(p
, ".") || !strcmp(p
, ".."))
1458 /* skip . and .. */ ;
1462 run_err("%s: not a regular file", src
);
1467 if ((last
= strrchr(src
, '/')) == NULL
)
1471 if (strrchr(last
, '\\') != NULL
)
1472 last
= strrchr(last
, '\\') + 1;
1473 if (last
== src
&& strchr(src
, ':') != NULL
)
1474 last
= strchr(src
, ':') + 1;
1476 f
= CreateFile(src
, GENERIC_READ
, FILE_SHARE_READ
, NULL
,
1477 OPEN_EXISTING
, 0, 0);
1478 if (f
== INVALID_HANDLE_VALUE
) {
1479 run_err("%s: Cannot open file", src
);
1484 FILETIME actime
, wrtime
;
1485 unsigned long mtime
, atime
;
1486 GetFileTime(f
, NULL
, &actime
, &wrtime
);
1487 TIME_WIN_TO_POSIX(actime
, atime
);
1488 TIME_WIN_TO_POSIX(wrtime
, mtime
);
1489 if (scp_send_filetimes(mtime
, atime
))
1493 size
= GetFileSize(f
, NULL
);
1495 tell_user(stderr
, "Sending file %s, size=%lu", last
, size
);
1496 if (scp_send_filename(last
, size
, 0644))
1500 stat_starttime
= time(NULL
);
1503 for (i
= 0; i
< size
; i
+= 4096) {
1504 char transbuf
[4096];
1509 if (!ReadFile(f
, transbuf
, k
, &j
, NULL
) || j
!= k
) {
1512 bump("%s: Read error", src
);
1514 if (scp_send_filedata(transbuf
, k
))
1515 bump("%s: Network error occurred", src
);
1519 if (time(NULL
) != stat_lasttime
|| i
+ k
== size
) {
1520 stat_lasttime
= time(NULL
);
1521 print_stats(last
, size
, stat_bytes
,
1522 stat_starttime
, stat_lasttime
);
1529 (void) scp_send_finish();
1533 * Recursively send the contents of a directory.
1535 static void rsource(char *src
)
1537 char *last
, *findfile
;
1540 WIN32_FIND_DATA fdat
;
1543 if ((last
= strrchr(src
, '/')) == NULL
)
1547 if (strrchr(last
, '\\') != NULL
)
1548 last
= strrchr(last
, '\\') + 1;
1549 if (last
== src
&& strchr(src
, ':') != NULL
)
1550 last
= strchr(src
, ':') + 1;
1552 /* maybe send filetime */
1554 save_target
= scp_save_remotepath();
1557 tell_user(stderr
, "Entering directory: %s", last
);
1558 if (scp_send_dirname(last
, 0755))
1561 findfile
= dupcat(src
, "/*", NULL
);
1562 dir
= FindFirstFile(findfile
, &fdat
);
1563 ok
= (dir
!= INVALID_HANDLE_VALUE
);
1565 if (strcmp(fdat
.cFileName
, ".") == 0 ||
1566 strcmp(fdat
.cFileName
, "..") == 0) {
1567 /* ignore . and .. */
1569 char *foundfile
= dupcat(src
, "/", fdat
.cFileName
, NULL
);
1573 ok
= FindNextFile(dir
, &fdat
);
1578 (void) scp_send_enddir();
1580 scp_restore_remotepath(save_target
);
1584 * Execute the sink part of the SCP protocol.
1586 static void sink(char *targ
, char *src
)
1595 unsigned long received
;
1597 unsigned long stat_bytes
;
1598 time_t stat_starttime
, stat_lasttime
;
1601 attr
= GetFileAttributes(targ
);
1602 if (attr
!= (DWORD
) - 1 && (attr
& FILE_ATTRIBUTE_DIRECTORY
) != 0)
1605 if (targetshouldbedirectory
&& !targisdir
)
1606 bump("%s: Not a directory", targ
);
1610 struct scp_sink_action act
;
1611 if (scp_get_sink_action(&act
))
1614 if (act
.action
== SCP_SINK_ENDDIR
)
1619 * Prevent the remote side from maliciously writing to
1620 * files outside the target area by sending a filename
1621 * containing `../'. In fact, it shouldn't be sending
1622 * filenames with any slashes in at all; so we'll find
1623 * the last slash or backslash in the filename and use
1624 * only the part after that. (And warn!)
1626 * In addition, we also ensure here that if we're
1627 * copying a single file and the target is a directory
1628 * (common usage: `pscp host:filename .') the remote
1629 * can't send us a _different_ file name. We can
1630 * distinguish this case because `src' will be non-NULL
1631 * and the last component of that will fail to match
1632 * (the last component of) the name sent.
1634 * (Well, not always; if `src' is a wildcard, we do
1635 * expect to get back filenames that don't correspond
1636 * exactly to it. So we skip this check if `src'
1637 * contains a *, a ? or a []. This is non-ideal - we
1638 * would like to ensure that the returned filename
1639 * actually matches the wildcard pattern - but one of
1640 * SCP's protocol infelicities is that wildcard
1641 * matching is done at the server end _by the server's
1642 * rules_ and so in general this is infeasible. Live
1643 * with it, or upgrade to SFTP.)
1645 char *striptarget
, *stripsrc
;
1647 striptarget
= stripslashes(act
.name
);
1648 if (striptarget
!= act
.name
) {
1649 tell_user(stderr
, "warning: remote host sent a compound"
1650 " pathname - possibly malicious! (ignored)");
1654 * Also check to see if the target filename is '.' or
1655 * '..', or indeed '...' and so on because Windows
1656 * appears to interpret those like '..'.
1658 if (is_dots(striptarget
)) {
1659 bump("security violation: remote host attempted to write to"
1660 " a '.' or '..' path!");
1664 stripsrc
= stripslashes(src
);
1665 if (!stripsrc
[strcspn(stripsrc
, "*?[]")] &&
1666 strcmp(striptarget
, stripsrc
)) {
1667 tell_user(stderr
, "warning: remote host attempted to"
1668 " write to a different filename: disallowing");
1669 /* Override the name the server provided with our own. */
1670 striptarget
= stripsrc
;
1674 if (targ
[0] != '\0')
1675 destfname
= dupcat(targ
, "\\", striptarget
, NULL
);
1677 destfname
= dupstr(striptarget
);
1680 * In this branch of the if, the target area is a
1681 * single file with an explicitly specified name in any
1682 * case, so there's no danger.
1684 destfname
= dupstr(targ
);
1686 attr
= GetFileAttributes(destfname
);
1687 exists
= (attr
!= (DWORD
) - 1);
1689 if (act
.action
== SCP_SINK_DIR
) {
1690 if (exists
&& (attr
& FILE_ATTRIBUTE_DIRECTORY
) == 0) {
1691 run_err("%s: Not a directory", destfname
);
1695 if (!CreateDirectory(destfname
, NULL
)) {
1696 run_err("%s: Cannot create directory", destfname
);
1700 sink(destfname
, NULL
);
1701 /* can we set the timestamp for directories ? */
1705 f
= CreateFile(destfname
, GENERIC_WRITE
, 0, NULL
,
1706 CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, 0);
1707 if (f
== INVALID_HANDLE_VALUE
) {
1708 run_err("%s: Cannot create file", destfname
);
1712 if (scp_accept_filexfer())
1716 stat_starttime
= time(NULL
);
1718 stat_name
= stripslashes(destfname
);
1721 while (received
< act
.size
) {
1722 char transbuf
[4096];
1723 DWORD blksize
, read
, written
;
1725 if (blksize
> act
.size
- received
)
1726 blksize
= act
.size
- received
;
1727 read
= scp_recv_filedata(transbuf
, blksize
);
1729 bump("Lost connection");
1732 if (!WriteFile(f
, transbuf
, read
, &written
, NULL
) ||
1735 /* FIXME: in sftp we can actually abort the transfer */
1737 printf("\r%-25.25s | %50s\n",
1739 "Write error.. waiting for end of file");
1744 if (time(NULL
) > stat_lasttime
||
1745 received
+ read
== act
.size
) {
1746 stat_lasttime
= time(NULL
);
1747 print_stats(stat_name
, act
.size
, stat_bytes
,
1748 stat_starttime
, stat_lasttime
);
1754 FILETIME actime
, wrtime
;
1755 TIME_POSIX_TO_WIN(act
.atime
, actime
);
1756 TIME_POSIX_TO_WIN(act
.mtime
, wrtime
);
1757 SetFileTime(f
, NULL
, &actime
, &wrtime
);
1762 run_err("%s: Write error", destfname
);
1765 (void) scp_finish_filerecv();
1772 * We will copy local files to a remote server.
1774 static void toremote(int argc
, char *argv
[])
1776 char *src
, *targ
, *host
, *user
;
1780 targ
= argv
[argc
- 1];
1782 /* Separate host from filename */
1786 bump("targ == NULL in toremote()");
1790 /* Substitute "." for emtpy target */
1792 /* Separate host and username */
1794 host
= strrchr(host
, '@');
1805 /* Find out if the source filespec covers multiple files
1806 if so, we should set the targetshouldbedirectory flag */
1808 WIN32_FIND_DATA fdat
;
1809 if (colon(argv
[0]) != NULL
)
1810 bump("%s: Remote to remote not supported", argv
[0]);
1811 fh
= FindFirstFile(argv
[0], &fdat
);
1812 if (fh
== INVALID_HANDLE_VALUE
)
1813 bump("%s: No such file or directory\n", argv
[0]);
1814 if (FindNextFile(fh
, &fdat
))
1815 targetshouldbedirectory
= 1;
1819 cmd
= smalloc(strlen(targ
) + 100);
1820 sprintf(cmd
, "scp%s%s%s%s -t %s",
1821 verbose ?
" -v" : "",
1822 recursive ?
" -r" : "",
1823 preserve ?
" -p" : "",
1824 targetshouldbedirectory ?
" -d" : "", targ
);
1825 do_cmd(host
, user
, cmd
);
1828 scp_source_setup(targ
, targetshouldbedirectory
);
1830 for (i
= 0; i
< argc
- 1; i
++) {
1831 char *srcpath
, *last
;
1833 WIN32_FIND_DATA fdat
;
1835 if (colon(src
) != NULL
) {
1836 tell_user(stderr
, "%s: Remote to remote not supported\n", src
);
1842 * Trim off the last pathname component of `src', to
1843 * provide the base pathname which will be prepended to
1844 * filenames returned from Find{First,Next}File.
1846 srcpath
= dupstr(src
);
1847 last
= stripslashes(srcpath
);
1848 if (last
== srcpath
) {
1849 last
= strchr(srcpath
, ':');
1857 dir
= FindFirstFile(src
, &fdat
);
1858 if (dir
== INVALID_HANDLE_VALUE
) {
1859 run_err("%s: No such file or directory", src
);
1866 * Ensure that . and .. are never matched by wildcards,
1867 * but only by deliberate action.
1869 if (!strcmp(fdat
.cFileName
, ".") ||
1870 !strcmp(fdat
.cFileName
, "..")) {
1872 * Find*File has returned a special dir. We require
1873 * that _either_ `src' ends in a backslash followed
1874 * by that string, _or_ `src' is precisely that
1877 int len
= strlen(src
), dlen
= strlen(fdat
.cFileName
);
1878 if (len
== dlen
&& !strcmp(src
, fdat
.cFileName
)) {
1880 } else if (len
> dlen
+ 1 && src
[len
- dlen
- 1] == '\\' &&
1881 !strcmp(src
+ len
- dlen
, fdat
.cFileName
)) {
1884 continue; /* ignore this one */
1886 filename
= dupcat(srcpath
, fdat
.cFileName
, NULL
);
1889 } while (FindNextFile(dir
, &fdat
));
1896 * We will copy files from a remote server to the local machine.
1898 static void tolocal(int argc
, char *argv
[])
1900 char *src
, *targ
, *host
, *user
;
1904 bump("More than one remote source not supported");
1909 /* Separate host from filename */
1913 bump("Local to local copy not supported");
1917 /* Substitute "." for empty filename */
1919 /* Separate username and hostname */
1921 host
= strrchr(host
, '@');
1931 cmd
= smalloc(strlen(src
) + 100);
1932 sprintf(cmd
, "scp%s%s%s%s -f %s",
1933 verbose ?
" -v" : "",
1934 recursive ?
" -r" : "",
1935 preserve ?
" -p" : "",
1936 targetshouldbedirectory ?
" -d" : "", src
);
1937 do_cmd(host
, user
, cmd
);
1940 scp_sink_setup(src
, preserve
, recursive
);
1946 * We will issue a list command to get a remote directory.
1948 static void get_dir_list(int argc
, char *argv
[])
1950 char *src
, *host
, *user
;
1956 /* Separate host from filename */
1960 bump("Local to local copy not supported");
1964 /* Substitute "." for empty filename */
1966 /* Separate username and hostname */
1968 host
= strrchr(host
, '@');
1978 cmd
= smalloc(4 * strlen(src
) + 100);
1979 strcpy(cmd
, "ls -la '");
1980 p
= cmd
+ strlen(cmd
);
1981 for (q
= src
; *q
; q
++) {
1994 do_cmd(host
, user
, cmd
);
1998 scp_sftp_listdir(src
);
2000 while (ssh_scp_recv(&c
, 1) > 0)
2001 tell_char(stdout
, c
);
2006 * Initialize the Win$ock driver.
2008 static void init_winsock(void)
2013 winsock_ver
= MAKEWORD(1, 1);
2014 if (WSAStartup(winsock_ver
, &wsadata
))
2015 bump("Unable to initialise WinSock");
2016 if (LOBYTE(wsadata
.wVersion
) != 1 || HIBYTE(wsadata
.wVersion
) != 1)
2017 bump("WinSock version is incompatible with 1.1");
2021 * Short description of parameters.
2023 static void usage(void)
2025 printf("PuTTY Secure Copy client\n");
2026 printf("%s\n", ver
);
2027 printf("Usage: pscp [options] [user@]host:source target\n");
2029 (" pscp [options] source [source...] [user@]host:target\n");
2030 printf(" pscp [options] -ls user@host:filespec\n");
2031 printf("Options:\n");
2032 printf(" -p preserve file attributes\n");
2033 printf(" -q quiet, don't show statistics\n");
2034 printf(" -r copy directories recursively\n");
2035 printf(" -v show verbose messages\n");
2036 printf(" -P port connect to specified port\n");
2037 printf(" -pw passw login with specified password\n");
2040 * -gui is an internal option, used by GUI front ends to get
2041 * pscp to pass progress reports back to them. It's not an
2042 * ordinary user-accessible option, so it shouldn't be part of
2043 * the command-line help. The only people who need to know
2044 * about it are programmers, and they can read the source.
2047 (" -gui hWnd GUI mode with the windows handle for receiving messages\n");
2053 * Main program (no, really?)
2055 int main(int argc
, char *argv
[])
2059 default_protocol
= PROT_TELNET
;
2061 flags
= FLAG_STDERR
;
2062 ssh_get_line
= &get_line
;
2066 for (i
= 1; i
< argc
; i
++) {
2067 if (argv
[i
][0] != '-')
2069 if (strcmp(argv
[i
], "-v") == 0)
2070 verbose
= 1, flags
|= FLAG_VERBOSE
;
2071 else if (strcmp(argv
[i
], "-r") == 0)
2073 else if (strcmp(argv
[i
], "-p") == 0)
2075 else if (strcmp(argv
[i
], "-q") == 0)
2077 else if (strcmp(argv
[i
], "-h") == 0 || strcmp(argv
[i
], "-?") == 0)
2079 else if (strcmp(argv
[i
], "-P") == 0 && i
+ 1 < argc
)
2080 portnumber
= atoi(argv
[++i
]);
2081 else if (strcmp(argv
[i
], "-pw") == 0 && i
+ 1 < argc
)
2082 password
= argv
[++i
];
2083 else if (strcmp(argv
[i
], "-gui") == 0 && i
+ 1 < argc
) {
2084 gui_hwnd
= argv
[++i
];
2086 } else if (strcmp(argv
[i
], "-ls") == 0)
2088 else if (strcmp(argv
[i
], "--") == 0) {
2101 get_dir_list(argc
, argv
);
2108 targetshouldbedirectory
= 1;
2110 if (colon(argv
[argc
- 1]) != NULL
)
2111 toremote(argc
, argv
);
2113 tolocal(argc
, argv
);
2116 if (back
!= NULL
&& back
->socket() != NULL
) {
2118 back
->special(TS_EOF
);
2119 ssh_scp_recv(&ch
, 1);
2124 /* GUI Adaptation - August 2000 */
2126 unsigned int msg_id
= WM_RET_ERR_CNT
;
2128 msg_id
= WM_LS_RET_ERR_CNT
;
2130 ((HWND
) atoi(gui_hwnd
), msg_id
, (WPARAM
) errs
,
2131 0 /*lParam */ ))SleepEx(1000, TRUE
);
2133 return (errs
== 0 ?
0 : 1);