xref: /freebsd/crypto/openssh/scp.c (revision cce7d3464f90246064915b2a37a95ef8a07c7370)
1cce7d346SDag-Erling Smørgrav /* $OpenBSD: scp.c,v 1.164 2008/10/10 04:55:16 stevesk Exp $ */
2511b41d2SMark Murray /*
3b66f2d16SKris Kennaway  * scp - secure remote copy.  This is basically patched BSD rcp which
4b66f2d16SKris Kennaway  * uses ssh to do the data transfer (instead of using rcmd).
5511b41d2SMark Murray  *
6b66f2d16SKris Kennaway  * NOTE: This version should NOT be suid root.  (This uses ssh to
7b66f2d16SKris Kennaway  * do the transfer and ssh has the necessary privileges.)
8511b41d2SMark Murray  *
9511b41d2SMark Murray  * 1995 Timo Rinne <tri@iki.fi>, Tatu Ylonen <ylo@cs.hut.fi>
10511b41d2SMark Murray  *
11b66f2d16SKris Kennaway  * As far as I am concerned, the code I have written for this software
12b66f2d16SKris Kennaway  * can be used freely for any purpose.  Any derived versions of this
13b66f2d16SKris Kennaway  * software must be clearly marked as such, and if the derived work is
14b66f2d16SKris Kennaway  * incompatible with the protocol description in the RFC file, it must be
15b66f2d16SKris Kennaway  * called by a name other than "ssh" or "Secure Shell".
16b66f2d16SKris Kennaway  */
17b66f2d16SKris Kennaway /*
18b66f2d16SKris Kennaway  * Copyright (c) 1999 Theo de Raadt.  All rights reserved.
19b66f2d16SKris Kennaway  * Copyright (c) 1999 Aaron Campbell.  All rights reserved.
20b66f2d16SKris Kennaway  *
21b66f2d16SKris Kennaway  * Redistribution and use in source and binary forms, with or without
22b66f2d16SKris Kennaway  * modification, are permitted provided that the following conditions
23b66f2d16SKris Kennaway  * are met:
24b66f2d16SKris Kennaway  * 1. Redistributions of source code must retain the above copyright
25b66f2d16SKris Kennaway  *    notice, this list of conditions and the following disclaimer.
26b66f2d16SKris Kennaway  * 2. Redistributions in binary form must reproduce the above copyright
27b66f2d16SKris Kennaway  *    notice, this list of conditions and the following disclaimer in the
28b66f2d16SKris Kennaway  *    documentation and/or other materials provided with the distribution.
29b66f2d16SKris Kennaway  *
30b66f2d16SKris Kennaway  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
31b66f2d16SKris Kennaway  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
32b66f2d16SKris Kennaway  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
33b66f2d16SKris Kennaway  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
34b66f2d16SKris Kennaway  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
35b66f2d16SKris Kennaway  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
36b66f2d16SKris Kennaway  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
37b66f2d16SKris Kennaway  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
38b66f2d16SKris Kennaway  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
39b66f2d16SKris Kennaway  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
40511b41d2SMark Murray  */
41511b41d2SMark Murray 
42511b41d2SMark Murray /*
43b66f2d16SKris Kennaway  * Parts from:
44b66f2d16SKris Kennaway  *
45511b41d2SMark Murray  * Copyright (c) 1983, 1990, 1992, 1993, 1995
46511b41d2SMark Murray  *	The Regents of the University of California.  All rights reserved.
47511b41d2SMark Murray  *
48511b41d2SMark Murray  * Redistribution and use in source and binary forms, with or without
49511b41d2SMark Murray  * modification, are permitted provided that the following conditions
50511b41d2SMark Murray  * are met:
51511b41d2SMark Murray  * 1. Redistributions of source code must retain the above copyright
52511b41d2SMark Murray  *    notice, this list of conditions and the following disclaimer.
53511b41d2SMark Murray  * 2. Redistributions in binary form must reproduce the above copyright
54511b41d2SMark Murray  *    notice, this list of conditions and the following disclaimer in the
55511b41d2SMark Murray  *    documentation and/or other materials provided with the distribution.
56cf2b5f3bSDag-Erling Smørgrav  * 3. Neither the name of the University nor the names of its contributors
57511b41d2SMark Murray  *    may be used to endorse or promote products derived from this software
58511b41d2SMark Murray  *    without specific prior written permission.
59511b41d2SMark Murray  *
60511b41d2SMark Murray  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
61511b41d2SMark Murray  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
62511b41d2SMark Murray  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
63511b41d2SMark Murray  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
64511b41d2SMark Murray  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
65511b41d2SMark Murray  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
66511b41d2SMark Murray  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
67511b41d2SMark Murray  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
68511b41d2SMark Murray  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
69511b41d2SMark Murray  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
70511b41d2SMark Murray  * SUCH DAMAGE.
71511b41d2SMark Murray  *
72511b41d2SMark Murray  */
73511b41d2SMark Murray 
74511b41d2SMark Murray #include "includes.h"
75333ee039SDag-Erling Smørgrav 
76333ee039SDag-Erling Smørgrav #include <sys/types.h>
77333ee039SDag-Erling Smørgrav #include <sys/param.h>
78333ee039SDag-Erling Smørgrav #ifdef HAVE_SYS_STAT_H
79333ee039SDag-Erling Smørgrav # include <sys/stat.h>
80333ee039SDag-Erling Smørgrav #endif
81d4af9e69SDag-Erling Smørgrav #ifdef HAVE_POLL_H
82d4af9e69SDag-Erling Smørgrav #include <poll.h>
83d4af9e69SDag-Erling Smørgrav #else
84d4af9e69SDag-Erling Smørgrav # ifdef HAVE_SYS_POLL_H
85d4af9e69SDag-Erling Smørgrav #  include <sys/poll.h>
86d4af9e69SDag-Erling Smørgrav # endif
87d4af9e69SDag-Erling Smørgrav #endif
88333ee039SDag-Erling Smørgrav #ifdef HAVE_SYS_TIME_H
89333ee039SDag-Erling Smørgrav # include <sys/time.h>
90333ee039SDag-Erling Smørgrav #endif
91333ee039SDag-Erling Smørgrav #include <sys/wait.h>
92333ee039SDag-Erling Smørgrav #include <sys/uio.h>
93333ee039SDag-Erling Smørgrav 
94333ee039SDag-Erling Smørgrav #include <ctype.h>
95333ee039SDag-Erling Smørgrav #include <dirent.h>
96333ee039SDag-Erling Smørgrav #include <errno.h>
97333ee039SDag-Erling Smørgrav #include <fcntl.h>
98333ee039SDag-Erling Smørgrav #include <pwd.h>
99333ee039SDag-Erling Smørgrav #include <signal.h>
100333ee039SDag-Erling Smørgrav #include <stdarg.h>
101333ee039SDag-Erling Smørgrav #include <stdio.h>
102333ee039SDag-Erling Smørgrav #include <stdlib.h>
103333ee039SDag-Erling Smørgrav #include <string.h>
104333ee039SDag-Erling Smørgrav #include <time.h>
105333ee039SDag-Erling Smørgrav #include <unistd.h>
106d4af9e69SDag-Erling Smørgrav #if defined(HAVE_STRNVIS) && defined(HAVE_VIS_H)
107d4af9e69SDag-Erling Smørgrav #include <vis.h>
108d4af9e69SDag-Erling Smørgrav #endif
109511b41d2SMark Murray 
110511b41d2SMark Murray #include "xmalloc.h"
1111e8db6e2SBrian Feldman #include "atomicio.h"
1121e8db6e2SBrian Feldman #include "pathnames.h"
1131e8db6e2SBrian Feldman #include "log.h"
114ae1f160dSDag-Erling Smørgrav #include "misc.h"
115e73e9afaSDag-Erling Smørgrav #include "progressmeter.h"
116511b41d2SMark Murray 
11783d2307dSDag-Erling Smørgrav extern char *__progname;
11883d2307dSDag-Erling Smørgrav 
119d4af9e69SDag-Erling Smørgrav #define COPY_BUFLEN	16384
120d4af9e69SDag-Erling Smørgrav 
121333ee039SDag-Erling Smørgrav int do_cmd(char *host, char *remuser, char *cmd, int *fdin, int *fdout);
122333ee039SDag-Erling Smørgrav 
123e73e9afaSDag-Erling Smørgrav void bwlimit(int);
124511b41d2SMark Murray 
125ae1f160dSDag-Erling Smørgrav /* Struct for addargs */
126ae1f160dSDag-Erling Smørgrav arglist args;
1275b9b2fafSBrian Feldman 
128e73e9afaSDag-Erling Smørgrav /* Bandwidth limit */
1291ec0d754SDag-Erling Smørgrav off_t limit_rate = 0;
130511b41d2SMark Murray 
131511b41d2SMark Murray /* Name of current file being transferred. */
132511b41d2SMark Murray char *curfile;
133511b41d2SMark Murray 
134511b41d2SMark Murray /* This is set to non-zero to enable verbose mode. */
135511b41d2SMark Murray int verbose_mode = 0;
136511b41d2SMark Murray 
137511b41d2SMark Murray /* This is set to zero if the progressmeter is not desired. */
138511b41d2SMark Murray int showprogress = 1;
139511b41d2SMark Murray 
140b66f2d16SKris Kennaway /* This is the program to execute for the secured connection. ("ssh" or -S) */
1411e8db6e2SBrian Feldman char *ssh_program = _PATH_SSH_PROGRAM;
142b66f2d16SKris Kennaway 
143e73e9afaSDag-Erling Smørgrav /* This is used to store the pid of ssh_program */
144cf2b5f3bSDag-Erling Smørgrav pid_t do_cmd_pid = -1;
145cf2b5f3bSDag-Erling Smørgrav 
146cf2b5f3bSDag-Erling Smørgrav static void
147cf2b5f3bSDag-Erling Smørgrav killchild(int signo)
148cf2b5f3bSDag-Erling Smørgrav {
149aa49c926SDag-Erling Smørgrav 	if (do_cmd_pid > 1) {
150d4ecd108SDag-Erling Smørgrav 		kill(do_cmd_pid, signo ? signo : SIGTERM);
151aa49c926SDag-Erling Smørgrav 		waitpid(do_cmd_pid, NULL, 0);
152aa49c926SDag-Erling Smørgrav 	}
153cf2b5f3bSDag-Erling Smørgrav 
154d4ecd108SDag-Erling Smørgrav 	if (signo)
155cf2b5f3bSDag-Erling Smørgrav 		_exit(1);
156d4ecd108SDag-Erling Smørgrav 	exit(1);
157cf2b5f3bSDag-Erling Smørgrav }
158e73e9afaSDag-Erling Smørgrav 
159b74df5b2SDag-Erling Smørgrav static int
160b74df5b2SDag-Erling Smørgrav do_local_cmd(arglist *a)
161b74df5b2SDag-Erling Smørgrav {
162b74df5b2SDag-Erling Smørgrav 	u_int i;
163b74df5b2SDag-Erling Smørgrav 	int status;
164b74df5b2SDag-Erling Smørgrav 	pid_t pid;
165b74df5b2SDag-Erling Smørgrav 
166b74df5b2SDag-Erling Smørgrav 	if (a->num == 0)
167b74df5b2SDag-Erling Smørgrav 		fatal("do_local_cmd: no arguments");
168b74df5b2SDag-Erling Smørgrav 
169b74df5b2SDag-Erling Smørgrav 	if (verbose_mode) {
170b74df5b2SDag-Erling Smørgrav 		fprintf(stderr, "Executing:");
171b74df5b2SDag-Erling Smørgrav 		for (i = 0; i < a->num; i++)
172b74df5b2SDag-Erling Smørgrav 			fprintf(stderr, " %s", a->list[i]);
173b74df5b2SDag-Erling Smørgrav 		fprintf(stderr, "\n");
174b74df5b2SDag-Erling Smørgrav 	}
175b74df5b2SDag-Erling Smørgrav 	if ((pid = fork()) == -1)
176b74df5b2SDag-Erling Smørgrav 		fatal("do_local_cmd: fork: %s", strerror(errno));
177b74df5b2SDag-Erling Smørgrav 
178b74df5b2SDag-Erling Smørgrav 	if (pid == 0) {
179b74df5b2SDag-Erling Smørgrav 		execvp(a->list[0], a->list);
180b74df5b2SDag-Erling Smørgrav 		perror(a->list[0]);
181b74df5b2SDag-Erling Smørgrav 		exit(1);
182b74df5b2SDag-Erling Smørgrav 	}
183b74df5b2SDag-Erling Smørgrav 
184b74df5b2SDag-Erling Smørgrav 	do_cmd_pid = pid;
185b74df5b2SDag-Erling Smørgrav 	signal(SIGTERM, killchild);
186b74df5b2SDag-Erling Smørgrav 	signal(SIGINT, killchild);
187b74df5b2SDag-Erling Smørgrav 	signal(SIGHUP, killchild);
188b74df5b2SDag-Erling Smørgrav 
189b74df5b2SDag-Erling Smørgrav 	while (waitpid(pid, &status, 0) == -1)
190b74df5b2SDag-Erling Smørgrav 		if (errno != EINTR)
191b74df5b2SDag-Erling Smørgrav 			fatal("do_local_cmd: waitpid: %s", strerror(errno));
192b74df5b2SDag-Erling Smørgrav 
193b74df5b2SDag-Erling Smørgrav 	do_cmd_pid = -1;
194b74df5b2SDag-Erling Smørgrav 
195b74df5b2SDag-Erling Smørgrav 	if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
196b74df5b2SDag-Erling Smørgrav 		return (-1);
197b74df5b2SDag-Erling Smørgrav 
198b74df5b2SDag-Erling Smørgrav 	return (0);
199b74df5b2SDag-Erling Smørgrav }
200b74df5b2SDag-Erling Smørgrav 
201511b41d2SMark Murray /*
202511b41d2SMark Murray  * This function executes the given command as the specified user on the
203511b41d2SMark Murray  * given host.  This returns < 0 if execution fails, and >= 0 otherwise. This
204511b41d2SMark Murray  * assigns the input and output file descriptors on success.
205511b41d2SMark Murray  */
206511b41d2SMark Murray 
207511b41d2SMark Murray int
208333ee039SDag-Erling Smørgrav do_cmd(char *host, char *remuser, char *cmd, int *fdin, int *fdout)
209511b41d2SMark Murray {
210511b41d2SMark Murray 	int pin[2], pout[2], reserved[2];
211511b41d2SMark Murray 
212511b41d2SMark Murray 	if (verbose_mode)
213ae1f160dSDag-Erling Smørgrav 		fprintf(stderr,
214ae1f160dSDag-Erling Smørgrav 		    "Executing: program %s host %s, user %s, command %s\n",
215ae1f160dSDag-Erling Smørgrav 		    ssh_program, host,
216ae1f160dSDag-Erling Smørgrav 		    remuser ? remuser : "(unspecified)", cmd);
217511b41d2SMark Murray 
218511b41d2SMark Murray 	/*
219511b41d2SMark Murray 	 * Reserve two descriptors so that the real pipes won't get
220511b41d2SMark Murray 	 * descriptors 0 and 1 because that will screw up dup2 below.
221511b41d2SMark Murray 	 */
222333ee039SDag-Erling Smørgrav 	if (pipe(reserved) < 0)
223333ee039SDag-Erling Smørgrav 		fatal("pipe: %s", strerror(errno));
224511b41d2SMark Murray 
225511b41d2SMark Murray 	/* Create a socket pair for communicating with ssh. */
226511b41d2SMark Murray 	if (pipe(pin) < 0)
227511b41d2SMark Murray 		fatal("pipe: %s", strerror(errno));
228511b41d2SMark Murray 	if (pipe(pout) < 0)
229511b41d2SMark Murray 		fatal("pipe: %s", strerror(errno));
230511b41d2SMark Murray 
231511b41d2SMark Murray 	/* Free the reserved descriptors. */
232511b41d2SMark Murray 	close(reserved[0]);
233511b41d2SMark Murray 	close(reserved[1]);
234511b41d2SMark Murray 
235cf2b5f3bSDag-Erling Smørgrav 	/* Fork a child to execute the command on the remote host using ssh. */
236e73e9afaSDag-Erling Smørgrav 	do_cmd_pid = fork();
237e73e9afaSDag-Erling Smørgrav 	if (do_cmd_pid == 0) {
238511b41d2SMark Murray 		/* Child. */
239511b41d2SMark Murray 		close(pin[1]);
240511b41d2SMark Murray 		close(pout[0]);
241511b41d2SMark Murray 		dup2(pin[0], 0);
242511b41d2SMark Murray 		dup2(pout[1], 1);
243511b41d2SMark Murray 		close(pin[0]);
244511b41d2SMark Murray 		close(pout[1]);
245511b41d2SMark Murray 
246b74df5b2SDag-Erling Smørgrav 		replacearg(&args, 0, "%s", ssh_program);
2475b9b2fafSBrian Feldman 		if (remuser != NULL)
248ae1f160dSDag-Erling Smørgrav 			addargs(&args, "-l%s", remuser);
249ae1f160dSDag-Erling Smørgrav 		addargs(&args, "%s", host);
250ae1f160dSDag-Erling Smørgrav 		addargs(&args, "%s", cmd);
251511b41d2SMark Murray 
2525b9b2fafSBrian Feldman 		execvp(ssh_program, args.list);
253b66f2d16SKris Kennaway 		perror(ssh_program);
254511b41d2SMark Murray 		exit(1);
255e73e9afaSDag-Erling Smørgrav 	} else if (do_cmd_pid == -1) {
256e73e9afaSDag-Erling Smørgrav 		fatal("fork: %s", strerror(errno));
257511b41d2SMark Murray 	}
258511b41d2SMark Murray 	/* Parent.  Close the other side, and return the local side. */
259511b41d2SMark Murray 	close(pin[0]);
260511b41d2SMark Murray 	*fdout = pin[1];
261511b41d2SMark Murray 	close(pout[1]);
262511b41d2SMark Murray 	*fdin = pout[0];
263cf2b5f3bSDag-Erling Smørgrav 	signal(SIGTERM, killchild);
264cf2b5f3bSDag-Erling Smørgrav 	signal(SIGINT, killchild);
265cf2b5f3bSDag-Erling Smørgrav 	signal(SIGHUP, killchild);
266511b41d2SMark Murray 	return 0;
267511b41d2SMark Murray }
268511b41d2SMark Murray 
269511b41d2SMark Murray typedef struct {
270d4ecd108SDag-Erling Smørgrav 	size_t cnt;
271511b41d2SMark Murray 	char *buf;
272511b41d2SMark Murray } BUF;
273511b41d2SMark Murray 
274511b41d2SMark Murray BUF *allocbuf(BUF *, int, int);
275511b41d2SMark Murray void lostconn(int);
276511b41d2SMark Murray int okname(char *);
277511b41d2SMark Murray void run_err(const char *,...);
278511b41d2SMark Murray void verifydir(char *);
279511b41d2SMark Murray 
280511b41d2SMark Murray struct passwd *pwd;
281511b41d2SMark Murray uid_t userid;
282511b41d2SMark Murray int errs, remin, remout;
283511b41d2SMark Murray int pflag, iamremote, iamrecursive, targetshouldbedirectory;
284511b41d2SMark Murray 
285511b41d2SMark Murray #define	CMDNEEDS	64
286511b41d2SMark Murray char cmd[CMDNEEDS];		/* must hold "rcp -r -p -d\0" */
287511b41d2SMark Murray 
288511b41d2SMark Murray int response(void);
289511b41d2SMark Murray void rsource(char *, struct stat *);
290511b41d2SMark Murray void sink(int, char *[]);
291511b41d2SMark Murray void source(int, char *[]);
292511b41d2SMark Murray void tolocal(int, char *[]);
293511b41d2SMark Murray void toremote(char *, int, char *[]);
294d4af9e69SDag-Erling Smørgrav size_t scpio(ssize_t (*)(int, void *, size_t), int, void *, size_t, off_t *);
295511b41d2SMark Murray void usage(void);
296511b41d2SMark Murray 
297511b41d2SMark Murray int
298cf2b5f3bSDag-Erling Smørgrav main(int argc, char **argv)
299511b41d2SMark Murray {
300333ee039SDag-Erling Smørgrav 	int ch, fflag, tflag, status, n;
301e73e9afaSDag-Erling Smørgrav 	double speed;
302333ee039SDag-Erling Smørgrav 	char *targ, *endp, **newargv;
303511b41d2SMark Murray 	extern char *optarg;
304511b41d2SMark Murray 	extern int optind;
305511b41d2SMark Murray 
306b74df5b2SDag-Erling Smørgrav 	/* Ensure that fds 0, 1 and 2 are open or directed to /dev/null */
307b74df5b2SDag-Erling Smørgrav 	sanitise_stdfd();
308b74df5b2SDag-Erling Smørgrav 
309333ee039SDag-Erling Smørgrav 	/* Copy argv, because we modify it */
310333ee039SDag-Erling Smørgrav 	newargv = xcalloc(MAX(argc + 1, 1), sizeof(*newargv));
311333ee039SDag-Erling Smørgrav 	for (n = 0; n < argc; n++)
312333ee039SDag-Erling Smørgrav 		newargv[n] = xstrdup(argv[n]);
313333ee039SDag-Erling Smørgrav 	argv = newargv;
314333ee039SDag-Erling Smørgrav 
315cf2b5f3bSDag-Erling Smørgrav 	__progname = ssh_get_progname(argv[0]);
31683d2307dSDag-Erling Smørgrav 
317b74df5b2SDag-Erling Smørgrav 	memset(&args, '\0', sizeof(args));
3185b9b2fafSBrian Feldman 	args.list = NULL;
319b74df5b2SDag-Erling Smørgrav 	addargs(&args, "%s", ssh_program);
320ae1f160dSDag-Erling Smørgrav 	addargs(&args, "-x");
321ae1f160dSDag-Erling Smørgrav 	addargs(&args, "-oForwardAgent no");
322b74df5b2SDag-Erling Smørgrav 	addargs(&args, "-oPermitLocalCommand no");
323ae1f160dSDag-Erling Smørgrav 	addargs(&args, "-oClearAllForwardings yes");
3245b9b2fafSBrian Feldman 
325511b41d2SMark Murray 	fflag = tflag = 0;
326e73e9afaSDag-Erling Smørgrav 	while ((ch = getopt(argc, argv, "dfl:prtvBCc:i:P:q1246S:o:F:")) != -1)
327511b41d2SMark Murray 		switch (ch) {
328511b41d2SMark Murray 		/* User-visible flags. */
329e73e9afaSDag-Erling Smørgrav 		case '1':
330e73e9afaSDag-Erling Smørgrav 		case '2':
331511b41d2SMark Murray 		case '4':
332511b41d2SMark Murray 		case '6':
3335b9b2fafSBrian Feldman 		case 'C':
334ae1f160dSDag-Erling Smørgrav 			addargs(&args, "-%c", ch);
3355b9b2fafSBrian Feldman 			break;
3365b9b2fafSBrian Feldman 		case 'o':
3375b9b2fafSBrian Feldman 		case 'c':
3385b9b2fafSBrian Feldman 		case 'i':
339ae1f160dSDag-Erling Smørgrav 		case 'F':
340ae1f160dSDag-Erling Smørgrav 			addargs(&args, "-%c%s", ch, optarg);
3415b9b2fafSBrian Feldman 			break;
3425b9b2fafSBrian Feldman 		case 'P':
343ae1f160dSDag-Erling Smørgrav 			addargs(&args, "-p%s", optarg);
3445b9b2fafSBrian Feldman 			break;
3455b9b2fafSBrian Feldman 		case 'B':
346ae1f160dSDag-Erling Smørgrav 			addargs(&args, "-oBatchmode yes");
347511b41d2SMark Murray 			break;
348e73e9afaSDag-Erling Smørgrav 		case 'l':
349e73e9afaSDag-Erling Smørgrav 			speed = strtod(optarg, &endp);
350e73e9afaSDag-Erling Smørgrav 			if (speed <= 0 || *endp != '\0')
351e73e9afaSDag-Erling Smørgrav 				usage();
3521ec0d754SDag-Erling Smørgrav 			limit_rate = speed * 1024;
353e73e9afaSDag-Erling Smørgrav 			break;
354511b41d2SMark Murray 		case 'p':
355511b41d2SMark Murray 			pflag = 1;
356511b41d2SMark Murray 			break;
357511b41d2SMark Murray 		case 'r':
358511b41d2SMark Murray 			iamrecursive = 1;
359511b41d2SMark Murray 			break;
360b66f2d16SKris Kennaway 		case 'S':
3615b9b2fafSBrian Feldman 			ssh_program = xstrdup(optarg);
3625b9b2fafSBrian Feldman 			break;
3635b9b2fafSBrian Feldman 		case 'v':
364ae1f160dSDag-Erling Smørgrav 			addargs(&args, "-v");
3655b9b2fafSBrian Feldman 			verbose_mode = 1;
3665b9b2fafSBrian Feldman 			break;
3675b9b2fafSBrian Feldman 		case 'q':
3681ec0d754SDag-Erling Smørgrav 			addargs(&args, "-q");
3695b9b2fafSBrian Feldman 			showprogress = 0;
370b66f2d16SKris Kennaway 			break;
371b66f2d16SKris Kennaway 
372511b41d2SMark Murray 		/* Server options. */
373511b41d2SMark Murray 		case 'd':
374511b41d2SMark Murray 			targetshouldbedirectory = 1;
375511b41d2SMark Murray 			break;
376511b41d2SMark Murray 		case 'f':	/* "from" */
377511b41d2SMark Murray 			iamremote = 1;
378511b41d2SMark Murray 			fflag = 1;
379511b41d2SMark Murray 			break;
380511b41d2SMark Murray 		case 't':	/* "to" */
381511b41d2SMark Murray 			iamremote = 1;
382511b41d2SMark Murray 			tflag = 1;
38383d2307dSDag-Erling Smørgrav #ifdef HAVE_CYGWIN
38483d2307dSDag-Erling Smørgrav 			setmode(0, O_BINARY);
38583d2307dSDag-Erling Smørgrav #endif
386511b41d2SMark Murray 			break;
387511b41d2SMark Murray 		default:
388511b41d2SMark Murray 			usage();
389511b41d2SMark Murray 		}
390511b41d2SMark Murray 	argc -= optind;
391511b41d2SMark Murray 	argv += optind;
392511b41d2SMark Murray 
393511b41d2SMark Murray 	if ((pwd = getpwuid(userid = getuid())) == NULL)
394cf2b5f3bSDag-Erling Smørgrav 		fatal("unknown user %u", (u_int) userid);
395511b41d2SMark Murray 
396d4af9e69SDag-Erling Smørgrav 	if (!isatty(STDOUT_FILENO))
397511b41d2SMark Murray 		showprogress = 0;
398511b41d2SMark Murray 
399511b41d2SMark Murray 	remin = STDIN_FILENO;
400511b41d2SMark Murray 	remout = STDOUT_FILENO;
401511b41d2SMark Murray 
402511b41d2SMark Murray 	if (fflag) {
403511b41d2SMark Murray 		/* Follow "protocol", send data. */
404511b41d2SMark Murray 		(void) response();
405511b41d2SMark Murray 		source(argc, argv);
406511b41d2SMark Murray 		exit(errs != 0);
407511b41d2SMark Murray 	}
408511b41d2SMark Murray 	if (tflag) {
409511b41d2SMark Murray 		/* Receive data. */
410511b41d2SMark Murray 		sink(argc, argv);
411511b41d2SMark Murray 		exit(errs != 0);
412511b41d2SMark Murray 	}
413511b41d2SMark Murray 	if (argc < 2)
414511b41d2SMark Murray 		usage();
415511b41d2SMark Murray 	if (argc > 2)
416511b41d2SMark Murray 		targetshouldbedirectory = 1;
417511b41d2SMark Murray 
418511b41d2SMark Murray 	remin = remout = -1;
419e73e9afaSDag-Erling Smørgrav 	do_cmd_pid = -1;
420511b41d2SMark Murray 	/* Command to be executed on remote system using "ssh". */
4211e8db6e2SBrian Feldman 	(void) snprintf(cmd, sizeof cmd, "scp%s%s%s%s",
4221e8db6e2SBrian Feldman 	    verbose_mode ? " -v" : "",
423511b41d2SMark Murray 	    iamrecursive ? " -r" : "", pflag ? " -p" : "",
424511b41d2SMark Murray 	    targetshouldbedirectory ? " -d" : "");
425511b41d2SMark Murray 
426511b41d2SMark Murray 	(void) signal(SIGPIPE, lostconn);
427511b41d2SMark Murray 
428511b41d2SMark Murray 	if ((targ = colon(argv[argc - 1])))	/* Dest is remote host. */
429511b41d2SMark Murray 		toremote(targ, argc, argv);
430511b41d2SMark Murray 	else {
431511b41d2SMark Murray 		if (targetshouldbedirectory)
432511b41d2SMark Murray 			verifydir(argv[argc - 1]);
433b74df5b2SDag-Erling Smørgrav 		tolocal(argc, argv);	/* Dest is local host. */
434511b41d2SMark Murray 	}
435e73e9afaSDag-Erling Smørgrav 	/*
436e73e9afaSDag-Erling Smørgrav 	 * Finally check the exit status of the ssh process, if one was forked
437cce7d346SDag-Erling Smørgrav 	 * and no error has occurred yet
438e73e9afaSDag-Erling Smørgrav 	 */
439e73e9afaSDag-Erling Smørgrav 	if (do_cmd_pid != -1 && errs == 0) {
440e73e9afaSDag-Erling Smørgrav 		if (remin != -1)
441e73e9afaSDag-Erling Smørgrav 		    (void) close(remin);
442e73e9afaSDag-Erling Smørgrav 		if (remout != -1)
443e73e9afaSDag-Erling Smørgrav 		    (void) close(remout);
444e73e9afaSDag-Erling Smørgrav 		if (waitpid(do_cmd_pid, &status, 0) == -1)
445e73e9afaSDag-Erling Smørgrav 			errs = 1;
446e73e9afaSDag-Erling Smørgrav 		else {
447e73e9afaSDag-Erling Smørgrav 			if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
448e73e9afaSDag-Erling Smørgrav 				errs = 1;
449e73e9afaSDag-Erling Smørgrav 		}
450e73e9afaSDag-Erling Smørgrav 	}
451511b41d2SMark Murray 	exit(errs != 0);
452511b41d2SMark Murray }
453511b41d2SMark Murray 
454d4af9e69SDag-Erling Smørgrav /*
455d4af9e69SDag-Erling Smørgrav  * atomicio-like wrapper that also applies bandwidth limits and updates
456d4af9e69SDag-Erling Smørgrav  * the progressmeter counter.
457d4af9e69SDag-Erling Smørgrav  */
458d4af9e69SDag-Erling Smørgrav size_t
459d4af9e69SDag-Erling Smørgrav scpio(ssize_t (*f)(int, void *, size_t), int fd, void *_p, size_t l, off_t *c)
460d4af9e69SDag-Erling Smørgrav {
461d4af9e69SDag-Erling Smørgrav 	u_char *p = (u_char *)_p;
462d4af9e69SDag-Erling Smørgrav 	size_t offset;
463d4af9e69SDag-Erling Smørgrav 	ssize_t r;
464d4af9e69SDag-Erling Smørgrav 	struct pollfd pfd;
465d4af9e69SDag-Erling Smørgrav 
466d4af9e69SDag-Erling Smørgrav 	pfd.fd = fd;
467d4af9e69SDag-Erling Smørgrav 	pfd.events = f == read ? POLLIN : POLLOUT;
468d4af9e69SDag-Erling Smørgrav 	for (offset = 0; offset < l;) {
469d4af9e69SDag-Erling Smørgrav 		r = f(fd, p + offset, l - offset);
470d4af9e69SDag-Erling Smørgrav 		if (r == 0) {
471d4af9e69SDag-Erling Smørgrav 			errno = EPIPE;
472d4af9e69SDag-Erling Smørgrav 			return offset;
473d4af9e69SDag-Erling Smørgrav 		}
474d4af9e69SDag-Erling Smørgrav 		if (r < 0) {
475d4af9e69SDag-Erling Smørgrav 			if (errno == EINTR)
476d4af9e69SDag-Erling Smørgrav 				continue;
477d4af9e69SDag-Erling Smørgrav 			if (errno == EAGAIN || errno == EWOULDBLOCK) {
478d4af9e69SDag-Erling Smørgrav 				(void)poll(&pfd, 1, -1); /* Ignore errors */
479d4af9e69SDag-Erling Smørgrav 				continue;
480d4af9e69SDag-Erling Smørgrav 			}
481d4af9e69SDag-Erling Smørgrav 			return offset;
482d4af9e69SDag-Erling Smørgrav 		}
483d4af9e69SDag-Erling Smørgrav 		offset += (size_t)r;
484d4af9e69SDag-Erling Smørgrav 		*c += (off_t)r;
485d4af9e69SDag-Erling Smørgrav 		if (limit_rate)
486d4af9e69SDag-Erling Smørgrav 			bwlimit(r);
487d4af9e69SDag-Erling Smørgrav 	}
488d4af9e69SDag-Erling Smørgrav 	return offset;
489d4af9e69SDag-Erling Smørgrav }
490d4af9e69SDag-Erling Smørgrav 
491511b41d2SMark Murray void
492cf2b5f3bSDag-Erling Smørgrav toremote(char *targ, int argc, char **argv)
493511b41d2SMark Murray {
494aa49c926SDag-Erling Smørgrav 	char *bp, *host, *src, *suser, *thost, *tuser, *arg;
495b74df5b2SDag-Erling Smørgrav 	arglist alist;
496333ee039SDag-Erling Smørgrav 	int i;
497b74df5b2SDag-Erling Smørgrav 
498b74df5b2SDag-Erling Smørgrav 	memset(&alist, '\0', sizeof(alist));
499b74df5b2SDag-Erling Smørgrav 	alist.list = NULL;
500511b41d2SMark Murray 
501511b41d2SMark Murray 	*targ++ = 0;
502511b41d2SMark Murray 	if (*targ == 0)
503511b41d2SMark Murray 		targ = ".";
504511b41d2SMark Murray 
505aa49c926SDag-Erling Smørgrav 	arg = xstrdup(argv[argc - 1]);
506aa49c926SDag-Erling Smørgrav 	if ((thost = strrchr(arg, '@'))) {
507511b41d2SMark Murray 		/* user@host */
508511b41d2SMark Murray 		*thost++ = 0;
509aa49c926SDag-Erling Smørgrav 		tuser = arg;
510511b41d2SMark Murray 		if (*tuser == '\0')
511511b41d2SMark Murray 			tuser = NULL;
512511b41d2SMark Murray 	} else {
513aa49c926SDag-Erling Smørgrav 		thost = arg;
514511b41d2SMark Murray 		tuser = NULL;
515511b41d2SMark Murray 	}
516511b41d2SMark Murray 
517b74df5b2SDag-Erling Smørgrav 	if (tuser != NULL && !okname(tuser)) {
518b74df5b2SDag-Erling Smørgrav 		xfree(arg);
519b74df5b2SDag-Erling Smørgrav 		return;
520b74df5b2SDag-Erling Smørgrav 	}
521b74df5b2SDag-Erling Smørgrav 
522511b41d2SMark Murray 	for (i = 0; i < argc - 1; i++) {
523511b41d2SMark Murray 		src = colon(argv[i]);
524511b41d2SMark Murray 		if (src) {	/* remote to remote */
525b74df5b2SDag-Erling Smørgrav 			freeargs(&alist);
526b74df5b2SDag-Erling Smørgrav 			addargs(&alist, "%s", ssh_program);
527b74df5b2SDag-Erling Smørgrav 			if (verbose_mode)
528b74df5b2SDag-Erling Smørgrav 				addargs(&alist, "-v");
529b74df5b2SDag-Erling Smørgrav 			addargs(&alist, "-x");
530b74df5b2SDag-Erling Smørgrav 			addargs(&alist, "-oClearAllForwardings yes");
531b74df5b2SDag-Erling Smørgrav 			addargs(&alist, "-n");
532b74df5b2SDag-Erling Smørgrav 
533511b41d2SMark Murray 			*src++ = 0;
534511b41d2SMark Murray 			if (*src == 0)
535511b41d2SMark Murray 				src = ".";
536e73e9afaSDag-Erling Smørgrav 			host = strrchr(argv[i], '@');
537b74df5b2SDag-Erling Smørgrav 
538511b41d2SMark Murray 			if (host) {
539511b41d2SMark Murray 				*host++ = 0;
540511b41d2SMark Murray 				host = cleanhostname(host);
541511b41d2SMark Murray 				suser = argv[i];
542511b41d2SMark Murray 				if (*suser == '\0')
543511b41d2SMark Murray 					suser = pwd->pw_name;
544b74df5b2SDag-Erling Smørgrav 				else if (!okname(suser))
545511b41d2SMark Murray 					continue;
546b74df5b2SDag-Erling Smørgrav 				addargs(&alist, "-l");
547b74df5b2SDag-Erling Smørgrav 				addargs(&alist, "%s", suser);
548511b41d2SMark Murray 			} else {
549511b41d2SMark Murray 				host = cleanhostname(argv[i]);
550b74df5b2SDag-Erling Smørgrav 			}
551b74df5b2SDag-Erling Smørgrav 			addargs(&alist, "%s", host);
552b74df5b2SDag-Erling Smørgrav 			addargs(&alist, "%s", cmd);
553b74df5b2SDag-Erling Smørgrav 			addargs(&alist, "%s", src);
554b74df5b2SDag-Erling Smørgrav 			addargs(&alist, "%s%s%s:%s",
555511b41d2SMark Murray 			    tuser ? tuser : "", tuser ? "@" : "",
556511b41d2SMark Murray 			    thost, targ);
557b74df5b2SDag-Erling Smørgrav 			if (do_local_cmd(&alist) != 0)
5581ec0d754SDag-Erling Smørgrav 				errs = 1;
559511b41d2SMark Murray 		} else {	/* local to remote */
560511b41d2SMark Murray 			if (remin == -1) {
561333ee039SDag-Erling Smørgrav 				xasprintf(&bp, "%s -t %s", cmd, targ);
562511b41d2SMark Murray 				host = cleanhostname(thost);
563b66f2d16SKris Kennaway 				if (do_cmd(host, tuser, bp, &remin,
564333ee039SDag-Erling Smørgrav 				    &remout) < 0)
565511b41d2SMark Murray 					exit(1);
566511b41d2SMark Murray 				if (response() < 0)
567511b41d2SMark Murray 					exit(1);
568511b41d2SMark Murray 				(void) xfree(bp);
569511b41d2SMark Murray 			}
570511b41d2SMark Murray 			source(1, argv + i);
571511b41d2SMark Murray 		}
572511b41d2SMark Murray 	}
573333ee039SDag-Erling Smørgrav 	xfree(arg);
574511b41d2SMark Murray }
575511b41d2SMark Murray 
576511b41d2SMark Murray void
577cf2b5f3bSDag-Erling Smørgrav tolocal(int argc, char **argv)
578511b41d2SMark Murray {
579511b41d2SMark Murray 	char *bp, *host, *src, *suser;
580b74df5b2SDag-Erling Smørgrav 	arglist alist;
581333ee039SDag-Erling Smørgrav 	int i;
582b74df5b2SDag-Erling Smørgrav 
583b74df5b2SDag-Erling Smørgrav 	memset(&alist, '\0', sizeof(alist));
584b74df5b2SDag-Erling Smørgrav 	alist.list = NULL;
585511b41d2SMark Murray 
586511b41d2SMark Murray 	for (i = 0; i < argc - 1; i++) {
587511b41d2SMark Murray 		if (!(src = colon(argv[i]))) {	/* Local to local. */
588b74df5b2SDag-Erling Smørgrav 			freeargs(&alist);
589b74df5b2SDag-Erling Smørgrav 			addargs(&alist, "%s", _PATH_CP);
590b74df5b2SDag-Erling Smørgrav 			if (iamrecursive)
591b74df5b2SDag-Erling Smørgrav 				addargs(&alist, "-r");
592b74df5b2SDag-Erling Smørgrav 			if (pflag)
593b74df5b2SDag-Erling Smørgrav 				addargs(&alist, "-p");
594b74df5b2SDag-Erling Smørgrav 			addargs(&alist, "%s", argv[i]);
595b74df5b2SDag-Erling Smørgrav 			addargs(&alist, "%s", argv[argc-1]);
596b74df5b2SDag-Erling Smørgrav 			if (do_local_cmd(&alist))
597511b41d2SMark Murray 				++errs;
598511b41d2SMark Murray 			continue;
599511b41d2SMark Murray 		}
600511b41d2SMark Murray 		*src++ = 0;
601511b41d2SMark Murray 		if (*src == 0)
602511b41d2SMark Murray 			src = ".";
603e73e9afaSDag-Erling Smørgrav 		if ((host = strrchr(argv[i], '@')) == NULL) {
604511b41d2SMark Murray 			host = argv[i];
605511b41d2SMark Murray 			suser = NULL;
606511b41d2SMark Murray 		} else {
607511b41d2SMark Murray 			*host++ = 0;
608511b41d2SMark Murray 			suser = argv[i];
609511b41d2SMark Murray 			if (*suser == '\0')
610511b41d2SMark Murray 				suser = pwd->pw_name;
611511b41d2SMark Murray 		}
612511b41d2SMark Murray 		host = cleanhostname(host);
613333ee039SDag-Erling Smørgrav 		xasprintf(&bp, "%s -f %s", cmd, src);
614333ee039SDag-Erling Smørgrav 		if (do_cmd(host, suser, bp, &remin, &remout) < 0) {
615511b41d2SMark Murray 			(void) xfree(bp);
616511b41d2SMark Murray 			++errs;
617511b41d2SMark Murray 			continue;
618511b41d2SMark Murray 		}
619511b41d2SMark Murray 		xfree(bp);
620511b41d2SMark Murray 		sink(1, argv + argc - 1);
621511b41d2SMark Murray 		(void) close(remin);
622511b41d2SMark Murray 		remin = remout = -1;
623511b41d2SMark Murray 	}
624511b41d2SMark Murray }
625511b41d2SMark Murray 
626511b41d2SMark Murray void
627cf2b5f3bSDag-Erling Smørgrav source(int argc, char **argv)
628511b41d2SMark Murray {
629511b41d2SMark Murray 	struct stat stb;
630511b41d2SMark Murray 	static BUF buffer;
631511b41d2SMark Murray 	BUF *bp;
632d4af9e69SDag-Erling Smørgrav 	off_t i, statbytes;
633d4af9e69SDag-Erling Smørgrav 	size_t amt;
634d4ecd108SDag-Erling Smørgrav 	int fd = -1, haderr, indx;
635d4af9e69SDag-Erling Smørgrav 	char *last, *name, buf[2048], encname[MAXPATHLEN];
6361e8db6e2SBrian Feldman 	int len;
637511b41d2SMark Murray 
638511b41d2SMark Murray 	for (indx = 0; indx < argc; ++indx) {
639511b41d2SMark Murray 		name = argv[indx];
640511b41d2SMark Murray 		statbytes = 0;
6411e8db6e2SBrian Feldman 		len = strlen(name);
6421e8db6e2SBrian Feldman 		while (len > 1 && name[len-1] == '/')
6431e8db6e2SBrian Feldman 			name[--len] = '\0';
644d4af9e69SDag-Erling Smørgrav 		if ((fd = open(name, O_RDONLY|O_NONBLOCK, 0)) < 0)
645511b41d2SMark Murray 			goto syserr;
646d4af9e69SDag-Erling Smørgrav 		if (strchr(name, '\n') != NULL) {
647d4af9e69SDag-Erling Smørgrav 			strnvis(encname, name, sizeof(encname), VIS_NL);
648d4af9e69SDag-Erling Smørgrav 			name = encname;
649d4af9e69SDag-Erling Smørgrav 		}
650511b41d2SMark Murray 		if (fstat(fd, &stb) < 0) {
651511b41d2SMark Murray syserr:			run_err("%s: %s", name, strerror(errno));
652511b41d2SMark Murray 			goto next;
653511b41d2SMark Murray 		}
654d4af9e69SDag-Erling Smørgrav 		if (stb.st_size < 0) {
655d4af9e69SDag-Erling Smørgrav 			run_err("%s: %s", name, "Negative file size");
656d4af9e69SDag-Erling Smørgrav 			goto next;
657d4af9e69SDag-Erling Smørgrav 		}
658d4af9e69SDag-Erling Smørgrav 		unset_nonblock(fd);
659511b41d2SMark Murray 		switch (stb.st_mode & S_IFMT) {
660511b41d2SMark Murray 		case S_IFREG:
661511b41d2SMark Murray 			break;
662511b41d2SMark Murray 		case S_IFDIR:
663511b41d2SMark Murray 			if (iamrecursive) {
664511b41d2SMark Murray 				rsource(name, &stb);
665511b41d2SMark Murray 				goto next;
666511b41d2SMark Murray 			}
667511b41d2SMark Murray 			/* FALLTHROUGH */
668511b41d2SMark Murray 		default:
669511b41d2SMark Murray 			run_err("%s: not a regular file", name);
670511b41d2SMark Murray 			goto next;
671511b41d2SMark Murray 		}
672511b41d2SMark Murray 		if ((last = strrchr(name, '/')) == NULL)
673511b41d2SMark Murray 			last = name;
674511b41d2SMark Murray 		else
675511b41d2SMark Murray 			++last;
676511b41d2SMark Murray 		curfile = last;
677511b41d2SMark Murray 		if (pflag) {
678511b41d2SMark Murray 			/*
679511b41d2SMark Murray 			 * Make it compatible with possible future
680511b41d2SMark Murray 			 * versions expecting microseconds.
681511b41d2SMark Murray 			 */
6821e8db6e2SBrian Feldman 			(void) snprintf(buf, sizeof buf, "T%lu 0 %lu 0\n",
683d4af9e69SDag-Erling Smørgrav 			    (u_long) (stb.st_mtime < 0 ? 0 : stb.st_mtime),
684d4af9e69SDag-Erling Smørgrav 			    (u_long) (stb.st_atime < 0 ? 0 : stb.st_atime));
685d4af9e69SDag-Erling Smørgrav 			if (verbose_mode) {
686d4af9e69SDag-Erling Smørgrav 				fprintf(stderr, "File mtime %ld atime %ld\n",
687d4af9e69SDag-Erling Smørgrav 				    (long)stb.st_mtime, (long)stb.st_atime);
688d4af9e69SDag-Erling Smørgrav 				fprintf(stderr, "Sending file timestamps: %s",
689d4af9e69SDag-Erling Smørgrav 				    buf);
690d4af9e69SDag-Erling Smørgrav 			}
691cf2b5f3bSDag-Erling Smørgrav 			(void) atomicio(vwrite, remout, buf, strlen(buf));
692511b41d2SMark Murray 			if (response() < 0)
693511b41d2SMark Murray 				goto next;
694511b41d2SMark Murray 		}
695511b41d2SMark Murray #define	FILEMODEMASK	(S_ISUID|S_ISGID|S_IRWXU|S_IRWXG|S_IRWXO)
6961e8db6e2SBrian Feldman 		snprintf(buf, sizeof buf, "C%04o %lld %s\n",
6971e8db6e2SBrian Feldman 		    (u_int) (stb.st_mode & FILEMODEMASK),
698b74df5b2SDag-Erling Smørgrav 		    (long long)stb.st_size, last);
699511b41d2SMark Murray 		if (verbose_mode) {
700511b41d2SMark Murray 			fprintf(stderr, "Sending file modes: %s", buf);
701511b41d2SMark Murray 		}
702cf2b5f3bSDag-Erling Smørgrav 		(void) atomicio(vwrite, remout, buf, strlen(buf));
703511b41d2SMark Murray 		if (response() < 0)
704511b41d2SMark Murray 			goto next;
705d4af9e69SDag-Erling Smørgrav 		if ((bp = allocbuf(&buffer, fd, COPY_BUFLEN)) == NULL) {
706b74df5b2SDag-Erling Smørgrav next:			if (fd != -1) {
707b74df5b2SDag-Erling Smørgrav 				(void) close(fd);
708b74df5b2SDag-Erling Smørgrav 				fd = -1;
709b74df5b2SDag-Erling Smørgrav 			}
710511b41d2SMark Murray 			continue;
711511b41d2SMark Murray 		}
712e73e9afaSDag-Erling Smørgrav 		if (showprogress)
713e73e9afaSDag-Erling Smørgrav 			start_progress_meter(curfile, stb.st_size, &statbytes);
714d4af9e69SDag-Erling Smørgrav 		set_nonblock(remout);
715511b41d2SMark Murray 		for (haderr = i = 0; i < stb.st_size; i += bp->cnt) {
716511b41d2SMark Murray 			amt = bp->cnt;
717d4af9e69SDag-Erling Smørgrav 			if (i + (off_t)amt > stb.st_size)
718511b41d2SMark Murray 				amt = stb.st_size - i;
719511b41d2SMark Murray 			if (!haderr) {
720d4af9e69SDag-Erling Smørgrav 				if (atomicio(read, fd, bp->buf, amt) != amt)
721d4ecd108SDag-Erling Smørgrav 					haderr = errno;
722511b41d2SMark Murray 			}
723d4af9e69SDag-Erling Smørgrav 			/* Keep writing after error to retain sync */
724d4af9e69SDag-Erling Smørgrav 			if (haderr) {
725cf2b5f3bSDag-Erling Smørgrav 				(void)atomicio(vwrite, remout, bp->buf, amt);
726d4af9e69SDag-Erling Smørgrav 				continue;
727d4af9e69SDag-Erling Smørgrav 			}
728d4af9e69SDag-Erling Smørgrav 			if (scpio(vwrite, remout, bp->buf, amt,
729d4af9e69SDag-Erling Smørgrav 			    &statbytes) != amt)
730d4ecd108SDag-Erling Smørgrav 				haderr = errno;
731511b41d2SMark Murray 		}
732d4af9e69SDag-Erling Smørgrav 		unset_nonblock(remout);
733511b41d2SMark Murray 		if (showprogress)
734e73e9afaSDag-Erling Smørgrav 			stop_progress_meter();
735511b41d2SMark Murray 
736b74df5b2SDag-Erling Smørgrav 		if (fd != -1) {
737511b41d2SMark Murray 			if (close(fd) < 0 && !haderr)
738511b41d2SMark Murray 				haderr = errno;
739b74df5b2SDag-Erling Smørgrav 			fd = -1;
740b74df5b2SDag-Erling Smørgrav 		}
741511b41d2SMark Murray 		if (!haderr)
742cf2b5f3bSDag-Erling Smørgrav 			(void) atomicio(vwrite, remout, "", 1);
743511b41d2SMark Murray 		else
744511b41d2SMark Murray 			run_err("%s: %s", name, strerror(haderr));
745511b41d2SMark Murray 		(void) response();
746511b41d2SMark Murray 	}
747511b41d2SMark Murray }
748511b41d2SMark Murray 
749511b41d2SMark Murray void
750cf2b5f3bSDag-Erling Smørgrav rsource(char *name, struct stat *statp)
751511b41d2SMark Murray {
752511b41d2SMark Murray 	DIR *dirp;
753511b41d2SMark Murray 	struct dirent *dp;
754511b41d2SMark Murray 	char *last, *vect[1], path[1100];
755511b41d2SMark Murray 
756511b41d2SMark Murray 	if (!(dirp = opendir(name))) {
757511b41d2SMark Murray 		run_err("%s: %s", name, strerror(errno));
758511b41d2SMark Murray 		return;
759511b41d2SMark Murray 	}
760511b41d2SMark Murray 	last = strrchr(name, '/');
761511b41d2SMark Murray 	if (last == 0)
762511b41d2SMark Murray 		last = name;
763511b41d2SMark Murray 	else
764511b41d2SMark Murray 		last++;
765511b41d2SMark Murray 	if (pflag) {
7661e8db6e2SBrian Feldman 		(void) snprintf(path, sizeof(path), "T%lu 0 %lu 0\n",
7671e8db6e2SBrian Feldman 		    (u_long) statp->st_mtime,
7681e8db6e2SBrian Feldman 		    (u_long) statp->st_atime);
769cf2b5f3bSDag-Erling Smørgrav 		(void) atomicio(vwrite, remout, path, strlen(path));
770511b41d2SMark Murray 		if (response() < 0) {
771511b41d2SMark Murray 			closedir(dirp);
772511b41d2SMark Murray 			return;
773511b41d2SMark Murray 		}
774511b41d2SMark Murray 	}
7751e8db6e2SBrian Feldman 	(void) snprintf(path, sizeof path, "D%04o %d %.1024s\n",
7761e8db6e2SBrian Feldman 	    (u_int) (statp->st_mode & FILEMODEMASK), 0, last);
777511b41d2SMark Murray 	if (verbose_mode)
778511b41d2SMark Murray 		fprintf(stderr, "Entering directory: %s", path);
779cf2b5f3bSDag-Erling Smørgrav 	(void) atomicio(vwrite, remout, path, strlen(path));
780511b41d2SMark Murray 	if (response() < 0) {
781511b41d2SMark Murray 		closedir(dirp);
782511b41d2SMark Murray 		return;
783511b41d2SMark Murray 	}
7841e8db6e2SBrian Feldman 	while ((dp = readdir(dirp)) != NULL) {
785511b41d2SMark Murray 		if (dp->d_ino == 0)
786511b41d2SMark Murray 			continue;
787511b41d2SMark Murray 		if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
788511b41d2SMark Murray 			continue;
789511b41d2SMark Murray 		if (strlen(name) + 1 + strlen(dp->d_name) >= sizeof(path) - 1) {
790511b41d2SMark Murray 			run_err("%s/%s: name too long", name, dp->d_name);
791511b41d2SMark Murray 			continue;
792511b41d2SMark Murray 		}
7931e8db6e2SBrian Feldman 		(void) snprintf(path, sizeof path, "%s/%s", name, dp->d_name);
794511b41d2SMark Murray 		vect[0] = path;
795511b41d2SMark Murray 		source(1, vect);
796511b41d2SMark Murray 	}
797511b41d2SMark Murray 	(void) closedir(dirp);
798cf2b5f3bSDag-Erling Smørgrav 	(void) atomicio(vwrite, remout, "E\n", 2);
799511b41d2SMark Murray 	(void) response();
800511b41d2SMark Murray }
801511b41d2SMark Murray 
802511b41d2SMark Murray void
803e73e9afaSDag-Erling Smørgrav bwlimit(int amount)
804e73e9afaSDag-Erling Smørgrav {
805e73e9afaSDag-Erling Smørgrav 	static struct timeval bwstart, bwend;
806e73e9afaSDag-Erling Smørgrav 	static int lamt, thresh = 16384;
80721e764dfSDag-Erling Smørgrav 	u_int64_t waitlen;
808e73e9afaSDag-Erling Smørgrav 	struct timespec ts, rm;
809e73e9afaSDag-Erling Smørgrav 
810e73e9afaSDag-Erling Smørgrav 	if (!timerisset(&bwstart)) {
811e73e9afaSDag-Erling Smørgrav 		gettimeofday(&bwstart, NULL);
812e73e9afaSDag-Erling Smørgrav 		return;
813e73e9afaSDag-Erling Smørgrav 	}
814e73e9afaSDag-Erling Smørgrav 
815e73e9afaSDag-Erling Smørgrav 	lamt += amount;
816e73e9afaSDag-Erling Smørgrav 	if (lamt < thresh)
817e73e9afaSDag-Erling Smørgrav 		return;
818e73e9afaSDag-Erling Smørgrav 
819e73e9afaSDag-Erling Smørgrav 	gettimeofday(&bwend, NULL);
820e73e9afaSDag-Erling Smørgrav 	timersub(&bwend, &bwstart, &bwend);
821e73e9afaSDag-Erling Smørgrav 	if (!timerisset(&bwend))
822e73e9afaSDag-Erling Smørgrav 		return;
823e73e9afaSDag-Erling Smørgrav 
824e73e9afaSDag-Erling Smørgrav 	lamt *= 8;
82521e764dfSDag-Erling Smørgrav 	waitlen = (double)1000000L * lamt / limit_rate;
826e73e9afaSDag-Erling Smørgrav 
82721e764dfSDag-Erling Smørgrav 	bwstart.tv_sec = waitlen / 1000000L;
82821e764dfSDag-Erling Smørgrav 	bwstart.tv_usec = waitlen % 1000000L;
829e73e9afaSDag-Erling Smørgrav 
830e73e9afaSDag-Erling Smørgrav 	if (timercmp(&bwstart, &bwend, >)) {
831e73e9afaSDag-Erling Smørgrav 		timersub(&bwstart, &bwend, &bwend);
832e73e9afaSDag-Erling Smørgrav 
833e73e9afaSDag-Erling Smørgrav 		/* Adjust the wait time */
834e73e9afaSDag-Erling Smørgrav 		if (bwend.tv_sec) {
835e73e9afaSDag-Erling Smørgrav 			thresh /= 2;
836e73e9afaSDag-Erling Smørgrav 			if (thresh < 2048)
837e73e9afaSDag-Erling Smørgrav 				thresh = 2048;
838d4af9e69SDag-Erling Smørgrav 		} else if (bwend.tv_usec < 10000) {
839e73e9afaSDag-Erling Smørgrav 			thresh *= 2;
840d4af9e69SDag-Erling Smørgrav 			if (thresh > COPY_BUFLEN * 4)
841d4af9e69SDag-Erling Smørgrav 				thresh = COPY_BUFLEN * 4;
842e73e9afaSDag-Erling Smørgrav 		}
843e73e9afaSDag-Erling Smørgrav 
844e73e9afaSDag-Erling Smørgrav 		TIMEVAL_TO_TIMESPEC(&bwend, &ts);
845e73e9afaSDag-Erling Smørgrav 		while (nanosleep(&ts, &rm) == -1) {
846e73e9afaSDag-Erling Smørgrav 			if (errno != EINTR)
847e73e9afaSDag-Erling Smørgrav 				break;
848e73e9afaSDag-Erling Smørgrav 			ts = rm;
849e73e9afaSDag-Erling Smørgrav 		}
850e73e9afaSDag-Erling Smørgrav 	}
851e73e9afaSDag-Erling Smørgrav 
852e73e9afaSDag-Erling Smørgrav 	lamt = 0;
853e73e9afaSDag-Erling Smørgrav 	gettimeofday(&bwstart, NULL);
854e73e9afaSDag-Erling Smørgrav }
855e73e9afaSDag-Erling Smørgrav 
856e73e9afaSDag-Erling Smørgrav void
857cf2b5f3bSDag-Erling Smørgrav sink(int argc, char **argv)
858511b41d2SMark Murray {
859511b41d2SMark Murray 	static BUF buffer;
860511b41d2SMark Murray 	struct stat stb;
861511b41d2SMark Murray 	enum {
862511b41d2SMark Murray 		YES, NO, DISPLAYED
863511b41d2SMark Murray 	} wrerr;
864511b41d2SMark Murray 	BUF *bp;
865d4ecd108SDag-Erling Smørgrav 	off_t i;
866d4ecd108SDag-Erling Smørgrav 	size_t j, count;
867333ee039SDag-Erling Smørgrav 	int amt, exists, first, ofd;
868333ee039SDag-Erling Smørgrav 	mode_t mode, omode, mask;
869e73e9afaSDag-Erling Smørgrav 	off_t size, statbytes;
870b66f2d16SKris Kennaway 	int setimes, targisdir, wrerrno = 0;
871511b41d2SMark Murray 	char ch, *cp, *np, *targ, *why, *vect[1], buf[2048];
8725b9b2fafSBrian Feldman 	struct timeval tv[2];
873511b41d2SMark Murray 
8741e8db6e2SBrian Feldman #define	atime	tv[0]
8751e8db6e2SBrian Feldman #define	mtime	tv[1]
876aa49c926SDag-Erling Smørgrav #define	SCREWUP(str)	{ why = str; goto screwup; }
877511b41d2SMark Murray 
878511b41d2SMark Murray 	setimes = targisdir = 0;
879511b41d2SMark Murray 	mask = umask(0);
880511b41d2SMark Murray 	if (!pflag)
881511b41d2SMark Murray 		(void) umask(mask);
882511b41d2SMark Murray 	if (argc != 1) {
883511b41d2SMark Murray 		run_err("ambiguous target");
884511b41d2SMark Murray 		exit(1);
885511b41d2SMark Murray 	}
886511b41d2SMark Murray 	targ = *argv;
887511b41d2SMark Murray 	if (targetshouldbedirectory)
888511b41d2SMark Murray 		verifydir(targ);
889511b41d2SMark Murray 
890cf2b5f3bSDag-Erling Smørgrav 	(void) atomicio(vwrite, remout, "", 1);
891511b41d2SMark Murray 	if (stat(targ, &stb) == 0 && S_ISDIR(stb.st_mode))
892511b41d2SMark Murray 		targisdir = 1;
893511b41d2SMark Murray 	for (first = 1;; first = 0) {
894511b41d2SMark Murray 		cp = buf;
895d4ecd108SDag-Erling Smørgrav 		if (atomicio(read, remin, cp, 1) != 1)
896511b41d2SMark Murray 			return;
897511b41d2SMark Murray 		if (*cp++ == '\n')
898511b41d2SMark Murray 			SCREWUP("unexpected <newline>");
899511b41d2SMark Murray 		do {
900a04a10f8SKris Kennaway 			if (atomicio(read, remin, &ch, sizeof(ch)) != sizeof(ch))
901511b41d2SMark Murray 				SCREWUP("lost connection");
902511b41d2SMark Murray 			*cp++ = ch;
903511b41d2SMark Murray 		} while (cp < &buf[sizeof(buf) - 1] && ch != '\n');
904511b41d2SMark Murray 		*cp = 0;
90521e764dfSDag-Erling Smørgrav 		if (verbose_mode)
90621e764dfSDag-Erling Smørgrav 			fprintf(stderr, "Sink: %s", buf);
907511b41d2SMark Murray 
908511b41d2SMark Murray 		if (buf[0] == '\01' || buf[0] == '\02') {
909511b41d2SMark Murray 			if (iamremote == 0)
910cf2b5f3bSDag-Erling Smørgrav 				(void) atomicio(vwrite, STDERR_FILENO,
911511b41d2SMark Murray 				    buf + 1, strlen(buf + 1));
912511b41d2SMark Murray 			if (buf[0] == '\02')
913511b41d2SMark Murray 				exit(1);
914511b41d2SMark Murray 			++errs;
915511b41d2SMark Murray 			continue;
916511b41d2SMark Murray 		}
917511b41d2SMark Murray 		if (buf[0] == 'E') {
918cf2b5f3bSDag-Erling Smørgrav 			(void) atomicio(vwrite, remout, "", 1);
919511b41d2SMark Murray 			return;
920511b41d2SMark Murray 		}
921511b41d2SMark Murray 		if (ch == '\n')
922511b41d2SMark Murray 			*--cp = 0;
923511b41d2SMark Murray 
924511b41d2SMark Murray 		cp = buf;
925511b41d2SMark Murray 		if (*cp == 'T') {
926511b41d2SMark Murray 			setimes++;
927511b41d2SMark Murray 			cp++;
9281e8db6e2SBrian Feldman 			mtime.tv_sec = strtol(cp, &cp, 10);
9291e8db6e2SBrian Feldman 			if (!cp || *cp++ != ' ')
930511b41d2SMark Murray 				SCREWUP("mtime.sec not delimited");
9311e8db6e2SBrian Feldman 			mtime.tv_usec = strtol(cp, &cp, 10);
9321e8db6e2SBrian Feldman 			if (!cp || *cp++ != ' ')
933511b41d2SMark Murray 				SCREWUP("mtime.usec not delimited");
9341e8db6e2SBrian Feldman 			atime.tv_sec = strtol(cp, &cp, 10);
9351e8db6e2SBrian Feldman 			if (!cp || *cp++ != ' ')
936511b41d2SMark Murray 				SCREWUP("atime.sec not delimited");
9371e8db6e2SBrian Feldman 			atime.tv_usec = strtol(cp, &cp, 10);
9381e8db6e2SBrian Feldman 			if (!cp || *cp++ != '\0')
939511b41d2SMark Murray 				SCREWUP("atime.usec not delimited");
940cf2b5f3bSDag-Erling Smørgrav 			(void) atomicio(vwrite, remout, "", 1);
941511b41d2SMark Murray 			continue;
942511b41d2SMark Murray 		}
943511b41d2SMark Murray 		if (*cp != 'C' && *cp != 'D') {
944511b41d2SMark Murray 			/*
945511b41d2SMark Murray 			 * Check for the case "rcp remote:foo\* local:bar".
946511b41d2SMark Murray 			 * In this case, the line "No match." can be returned
947511b41d2SMark Murray 			 * by the shell before the rcp command on the remote is
948511b41d2SMark Murray 			 * executed so the ^Aerror_message convention isn't
949511b41d2SMark Murray 			 * followed.
950511b41d2SMark Murray 			 */
951511b41d2SMark Murray 			if (first) {
952511b41d2SMark Murray 				run_err("%s", cp);
953511b41d2SMark Murray 				exit(1);
954511b41d2SMark Murray 			}
955511b41d2SMark Murray 			SCREWUP("expected control record");
956511b41d2SMark Murray 		}
957511b41d2SMark Murray 		mode = 0;
958511b41d2SMark Murray 		for (++cp; cp < buf + 5; cp++) {
959511b41d2SMark Murray 			if (*cp < '0' || *cp > '7')
960511b41d2SMark Murray 				SCREWUP("bad mode");
961511b41d2SMark Murray 			mode = (mode << 3) | (*cp - '0');
962511b41d2SMark Murray 		}
963511b41d2SMark Murray 		if (*cp++ != ' ')
964511b41d2SMark Murray 			SCREWUP("mode not delimited");
965511b41d2SMark Murray 
9661e8db6e2SBrian Feldman 		for (size = 0; isdigit(*cp);)
967511b41d2SMark Murray 			size = size * 10 + (*cp++ - '0');
968511b41d2SMark Murray 		if (*cp++ != ' ')
969511b41d2SMark Murray 			SCREWUP("size not delimited");
97021e764dfSDag-Erling Smørgrav 		if ((strchr(cp, '/') != NULL) || (strcmp(cp, "..") == 0)) {
97121e764dfSDag-Erling Smørgrav 			run_err("error: unexpected filename: %s", cp);
97221e764dfSDag-Erling Smørgrav 			exit(1);
97321e764dfSDag-Erling Smørgrav 		}
974511b41d2SMark Murray 		if (targisdir) {
975511b41d2SMark Murray 			static char *namebuf;
976d4ecd108SDag-Erling Smørgrav 			static size_t cursize;
977511b41d2SMark Murray 			size_t need;
978511b41d2SMark Murray 
979511b41d2SMark Murray 			need = strlen(targ) + strlen(cp) + 250;
9801e8db6e2SBrian Feldman 			if (need > cursize) {
9811e8db6e2SBrian Feldman 				if (namebuf)
9821e8db6e2SBrian Feldman 					xfree(namebuf);
983511b41d2SMark Murray 				namebuf = xmalloc(need);
9841e8db6e2SBrian Feldman 				cursize = need;
9851e8db6e2SBrian Feldman 			}
9861e8db6e2SBrian Feldman 			(void) snprintf(namebuf, need, "%s%s%s", targ,
987545d5ecaSDag-Erling Smørgrav 			    strcmp(targ, "/") ? "/" : "", cp);
988511b41d2SMark Murray 			np = namebuf;
989511b41d2SMark Murray 		} else
990511b41d2SMark Murray 			np = targ;
991511b41d2SMark Murray 		curfile = cp;
992511b41d2SMark Murray 		exists = stat(np, &stb) == 0;
993511b41d2SMark Murray 		if (buf[0] == 'D') {
994511b41d2SMark Murray 			int mod_flag = pflag;
99521e764dfSDag-Erling Smørgrav 			if (!iamrecursive)
99621e764dfSDag-Erling Smørgrav 				SCREWUP("received directory without -r");
997511b41d2SMark Murray 			if (exists) {
998511b41d2SMark Murray 				if (!S_ISDIR(stb.st_mode)) {
999511b41d2SMark Murray 					errno = ENOTDIR;
1000511b41d2SMark Murray 					goto bad;
1001511b41d2SMark Murray 				}
1002511b41d2SMark Murray 				if (pflag)
1003511b41d2SMark Murray 					(void) chmod(np, mode);
1004511b41d2SMark Murray 			} else {
1005511b41d2SMark Murray 				/* Handle copying from a read-only
1006511b41d2SMark Murray 				   directory */
1007511b41d2SMark Murray 				mod_flag = 1;
1008511b41d2SMark Murray 				if (mkdir(np, mode | S_IRWXU) < 0)
1009511b41d2SMark Murray 					goto bad;
1010511b41d2SMark Murray 			}
10111e8db6e2SBrian Feldman 			vect[0] = xstrdup(np);
1012511b41d2SMark Murray 			sink(1, vect);
1013511b41d2SMark Murray 			if (setimes) {
1014511b41d2SMark Murray 				setimes = 0;
10151e8db6e2SBrian Feldman 				if (utimes(vect[0], tv) < 0)
1016511b41d2SMark Murray 					run_err("%s: set times: %s",
10171e8db6e2SBrian Feldman 					    vect[0], strerror(errno));
1018511b41d2SMark Murray 			}
1019511b41d2SMark Murray 			if (mod_flag)
10201e8db6e2SBrian Feldman 				(void) chmod(vect[0], mode);
10211e8db6e2SBrian Feldman 			if (vect[0])
10221e8db6e2SBrian Feldman 				xfree(vect[0]);
1023511b41d2SMark Murray 			continue;
1024511b41d2SMark Murray 		}
1025511b41d2SMark Murray 		omode = mode;
1026511b41d2SMark Murray 		mode |= S_IWRITE;
1027ae1f160dSDag-Erling Smørgrav 		if ((ofd = open(np, O_WRONLY|O_CREAT, mode)) < 0) {
1028511b41d2SMark Murray bad:			run_err("%s: %s", np, strerror(errno));
1029511b41d2SMark Murray 			continue;
1030511b41d2SMark Murray 		}
1031cf2b5f3bSDag-Erling Smørgrav 		(void) atomicio(vwrite, remout, "", 1);
1032d4af9e69SDag-Erling Smørgrav 		if ((bp = allocbuf(&buffer, ofd, COPY_BUFLEN)) == NULL) {
1033511b41d2SMark Murray 			(void) close(ofd);
1034511b41d2SMark Murray 			continue;
1035511b41d2SMark Murray 		}
1036511b41d2SMark Murray 		cp = bp->buf;
1037511b41d2SMark Murray 		wrerr = NO;
1038511b41d2SMark Murray 
1039511b41d2SMark Murray 		statbytes = 0;
1040e73e9afaSDag-Erling Smørgrav 		if (showprogress)
1041e73e9afaSDag-Erling Smørgrav 			start_progress_meter(curfile, size, &statbytes);
1042d4af9e69SDag-Erling Smørgrav 		set_nonblock(remin);
1043d4af9e69SDag-Erling Smørgrav 		for (count = i = 0; i < size; i += bp->cnt) {
1044d4af9e69SDag-Erling Smørgrav 			amt = bp->cnt;
1045511b41d2SMark Murray 			if (i + amt > size)
1046511b41d2SMark Murray 				amt = size - i;
1047511b41d2SMark Murray 			count += amt;
1048511b41d2SMark Murray 			do {
1049d4af9e69SDag-Erling Smørgrav 				j = scpio(read, remin, cp, amt, &statbytes);
1050d4ecd108SDag-Erling Smørgrav 				if (j == 0) {
1051d4af9e69SDag-Erling Smørgrav 					run_err("%s", j != EPIPE ?
1052d4af9e69SDag-Erling Smørgrav 					    strerror(errno) :
1053511b41d2SMark Murray 					    "dropped connection");
1054511b41d2SMark Murray 					exit(1);
1055511b41d2SMark Murray 				}
1056511b41d2SMark Murray 				amt -= j;
1057511b41d2SMark Murray 				cp += j;
1058511b41d2SMark Murray 			} while (amt > 0);
1059e73e9afaSDag-Erling Smørgrav 
1060511b41d2SMark Murray 			if (count == bp->cnt) {
1061511b41d2SMark Murray 				/* Keep reading so we stay sync'd up. */
1062511b41d2SMark Murray 				if (wrerr == NO) {
1063d4ecd108SDag-Erling Smørgrav 					if (atomicio(vwrite, ofd, bp->buf,
1064d4ecd108SDag-Erling Smørgrav 					    count) != count) {
1065511b41d2SMark Murray 						wrerr = YES;
1066d4ecd108SDag-Erling Smørgrav 						wrerrno = errno;
1067511b41d2SMark Murray 					}
1068511b41d2SMark Murray 				}
1069511b41d2SMark Murray 				count = 0;
1070511b41d2SMark Murray 				cp = bp->buf;
1071511b41d2SMark Murray 			}
1072511b41d2SMark Murray 		}
1073d4af9e69SDag-Erling Smørgrav 		unset_nonblock(remin);
1074511b41d2SMark Murray 		if (showprogress)
1075e73e9afaSDag-Erling Smørgrav 			stop_progress_meter();
1076511b41d2SMark Murray 		if (count != 0 && wrerr == NO &&
1077d4ecd108SDag-Erling Smørgrav 		    atomicio(vwrite, ofd, bp->buf, count) != count) {
1078511b41d2SMark Murray 			wrerr = YES;
1079d4ecd108SDag-Erling Smørgrav 			wrerrno = errno;
1080511b41d2SMark Murray 		}
1081d4af9e69SDag-Erling Smørgrav 		if (wrerr == NO && (!exists || S_ISREG(stb.st_mode)) &&
1082d4af9e69SDag-Erling Smørgrav 		    ftruncate(ofd, size) != 0) {
1083511b41d2SMark Murray 			run_err("%s: truncate: %s", np, strerror(errno));
1084511b41d2SMark Murray 			wrerr = DISPLAYED;
1085511b41d2SMark Murray 		}
1086511b41d2SMark Murray 		if (pflag) {
1087511b41d2SMark Murray 			if (exists || omode != mode)
108883d2307dSDag-Erling Smørgrav #ifdef HAVE_FCHMOD
108921e764dfSDag-Erling Smørgrav 				if (fchmod(ofd, omode)) {
109083d2307dSDag-Erling Smørgrav #else /* HAVE_FCHMOD */
109121e764dfSDag-Erling Smørgrav 				if (chmod(np, omode)) {
109283d2307dSDag-Erling Smørgrav #endif /* HAVE_FCHMOD */
1093511b41d2SMark Murray 					run_err("%s: set mode: %s",
1094511b41d2SMark Murray 					    np, strerror(errno));
109521e764dfSDag-Erling Smørgrav 					wrerr = DISPLAYED;
109621e764dfSDag-Erling Smørgrav 				}
1097511b41d2SMark Murray 		} else {
1098511b41d2SMark Murray 			if (!exists && omode != mode)
109983d2307dSDag-Erling Smørgrav #ifdef HAVE_FCHMOD
110021e764dfSDag-Erling Smørgrav 				if (fchmod(ofd, omode & ~mask)) {
110183d2307dSDag-Erling Smørgrav #else /* HAVE_FCHMOD */
110221e764dfSDag-Erling Smørgrav 				if (chmod(np, omode & ~mask)) {
110383d2307dSDag-Erling Smørgrav #endif /* HAVE_FCHMOD */
1104511b41d2SMark Murray 					run_err("%s: set mode: %s",
1105511b41d2SMark Murray 					    np, strerror(errno));
110621e764dfSDag-Erling Smørgrav 					wrerr = DISPLAYED;
110721e764dfSDag-Erling Smørgrav 				}
1108511b41d2SMark Murray 		}
1109b66f2d16SKris Kennaway 		if (close(ofd) == -1) {
1110b66f2d16SKris Kennaway 			wrerr = YES;
1111b66f2d16SKris Kennaway 			wrerrno = errno;
1112b66f2d16SKris Kennaway 		}
1113511b41d2SMark Murray 		(void) response();
1114511b41d2SMark Murray 		if (setimes && wrerr == NO) {
1115511b41d2SMark Murray 			setimes = 0;
11165b9b2fafSBrian Feldman 			if (utimes(np, tv) < 0) {
1117511b41d2SMark Murray 				run_err("%s: set times: %s",
1118511b41d2SMark Murray 				    np, strerror(errno));
1119511b41d2SMark Murray 				wrerr = DISPLAYED;
1120511b41d2SMark Murray 			}
1121511b41d2SMark Murray 		}
1122511b41d2SMark Murray 		switch (wrerr) {
1123511b41d2SMark Murray 		case YES:
1124511b41d2SMark Murray 			run_err("%s: %s", np, strerror(wrerrno));
1125511b41d2SMark Murray 			break;
1126511b41d2SMark Murray 		case NO:
1127cf2b5f3bSDag-Erling Smørgrav 			(void) atomicio(vwrite, remout, "", 1);
1128511b41d2SMark Murray 			break;
1129511b41d2SMark Murray 		case DISPLAYED:
1130511b41d2SMark Murray 			break;
1131511b41d2SMark Murray 		}
1132511b41d2SMark Murray 	}
1133511b41d2SMark Murray screwup:
1134511b41d2SMark Murray 	run_err("protocol error: %s", why);
1135511b41d2SMark Murray 	exit(1);
1136511b41d2SMark Murray }
1137511b41d2SMark Murray 
1138511b41d2SMark Murray int
1139ae1f160dSDag-Erling Smørgrav response(void)
1140511b41d2SMark Murray {
1141511b41d2SMark Murray 	char ch, *cp, resp, rbuf[2048];
1142511b41d2SMark Murray 
1143a04a10f8SKris Kennaway 	if (atomicio(read, remin, &resp, sizeof(resp)) != sizeof(resp))
1144511b41d2SMark Murray 		lostconn(0);
1145511b41d2SMark Murray 
1146511b41d2SMark Murray 	cp = rbuf;
1147511b41d2SMark Murray 	switch (resp) {
1148511b41d2SMark Murray 	case 0:		/* ok */
1149511b41d2SMark Murray 		return (0);
1150511b41d2SMark Murray 	default:
1151511b41d2SMark Murray 		*cp++ = resp;
1152511b41d2SMark Murray 		/* FALLTHROUGH */
1153511b41d2SMark Murray 	case 1:		/* error, followed by error msg */
1154511b41d2SMark Murray 	case 2:		/* fatal error, "" */
1155511b41d2SMark Murray 		do {
1156a04a10f8SKris Kennaway 			if (atomicio(read, remin, &ch, sizeof(ch)) != sizeof(ch))
1157511b41d2SMark Murray 				lostconn(0);
1158511b41d2SMark Murray 			*cp++ = ch;
1159511b41d2SMark Murray 		} while (cp < &rbuf[sizeof(rbuf) - 1] && ch != '\n');
1160511b41d2SMark Murray 
1161511b41d2SMark Murray 		if (!iamremote)
1162cf2b5f3bSDag-Erling Smørgrav 			(void) atomicio(vwrite, STDERR_FILENO, rbuf, cp - rbuf);
1163511b41d2SMark Murray 		++errs;
1164511b41d2SMark Murray 		if (resp == 1)
1165511b41d2SMark Murray 			return (-1);
1166511b41d2SMark Murray 		exit(1);
1167511b41d2SMark Murray 	}
1168511b41d2SMark Murray 	/* NOTREACHED */
1169511b41d2SMark Murray }
1170511b41d2SMark Murray 
1171511b41d2SMark Murray void
1172ae1f160dSDag-Erling Smørgrav usage(void)
1173511b41d2SMark Murray {
1174ae1f160dSDag-Erling Smørgrav 	(void) fprintf(stderr,
11751ec0d754SDag-Erling Smørgrav 	    "usage: scp [-1246BCpqrv] [-c cipher] [-F ssh_config] [-i identity_file]\n"
11761ec0d754SDag-Erling Smørgrav 	    "           [-l limit] [-o ssh_option] [-P port] [-S program]\n"
1177d4af9e69SDag-Erling Smørgrav 	    "           [[user@]host1:]file1 ... [[user@]host2:]file2\n");
1178511b41d2SMark Murray 	exit(1);
1179511b41d2SMark Murray }
1180511b41d2SMark Murray 
1181511b41d2SMark Murray void
1182511b41d2SMark Murray run_err(const char *fmt,...)
1183511b41d2SMark Murray {
1184511b41d2SMark Murray 	static FILE *fp;
1185511b41d2SMark Murray 	va_list ap;
1186511b41d2SMark Murray 
1187511b41d2SMark Murray 	++errs;
1188333ee039SDag-Erling Smørgrav 	if (fp != NULL || (remout != -1 && (fp = fdopen(remout, "w")))) {
1189511b41d2SMark Murray 		(void) fprintf(fp, "%c", 0x01);
1190511b41d2SMark Murray 		(void) fprintf(fp, "scp: ");
1191ae1f160dSDag-Erling Smørgrav 		va_start(ap, fmt);
1192511b41d2SMark Murray 		(void) vfprintf(fp, fmt, ap);
1193ae1f160dSDag-Erling Smørgrav 		va_end(ap);
1194511b41d2SMark Murray 		(void) fprintf(fp, "\n");
1195511b41d2SMark Murray 		(void) fflush(fp);
1196333ee039SDag-Erling Smørgrav 	}
1197511b41d2SMark Murray 
1198511b41d2SMark Murray 	if (!iamremote) {
1199ae1f160dSDag-Erling Smørgrav 		va_start(ap, fmt);
1200511b41d2SMark Murray 		vfprintf(stderr, fmt, ap);
1201ae1f160dSDag-Erling Smørgrav 		va_end(ap);
1202511b41d2SMark Murray 		fprintf(stderr, "\n");
1203511b41d2SMark Murray 	}
1204511b41d2SMark Murray }
1205511b41d2SMark Murray 
1206511b41d2SMark Murray void
1207cf2b5f3bSDag-Erling Smørgrav verifydir(char *cp)
1208511b41d2SMark Murray {
1209511b41d2SMark Murray 	struct stat stb;
1210511b41d2SMark Murray 
1211511b41d2SMark Murray 	if (!stat(cp, &stb)) {
1212511b41d2SMark Murray 		if (S_ISDIR(stb.st_mode))
1213511b41d2SMark Murray 			return;
1214511b41d2SMark Murray 		errno = ENOTDIR;
1215511b41d2SMark Murray 	}
1216511b41d2SMark Murray 	run_err("%s: %s", cp, strerror(errno));
1217d4ecd108SDag-Erling Smørgrav 	killchild(0);
1218511b41d2SMark Murray }
1219511b41d2SMark Murray 
1220511b41d2SMark Murray int
1221cf2b5f3bSDag-Erling Smørgrav okname(char *cp0)
1222511b41d2SMark Murray {
1223511b41d2SMark Murray 	int c;
1224511b41d2SMark Murray 	char *cp;
1225511b41d2SMark Murray 
1226511b41d2SMark Murray 	cp = cp0;
1227511b41d2SMark Murray 	do {
1228ae1f160dSDag-Erling Smørgrav 		c = (int)*cp;
1229511b41d2SMark Murray 		if (c & 0200)
1230511b41d2SMark Murray 			goto bad;
1231e73e9afaSDag-Erling Smørgrav 		if (!isalpha(c) && !isdigit(c)) {
1232e73e9afaSDag-Erling Smørgrav 			switch (c) {
1233e73e9afaSDag-Erling Smørgrav 			case '\'':
1234e73e9afaSDag-Erling Smørgrav 			case '"':
1235e73e9afaSDag-Erling Smørgrav 			case '`':
1236e73e9afaSDag-Erling Smørgrav 			case ' ':
1237e73e9afaSDag-Erling Smørgrav 			case '#':
1238511b41d2SMark Murray 				goto bad;
1239e73e9afaSDag-Erling Smørgrav 			default:
1240e73e9afaSDag-Erling Smørgrav 				break;
1241e73e9afaSDag-Erling Smørgrav 			}
1242e73e9afaSDag-Erling Smørgrav 		}
1243511b41d2SMark Murray 	} while (*++cp);
1244511b41d2SMark Murray 	return (1);
1245511b41d2SMark Murray 
1246511b41d2SMark Murray bad:	fprintf(stderr, "%s: invalid user name\n", cp0);
1247511b41d2SMark Murray 	return (0);
1248511b41d2SMark Murray }
1249511b41d2SMark Murray 
1250511b41d2SMark Murray BUF *
1251cf2b5f3bSDag-Erling Smørgrav allocbuf(BUF *bp, int fd, int blksize)
1252511b41d2SMark Murray {
1253511b41d2SMark Murray 	size_t size;
125483d2307dSDag-Erling Smørgrav #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
1255511b41d2SMark Murray 	struct stat stb;
1256511b41d2SMark Murray 
1257511b41d2SMark Murray 	if (fstat(fd, &stb) < 0) {
1258511b41d2SMark Murray 		run_err("fstat: %s", strerror(errno));
1259511b41d2SMark Murray 		return (0);
1260511b41d2SMark Murray 	}
1261b6fd52a0SDag-Erling Smørgrav 	size = roundup(stb.st_blksize, blksize);
1262e73e9afaSDag-Erling Smørgrav 	if (size == 0)
1263e73e9afaSDag-Erling Smørgrav 		size = blksize;
126483d2307dSDag-Erling Smørgrav #else /* HAVE_STRUCT_STAT_ST_BLKSIZE */
126583d2307dSDag-Erling Smørgrav 	size = blksize;
126683d2307dSDag-Erling Smørgrav #endif /* HAVE_STRUCT_STAT_ST_BLKSIZE */
1267511b41d2SMark Murray 	if (bp->cnt >= size)
1268511b41d2SMark Murray 		return (bp);
1269511b41d2SMark Murray 	if (bp->buf == NULL)
1270511b41d2SMark Murray 		bp->buf = xmalloc(size);
1271511b41d2SMark Murray 	else
1272333ee039SDag-Erling Smørgrav 		bp->buf = xrealloc(bp->buf, 1, size);
1273ae1f160dSDag-Erling Smørgrav 	memset(bp->buf, 0, size);
1274511b41d2SMark Murray 	bp->cnt = size;
1275511b41d2SMark Murray 	return (bp);
1276511b41d2SMark Murray }
1277511b41d2SMark Murray 
1278511b41d2SMark Murray void
1279cf2b5f3bSDag-Erling Smørgrav lostconn(int signo)
1280511b41d2SMark Murray {
1281511b41d2SMark Murray 	if (!iamremote)
1282ae1f160dSDag-Erling Smørgrav 		write(STDERR_FILENO, "lost connection\n", 16);
1283ae1f160dSDag-Erling Smørgrav 	if (signo)
1284ae1f160dSDag-Erling Smørgrav 		_exit(1);
1285ae1f160dSDag-Erling Smørgrav 	else
1286511b41d2SMark Murray 		exit(1);
1287511b41d2SMark Murray }
1288