blob: 5a5d0f4693a7e021afb72869c48678a8a8710cc8 [file] [log] [blame]
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001/*
Damien Miller4af51302000-04-16 11:18:38 +10002 *
Damien Miller95def091999-11-25 00:26:21 +11003 * scp - secure remote copy. This is basically patched BSD rcp which uses ssh
4 * to do the data transfer (instead of using rcmd).
Damien Miller4af51302000-04-16 11:18:38 +10005 *
Damien Miller95def091999-11-25 00:26:21 +11006 * NOTE: This version should NOT be suid root. (This uses ssh to do the transfer
7 * and ssh has the necessary privileges.)
Damien Miller4af51302000-04-16 11:18:38 +10008 *
Damien Miller95def091999-11-25 00:26:21 +11009 * 1995 Timo Rinne <tri@iki.fi>, Tatu Ylonen <ylo@cs.hut.fi>
Damien Miller4af51302000-04-16 11:18:38 +100010 *
Damien Millerd4a8b7e1999-10-27 13:42:43 +100011*/
12
13/*
Damien Millerad833b32000-08-23 10:46:23 +100014 * Parts from:
15 *
Damien Millerd4a8b7e1999-10-27 13:42:43 +100016 * Copyright (c) 1983, 1990, 1992, 1993, 1995
17 * The Regents of the University of California. All rights reserved.
18 *
19 * Redistribution and use in source and binary forms, with or without
20 * modification, are permitted provided that the following conditions
21 * are met:
22 * 1. Redistributions of source code must retain the above copyright
23 * notice, this list of conditions and the following disclaimer.
24 * 2. Redistributions in binary form must reproduce the above copyright
25 * notice, this list of conditions and the following disclaimer in the
26 * documentation and/or other materials provided with the distribution.
27 * 3. All advertising materials mentioning features or use of this software
28 * must display the following acknowledgement:
29 * This product includes software developed by the University of
30 * California, Berkeley and its contributors.
31 * 4. Neither the name of the University nor the names of its contributors
32 * may be used to endorse or promote products derived from this software
33 * without specific prior written permission.
34 *
35 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
36 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
37 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
38 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
39 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
40 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
41 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
42 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
43 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
44 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
45 * SUCH DAMAGE.
46 *
Damien Millerd4a8b7e1999-10-27 13:42:43 +100047 */
48
49#include "includes.h"
Damien Millercaf6dd62000-08-29 11:33:50 +110050RCSID("$OpenBSD: scp.c,v 1.36 2000/08/24 21:46:59 deraadt Exp $");
Damien Millerd4a8b7e1999-10-27 13:42:43 +100051
52#include "ssh.h"
53#include "xmalloc.h"
54#include <utime.h>
55
56#define _PATH_CP "cp"
57
58/* For progressmeter() -- number of seconds before xfer considered "stalled" */
59#define STALLTIME 5
60
Damien Miller484118e2000-07-02 19:13:56 +100061/* Progress meter bar */
62#define BAR \
63 "************************************************************"\
64 "************************************************************"\
65 "************************************************************"\
66 "************************************************************"
67#define MAX_BARLENGTH (sizeof(BAR) - 1)
68
Damien Millerd4a8b7e1999-10-27 13:42:43 +100069/* Visual statistics about files as they are transferred. */
70void progressmeter(int);
71
72/* Returns width of the terminal (for progress meter calculations). */
73int getttywidth(void);
Damien Millerad833b32000-08-23 10:46:23 +100074int do_cmd(char *host, char *remuser, char *cmd, int *fdin, int *fdout, int argc);
Damien Millerd4a8b7e1999-10-27 13:42:43 +100075
76/* Time a transfer started. */
77static struct timeval start;
78
79/* Number of bytes of current file transferred so far. */
80volatile unsigned long statbytes;
81
82/* Total size of current file. */
Damien Millera2d6efe1999-11-13 13:22:46 +110083off_t totalbytes = 0;
Damien Millerd4a8b7e1999-10-27 13:42:43 +100084
85/* Name of current file being transferred. */
86char *curfile;
87
Damien Miller34132e52000-01-14 15:45:46 +110088/* This is set to non-zero if IPv4 is desired. */
89int IPv4 = 0;
90
91/* This is set to non-zero if IPv6 is desired. */
92int IPv6 = 0;
93
Damien Millerd4a8b7e1999-10-27 13:42:43 +100094/* This is set to non-zero to enable verbose mode. */
Damien Miller95def091999-11-25 00:26:21 +110095int verbose_mode = 0;
Damien Millerd4a8b7e1999-10-27 13:42:43 +100096
97/* This is set to non-zero if compression is desired. */
Damien Millerd8087f61999-11-25 12:31:26 +110098int compress_flag = 0;
Damien Millerd4a8b7e1999-10-27 13:42:43 +100099
100/* This is set to zero if the progressmeter is not desired. */
101int showprogress = 1;
102
103/* This is set to non-zero if running in batch mode (that is, password
104 and passphrase queries are not allowed). */
105int batchmode = 0;
106
107/* This is set to the cipher type string if given on the command line. */
108char *cipher = NULL;
109
Damien Miller95def091999-11-25 00:26:21 +1100110/* This is set to the RSA authentication identity file name if given on
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000111 the command line. */
112char *identity = NULL;
113
114/* This is the port to use in contacting the remote site (is non-NULL). */
115char *port = NULL;
116
Damien Millerad833b32000-08-23 10:46:23 +1000117/* This is the program to execute for the secured connection. ("ssh" or -S) */
118char *ssh_program = SSH_PROGRAM;
119
Damien Miller5428f641999-11-25 11:54:57 +1100120/*
121 * This function executes the given command as the specified user on the
122 * given host. This returns < 0 if execution fails, and >= 0 otherwise. This
123 * assigns the input and output file descriptors on success.
124 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000125
Damien Miller4af51302000-04-16 11:18:38 +1000126int
Damien Millerad833b32000-08-23 10:46:23 +1000127do_cmd(char *host, char *remuser, char *cmd, int *fdin, int *fdout, int argc)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000128{
Damien Miller95def091999-11-25 00:26:21 +1100129 int pin[2], pout[2], reserved[2];
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000130
Damien Miller95def091999-11-25 00:26:21 +1100131 if (verbose_mode)
132 fprintf(stderr, "Executing: host %s, user %s, command %s\n",
Damien Millerad833b32000-08-23 10:46:23 +1000133 host, remuser ? remuser : "(unspecified)", cmd);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000134
Damien Miller5428f641999-11-25 11:54:57 +1100135 /*
136 * Reserve two descriptors so that the real pipes won't get
137 * descriptors 0 and 1 because that will screw up dup2 below.
138 */
Damien Miller95def091999-11-25 00:26:21 +1100139 pipe(reserved);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000140
Damien Miller95def091999-11-25 00:26:21 +1100141 /* Create a socket pair for communicating with ssh. */
142 if (pipe(pin) < 0)
143 fatal("pipe: %s", strerror(errno));
144 if (pipe(pout) < 0)
145 fatal("pipe: %s", strerror(errno));
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000146
Damien Miller95def091999-11-25 00:26:21 +1100147 /* Free the reserved descriptors. */
148 close(reserved[0]);
149 close(reserved[1]);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000150
Damien Miller95def091999-11-25 00:26:21 +1100151 /* For a child to execute the command on the remote host using ssh. */
152 if (fork() == 0) {
Damien Millerad833b32000-08-23 10:46:23 +1000153 char *args[100]; /* XXX careful */
Damien Miller95def091999-11-25 00:26:21 +1100154 unsigned int i;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000155
Damien Miller95def091999-11-25 00:26:21 +1100156 /* Child. */
157 close(pin[1]);
158 close(pout[0]);
159 dup2(pin[0], 0);
160 dup2(pout[1], 1);
161 close(pin[0]);
162 close(pout[1]);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000163
Damien Miller95def091999-11-25 00:26:21 +1100164 i = 0;
Damien Millerad833b32000-08-23 10:46:23 +1000165 args[i++] = ssh_program;
Damien Miller95def091999-11-25 00:26:21 +1100166 args[i++] = "-x";
167 args[i++] = "-oFallBackToRsh no";
Damien Miller34132e52000-01-14 15:45:46 +1100168 if (IPv4)
169 args[i++] = "-4";
170 if (IPv6)
171 args[i++] = "-6";
Damien Miller95def091999-11-25 00:26:21 +1100172 if (verbose_mode)
173 args[i++] = "-v";
Damien Millerd8087f61999-11-25 12:31:26 +1100174 if (compress_flag)
Damien Miller95def091999-11-25 00:26:21 +1100175 args[i++] = "-C";
176 if (batchmode)
177 args[i++] = "-oBatchMode yes";
178 if (cipher != NULL) {
179 args[i++] = "-c";
180 args[i++] = cipher;
181 }
182 if (identity != NULL) {
183 args[i++] = "-i";
184 args[i++] = identity;
185 }
186 if (port != NULL) {
187 args[i++] = "-p";
188 args[i++] = port;
189 }
190 if (remuser != NULL) {
191 args[i++] = "-l";
192 args[i++] = remuser;
193 }
194 args[i++] = host;
195 args[i++] = cmd;
196 args[i++] = NULL;
197
Damien Millerad833b32000-08-23 10:46:23 +1000198 execvp(ssh_program, args);
199 perror(ssh_program);
Damien Miller95def091999-11-25 00:26:21 +1100200 exit(1);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000201 }
Damien Miller95def091999-11-25 00:26:21 +1100202 /* Parent. Close the other side, and return the local side. */
203 close(pin[0]);
204 *fdout = pin[1];
205 close(pout[1]);
206 *fdin = pout[0];
207 return 0;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000208}
209
Damien Miller4af51302000-04-16 11:18:38 +1000210void
Damien Miller95def091999-11-25 00:26:21 +1100211fatal(const char *fmt,...)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000212{
Damien Miller95def091999-11-25 00:26:21 +1100213 va_list ap;
214 char buf[1024];
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000215
Damien Miller95def091999-11-25 00:26:21 +1100216 va_start(ap, fmt);
217 vsnprintf(buf, sizeof(buf), fmt, ap);
218 va_end(ap);
219 fprintf(stderr, "%s\n", buf);
220 exit(255);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000221}
222
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000223typedef struct {
224 int cnt;
225 char *buf;
226} BUF;
227
228extern int iamremote;
229
Damien Miller95def091999-11-25 00:26:21 +1100230BUF *allocbuf(BUF *, int, int);
231char *colon(char *);
232void lostconn(int);
233void nospace(void);
234int okname(char *);
235void run_err(const char *,...);
236void verifydir(char *);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000237
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000238struct passwd *pwd;
Damien Miller95def091999-11-25 00:26:21 +1100239uid_t userid;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000240int errs, remin, remout;
241int pflag, iamremote, iamrecursive, targetshouldbedirectory;
242
243#define CMDNEEDS 64
244char cmd[CMDNEEDS]; /* must hold "rcp -r -p -d\0" */
245
Damien Miller95def091999-11-25 00:26:21 +1100246int response(void);
247void rsource(char *, struct stat *);
248void sink(int, char *[]);
249void source(int, char *[]);
250void tolocal(int, char *[]);
251void toremote(char *, int, char *[]);
252void usage(void);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000253
254int
255main(argc, argv)
256 int argc;
257 char *argv[];
258{
259 int ch, fflag, tflag;
260 char *targ;
261 extern char *optarg;
262 extern int optind;
263
264 fflag = tflag = 0;
Damien Millerad833b32000-08-23 10:46:23 +1000265 while ((ch = getopt(argc, argv, "dfprtvBCc:i:P:q46S")) != EOF)
Damien Miller95def091999-11-25 00:26:21 +1100266 switch (ch) {
267 /* User-visible flags. */
Damien Miller34132e52000-01-14 15:45:46 +1100268 case '4':
Damien Miller4af51302000-04-16 11:18:38 +1000269 IPv4 = 1;
Damien Miller34132e52000-01-14 15:45:46 +1100270 break;
271 case '6':
Damien Miller4af51302000-04-16 11:18:38 +1000272 IPv6 = 1;
Damien Miller34132e52000-01-14 15:45:46 +1100273 break;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000274 case 'p':
275 pflag = 1;
276 break;
277 case 'P':
Damien Miller95def091999-11-25 00:26:21 +1100278 port = optarg;
279 break;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000280 case 'r':
281 iamrecursive = 1;
282 break;
Damien Millerad833b32000-08-23 10:46:23 +1000283 case 'S':
284 ssh_program = optarg;
285 break;
286
Damien Miller95def091999-11-25 00:26:21 +1100287 /* Server options. */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000288 case 'd':
289 targetshouldbedirectory = 1;
290 break;
Damien Miller95def091999-11-25 00:26:21 +1100291 case 'f': /* "from" */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000292 iamremote = 1;
293 fflag = 1;
294 break;
Damien Miller95def091999-11-25 00:26:21 +1100295 case 't': /* "to" */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000296 iamremote = 1;
297 tflag = 1;
298 break;
299 case 'c':
300 cipher = optarg;
Damien Miller95def091999-11-25 00:26:21 +1100301 break;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000302 case 'i':
Damien Miller95def091999-11-25 00:26:21 +1100303 identity = optarg;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000304 break;
305 case 'v':
Damien Miller95def091999-11-25 00:26:21 +1100306 verbose_mode = 1;
307 break;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000308 case 'B':
Damien Miller95def091999-11-25 00:26:21 +1100309 batchmode = 1;
310 break;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000311 case 'C':
Damien Millerd8087f61999-11-25 12:31:26 +1100312 compress_flag = 1;
Damien Miller95def091999-11-25 00:26:21 +1100313 break;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000314 case 'q':
Damien Miller95def091999-11-25 00:26:21 +1100315 showprogress = 0;
316 break;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000317 case '?':
318 default:
319 usage();
320 }
321 argc -= optind;
322 argv += optind;
323
324 if ((pwd = getpwuid(userid = getuid())) == NULL)
Damien Miller95def091999-11-25 00:26:21 +1100325 fatal("unknown user %d", (int) userid);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000326
Damien Miller95def091999-11-25 00:26:21 +1100327 if (!isatty(STDERR_FILENO))
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000328 showprogress = 0;
329
330 remin = STDIN_FILENO;
331 remout = STDOUT_FILENO;
332
Damien Miller95def091999-11-25 00:26:21 +1100333 if (fflag) {
334 /* Follow "protocol", send data. */
335 (void) response();
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000336 source(argc, argv);
337 exit(errs != 0);
338 }
Damien Miller95def091999-11-25 00:26:21 +1100339 if (tflag) {
340 /* Receive data. */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000341 sink(argc, argv);
342 exit(errs != 0);
343 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000344 if (argc < 2)
345 usage();
346 if (argc > 2)
347 targetshouldbedirectory = 1;
348
349 remin = remout = -1;
350 /* Command to be executed on remote system using "ssh". */
Damien Miller95def091999-11-25 00:26:21 +1100351 (void) sprintf(cmd, "scp%s%s%s%s", verbose_mode ? " -v" : "",
Damien Millerad833b32000-08-23 10:46:23 +1000352 iamrecursive ? " -r" : "", pflag ? " -p" : "",
353 targetshouldbedirectory ? " -d" : "");
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000354
Damien Miller95def091999-11-25 00:26:21 +1100355 (void) signal(SIGPIPE, lostconn);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000356
357 if ((targ = colon(argv[argc - 1]))) /* Dest is remote host. */
358 toremote(targ, argc, argv);
359 else {
Damien Miller95def091999-11-25 00:26:21 +1100360 tolocal(argc, argv); /* Dest is local host. */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000361 if (targetshouldbedirectory)
362 verifydir(argv[argc - 1]);
363 }
364 exit(errs != 0);
365}
366
Damien Miller34132e52000-01-14 15:45:46 +1100367char *
368cleanhostname(host)
369 char *host;
370{
371 if (*host == '[' && host[strlen(host) - 1] == ']') {
372 host[strlen(host) - 1] = '\0';
373 return (host + 1);
374 } else
375 return host;
376}
377
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000378void
379toremote(targ, argc, argv)
380 char *targ, *argv[];
381 int argc;
382{
383 int i, len;
384 char *bp, *host, *src, *suser, *thost, *tuser;
385
386 *targ++ = 0;
387 if (*targ == 0)
388 targ = ".";
389
390 if ((thost = strchr(argv[argc - 1], '@'))) {
391 /* user@host */
392 *thost++ = 0;
393 tuser = argv[argc - 1];
394 if (*tuser == '\0')
395 tuser = NULL;
396 else if (!okname(tuser))
397 exit(1);
398 } else {
399 thost = argv[argc - 1];
400 tuser = NULL;
401 }
402
403 for (i = 0; i < argc - 1; i++) {
404 src = colon(argv[i]);
Damien Miller95def091999-11-25 00:26:21 +1100405 if (src) { /* remote to remote */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000406 *src++ = 0;
407 if (*src == 0)
408 src = ".";
409 host = strchr(argv[i], '@');
Damien Millerad833b32000-08-23 10:46:23 +1000410 len = strlen(ssh_program) + strlen(argv[i]) +
411 strlen(src) + (tuser ? strlen(tuser) : 0) +
412 strlen(thost) + strlen(targ) + CMDNEEDS + 32;
Damien Miller95def091999-11-25 00:26:21 +1100413 bp = xmalloc(len);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000414 if (host) {
415 *host++ = 0;
Damien Miller34132e52000-01-14 15:45:46 +1100416 host = cleanhostname(host);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000417 suser = argv[i];
418 if (*suser == '\0')
419 suser = pwd->pw_name;
420 else if (!okname(suser))
421 continue;
Damien Miller95def091999-11-25 00:26:21 +1100422 (void) sprintf(bp,
Damien Millerad833b32000-08-23 10:46:23 +1000423 "%s%s -x -o'FallBackToRsh no' -n -l %s %s %s %s '%s%s%s:%s'",
424 ssh_program, verbose_mode ? " -v" : "",
425 suser, host, cmd, src,
426 tuser ? tuser : "", tuser ? "@" : "",
427 thost, targ);
Damien Miller34132e52000-01-14 15:45:46 +1100428 } else {
429 host = cleanhostname(argv[i]);
Damien Miller95def091999-11-25 00:26:21 +1100430 (void) sprintf(bp,
Damien Millerad833b32000-08-23 10:46:23 +1000431 "exec %s%s -x -o'FallBackToRsh no' -n %s %s %s '%s%s%s:%s'",
432 ssh_program, verbose_mode ? " -v" : "",
433 host, cmd, src,
434 tuser ? tuser : "", tuser ? "@" : "",
435 thost, targ);
Damien Miller34132e52000-01-14 15:45:46 +1100436 }
Damien Miller95def091999-11-25 00:26:21 +1100437 if (verbose_mode)
438 fprintf(stderr, "Executing: %s\n", bp);
439 (void) system(bp);
440 (void) xfree(bp);
441 } else { /* local to remote */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000442 if (remin == -1) {
443 len = strlen(targ) + CMDNEEDS + 20;
Damien Miller95def091999-11-25 00:26:21 +1100444 bp = xmalloc(len);
445 (void) sprintf(bp, "%s -t %s", cmd, targ);
Damien Miller34132e52000-01-14 15:45:46 +1100446 host = cleanhostname(thost);
Damien Millerad833b32000-08-23 10:46:23 +1000447 if (do_cmd(host, tuser, bp, &remin,
448 &remout, argc) < 0)
Damien Miller95def091999-11-25 00:26:21 +1100449 exit(1);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000450 if (response() < 0)
451 exit(1);
Damien Miller95def091999-11-25 00:26:21 +1100452 (void) xfree(bp);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000453 }
Damien Miller95def091999-11-25 00:26:21 +1100454 source(1, argv + i);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000455 }
456 }
457}
458
459void
460tolocal(argc, argv)
461 int argc;
462 char *argv[];
463{
464 int i, len;
465 char *bp, *host, *src, *suser;
466
467 for (i = 0; i < argc - 1; i++) {
Damien Miller95def091999-11-25 00:26:21 +1100468 if (!(src = colon(argv[i]))) { /* Local to local. */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000469 len = strlen(_PATH_CP) + strlen(argv[i]) +
Damien Millerad833b32000-08-23 10:46:23 +1000470 strlen(argv[argc - 1]) + 20;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000471 bp = xmalloc(len);
Damien Miller95def091999-11-25 00:26:21 +1100472 (void) sprintf(bp, "exec %s%s%s %s %s", _PATH_CP,
Damien Millerad833b32000-08-23 10:46:23 +1000473 iamrecursive ? " -r" : "", pflag ? " -p" : "",
474 argv[i], argv[argc - 1]);
Damien Miller95def091999-11-25 00:26:21 +1100475 if (verbose_mode)
476 fprintf(stderr, "Executing: %s\n", bp);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000477 if (system(bp))
478 ++errs;
Damien Miller95def091999-11-25 00:26:21 +1100479 (void) xfree(bp);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000480 continue;
481 }
482 *src++ = 0;
483 if (*src == 0)
484 src = ".";
485 if ((host = strchr(argv[i], '@')) == NULL) {
486 host = argv[i];
487 suser = NULL;
488 } else {
489 *host++ = 0;
490 suser = argv[i];
491 if (*suser == '\0')
492 suser = pwd->pw_name;
493 else if (!okname(suser))
494 continue;
495 }
Damien Miller34132e52000-01-14 15:45:46 +1100496 host = cleanhostname(host);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000497 len = strlen(src) + CMDNEEDS + 20;
Damien Miller95def091999-11-25 00:26:21 +1100498 bp = xmalloc(len);
499 (void) sprintf(bp, "%s -f %s", cmd, src);
Damien Millerad833b32000-08-23 10:46:23 +1000500 if (do_cmd(host, suser, bp, &remin, &remout, argc) < 0) {
Damien Miller95def091999-11-25 00:26:21 +1100501 (void) xfree(bp);
502 ++errs;
503 continue;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000504 }
Damien Miller95def091999-11-25 00:26:21 +1100505 xfree(bp);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000506 sink(1, argv + argc - 1);
Damien Miller95def091999-11-25 00:26:21 +1100507 (void) close(remin);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000508 remin = remout = -1;
509 }
510}
511
512void
513source(argc, argv)
514 int argc;
515 char *argv[];
516{
517 struct stat stb;
518 static BUF buffer;
519 BUF *bp;
520 off_t i;
521 int amt, fd, haderr, indx, result;
522 char *last, *name, buf[2048];
523
524 for (indx = 0; indx < argc; ++indx) {
Damien Miller95def091999-11-25 00:26:21 +1100525 name = argv[indx];
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000526 statbytes = 0;
527 if ((fd = open(name, O_RDONLY, 0)) < 0)
528 goto syserr;
529 if (fstat(fd, &stb) < 0) {
530syserr: run_err("%s: %s", name, strerror(errno));
531 goto next;
532 }
533 switch (stb.st_mode & S_IFMT) {
534 case S_IFREG:
535 break;
536 case S_IFDIR:
537 if (iamrecursive) {
538 rsource(name, &stb);
539 goto next;
540 }
541 /* FALLTHROUGH */
542 default:
543 run_err("%s: not a regular file", name);
544 goto next;
545 }
546 if ((last = strrchr(name, '/')) == NULL)
547 last = name;
548 else
549 ++last;
550 curfile = last;
551 if (pflag) {
552 /*
553 * Make it compatible with possible future
554 * versions expecting microseconds.
555 */
Damien Miller95def091999-11-25 00:26:21 +1100556 (void) sprintf(buf, "T%lu 0 %lu 0\n",
Damien Millerad833b32000-08-23 10:46:23 +1000557 (unsigned long) stb.st_mtime,
558 (unsigned long) stb.st_atime);
Damien Miller35dabd02000-05-01 21:10:33 +1000559 (void) atomicio(write, remout, buf, strlen(buf));
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000560 if (response() < 0)
561 goto next;
562 }
563#define FILEMODEMASK (S_ISUID|S_ISGID|S_IRWXU|S_IRWXG|S_IRWXO)
Damien Miller95def091999-11-25 00:26:21 +1100564 (void) sprintf(buf, "C%04o %lu %s\n",
565 (unsigned int) (stb.st_mode & FILEMODEMASK),
566 (unsigned long) stb.st_size,
567 last);
568 if (verbose_mode) {
569 fprintf(stderr, "Sending file modes: %s", buf);
570 fflush(stderr);
571 }
Damien Miller35dabd02000-05-01 21:10:33 +1000572 (void) atomicio(write, remout, buf, strlen(buf));
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000573 if (response() < 0)
574 goto next;
575 if ((bp = allocbuf(&buffer, fd, 2048)) == NULL) {
Damien Miller95def091999-11-25 00:26:21 +1100576next: (void) close(fd);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000577 continue;
578 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000579 if (showprogress) {
580 totalbytes = stb.st_size;
581 progressmeter(-1);
582 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000583 /* Keep writing after an error so that we stay sync'd up. */
584 for (haderr = i = 0; i < stb.st_size; i += bp->cnt) {
585 amt = bp->cnt;
586 if (i + amt > stb.st_size)
587 amt = stb.st_size - i;
588 if (!haderr) {
Damien Millere247cc42000-05-07 12:03:14 +1000589 result = atomicio(read, fd, bp->buf, amt);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000590 if (result != amt)
591 haderr = result >= 0 ? EIO : errno;
592 }
593 if (haderr)
Damien Miller35dabd02000-05-01 21:10:33 +1000594 (void) atomicio(write, remout, bp->buf, amt);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000595 else {
Damien Miller864ea591999-12-15 11:04:25 +1100596 result = atomicio(write, remout, bp->buf, amt);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000597 if (result != amt)
598 haderr = result >= 0 ? EIO : errno;
599 statbytes += result;
600 }
601 }
Damien Miller95def091999-11-25 00:26:21 +1100602 if (showprogress)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000603 progressmeter(1);
604
605 if (close(fd) < 0 && !haderr)
606 haderr = errno;
607 if (!haderr)
Damien Miller35dabd02000-05-01 21:10:33 +1000608 (void) atomicio(write, remout, "", 1);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000609 else
610 run_err("%s: %s", name, strerror(haderr));
Damien Miller95def091999-11-25 00:26:21 +1100611 (void) response();
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000612 }
613}
614
615void
616rsource(name, statp)
617 char *name;
618 struct stat *statp;
619{
620 DIR *dirp;
621 struct dirent *dp;
622 char *last, *vect[1], path[1100];
623
624 if (!(dirp = opendir(name))) {
625 run_err("%s: %s", name, strerror(errno));
626 return;
627 }
628 last = strrchr(name, '/');
629 if (last == 0)
630 last = name;
631 else
632 last++;
633 if (pflag) {
Damien Miller95def091999-11-25 00:26:21 +1100634 (void) sprintf(path, "T%lu 0 %lu 0\n",
Damien Millerad833b32000-08-23 10:46:23 +1000635 (unsigned long) statp->st_mtime,
636 (unsigned long) statp->st_atime);
Damien Miller35dabd02000-05-01 21:10:33 +1000637 (void) atomicio(write, remout, path, strlen(path));
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000638 if (response() < 0) {
639 closedir(dirp);
640 return;
641 }
642 }
Damien Miller95def091999-11-25 00:26:21 +1100643 (void) sprintf(path, "D%04o %d %.1024s\n",
Damien Millerad833b32000-08-23 10:46:23 +1000644 (unsigned int) (statp->st_mode & FILEMODEMASK), 0, last);
Damien Miller95def091999-11-25 00:26:21 +1100645 if (verbose_mode)
646 fprintf(stderr, "Entering directory: %s", path);
Damien Miller35dabd02000-05-01 21:10:33 +1000647 (void) atomicio(write, remout, path, strlen(path));
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000648 if (response() < 0) {
649 closedir(dirp);
650 return;
651 }
652 while ((dp = readdir(dirp))) {
653 if (dp->d_ino == 0)
654 continue;
655 if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
656 continue;
657 if (strlen(name) + 1 + strlen(dp->d_name) >= sizeof(path) - 1) {
658 run_err("%s/%s: name too long", name, dp->d_name);
659 continue;
660 }
Damien Miller95def091999-11-25 00:26:21 +1100661 (void) sprintf(path, "%s/%s", name, dp->d_name);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000662 vect[0] = path;
663 source(1, vect);
664 }
Damien Miller95def091999-11-25 00:26:21 +1100665 (void) closedir(dirp);
Damien Miller35dabd02000-05-01 21:10:33 +1000666 (void) atomicio(write, remout, "E\n", 2);
Damien Miller95def091999-11-25 00:26:21 +1100667 (void) response();
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000668}
669
670void
671sink(argc, argv)
672 int argc;
673 char *argv[];
674{
675 static BUF buffer;
676 struct stat stb;
Damien Miller95def091999-11-25 00:26:21 +1100677 enum {
678 YES, NO, DISPLAYED
679 } wrerr;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000680 BUF *bp;
681 off_t i, j;
682 int amt, count, exists, first, mask, mode, ofd, omode;
Damien Millercaf6dd62000-08-29 11:33:50 +1100683 off_t size;
684 int setimes, targisdir, wrerrno = 0;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000685 char ch, *cp, *np, *targ, *why, *vect[1], buf[2048];
Damien Miller95def091999-11-25 00:26:21 +1100686 struct utimbuf ut;
687 int dummy_usec;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000688
689#define SCREWUP(str) { why = str; goto screwup; }
690
691 setimes = targisdir = 0;
692 mask = umask(0);
693 if (!pflag)
Damien Miller95def091999-11-25 00:26:21 +1100694 (void) umask(mask);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000695 if (argc != 1) {
696 run_err("ambiguous target");
697 exit(1);
698 }
699 targ = *argv;
700 if (targetshouldbedirectory)
701 verifydir(targ);
Damien Miller95def091999-11-25 00:26:21 +1100702
Damien Miller35dabd02000-05-01 21:10:33 +1000703 (void) atomicio(write, remout, "", 1);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000704 if (stat(targ, &stb) == 0 && S_ISDIR(stb.st_mode))
705 targisdir = 1;
706 for (first = 1;; first = 0) {
707 cp = buf;
Damien Millere247cc42000-05-07 12:03:14 +1000708 if (atomicio(read, remin, cp, 1) <= 0)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000709 return;
710 if (*cp++ == '\n')
711 SCREWUP("unexpected <newline>");
712 do {
Damien Millere247cc42000-05-07 12:03:14 +1000713 if (atomicio(read, remin, &ch, sizeof(ch)) != sizeof(ch))
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000714 SCREWUP("lost connection");
715 *cp++ = ch;
716 } while (cp < &buf[sizeof(buf) - 1] && ch != '\n');
717 *cp = 0;
718
719 if (buf[0] == '\01' || buf[0] == '\02') {
720 if (iamremote == 0)
Damien Miller35dabd02000-05-01 21:10:33 +1000721 (void) atomicio(write, STDERR_FILENO,
Damien Miller95def091999-11-25 00:26:21 +1100722 buf + 1, strlen(buf + 1));
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000723 if (buf[0] == '\02')
724 exit(1);
725 ++errs;
726 continue;
727 }
728 if (buf[0] == 'E') {
Damien Miller35dabd02000-05-01 21:10:33 +1000729 (void) atomicio(write, remout, "", 1);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000730 return;
731 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000732 if (ch == '\n')
733 *--cp = 0;
734
735#define getnum(t) (t) = 0; \
736 while (*cp >= '0' && *cp <= '9') (t) = (t) * 10 + (*cp++ - '0');
737 cp = buf;
738 if (*cp == 'T') {
739 setimes++;
740 cp++;
741 getnum(ut.modtime);
742 if (*cp++ != ' ')
743 SCREWUP("mtime.sec not delimited");
744 getnum(dummy_usec);
745 if (*cp++ != ' ')
746 SCREWUP("mtime.usec not delimited");
747 getnum(ut.actime);
748 if (*cp++ != ' ')
749 SCREWUP("atime.sec not delimited");
750 getnum(dummy_usec);
751 if (*cp++ != '\0')
752 SCREWUP("atime.usec not delimited");
Damien Miller35dabd02000-05-01 21:10:33 +1000753 (void) atomicio(write, remout, "", 1);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000754 continue;
755 }
756 if (*cp != 'C' && *cp != 'D') {
757 /*
758 * Check for the case "rcp remote:foo\* local:bar".
759 * In this case, the line "No match." can be returned
760 * by the shell before the rcp command on the remote is
761 * executed so the ^Aerror_message convention isn't
762 * followed.
763 */
764 if (first) {
765 run_err("%s", cp);
766 exit(1);
767 }
768 SCREWUP("expected control record");
769 }
770 mode = 0;
771 for (++cp; cp < buf + 5; cp++) {
772 if (*cp < '0' || *cp > '7')
773 SCREWUP("bad mode");
774 mode = (mode << 3) | (*cp - '0');
775 }
776 if (*cp++ != ' ')
777 SCREWUP("mode not delimited");
778
Damien Miller95def091999-11-25 00:26:21 +1100779 for (size = 0; *cp >= '0' && *cp <= '9';)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000780 size = size * 10 + (*cp++ - '0');
781 if (*cp++ != ' ')
782 SCREWUP("size not delimited");
783 if (targisdir) {
784 static char *namebuf;
785 static int cursize;
786 size_t need;
787
788 need = strlen(targ) + strlen(cp) + 250;
789 if (need > cursize)
Damien Miller95def091999-11-25 00:26:21 +1100790 namebuf = xmalloc(need);
791 (void) sprintf(namebuf, "%s%s%s", targ,
Damien Millerad833b32000-08-23 10:46:23 +1000792 *targ ? "/" : "", cp);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000793 np = namebuf;
794 } else
795 np = targ;
796 curfile = cp;
797 exists = stat(np, &stb) == 0;
798 if (buf[0] == 'D') {
799 int mod_flag = pflag;
800 if (exists) {
801 if (!S_ISDIR(stb.st_mode)) {
802 errno = ENOTDIR;
803 goto bad;
804 }
805 if (pflag)
Damien Miller95def091999-11-25 00:26:21 +1100806 (void) chmod(np, mode);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000807 } else {
Damien Miller95def091999-11-25 00:26:21 +1100808 /* Handle copying from a read-only
809 directory */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000810 mod_flag = 1;
811 if (mkdir(np, mode | S_IRWXU) < 0)
812 goto bad;
813 }
814 vect[0] = np;
815 sink(1, vect);
816 if (setimes) {
817 setimes = 0;
818 if (utime(np, &ut) < 0)
Damien Miller95def091999-11-25 00:26:21 +1100819 run_err("%s: set times: %s",
820 np, strerror(errno));
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000821 }
822 if (mod_flag)
Damien Miller95def091999-11-25 00:26:21 +1100823 (void) chmod(np, mode);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000824 continue;
825 }
826 omode = mode;
827 mode |= S_IWRITE;
Damien Miller95def091999-11-25 00:26:21 +1100828 if ((ofd = open(np, O_WRONLY | O_CREAT | O_TRUNC, mode)) < 0) {
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000829bad: run_err("%s: %s", np, strerror(errno));
830 continue;
831 }
Damien Miller35dabd02000-05-01 21:10:33 +1000832 (void) atomicio(write, remout, "", 1);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000833 if ((bp = allocbuf(&buffer, ofd, 4096)) == NULL) {
Damien Miller95def091999-11-25 00:26:21 +1100834 (void) close(ofd);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000835 continue;
836 }
837 cp = bp->buf;
838 wrerr = NO;
839
840 if (showprogress) {
841 totalbytes = size;
842 progressmeter(-1);
843 }
844 statbytes = 0;
845 for (count = i = 0; i < size; i += 4096) {
846 amt = 4096;
847 if (i + amt > size)
848 amt = size - i;
849 count += amt;
850 do {
Damien Millere247cc42000-05-07 12:03:14 +1000851 j = atomicio(read, remin, cp, amt);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000852 if (j <= 0) {
853 run_err("%s", j ? strerror(errno) :
Damien Miller95def091999-11-25 00:26:21 +1100854 "dropped connection");
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000855 exit(1);
856 }
857 amt -= j;
858 cp += j;
Damien Miller95def091999-11-25 00:26:21 +1100859 statbytes += j;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000860 } while (amt > 0);
861 if (count == bp->cnt) {
862 /* Keep reading so we stay sync'd up. */
863 if (wrerr == NO) {
Damien Millere247cc42000-05-07 12:03:14 +1000864 j = atomicio(write, ofd, bp->buf, count);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000865 if (j != count) {
866 wrerr = YES;
Damien Miller95def091999-11-25 00:26:21 +1100867 wrerrno = j >= 0 ? EIO : errno;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000868 }
869 }
870 count = 0;
871 cp = bp->buf;
872 }
873 }
874 if (showprogress)
875 progressmeter(1);
876 if (count != 0 && wrerr == NO &&
Damien Millere247cc42000-05-07 12:03:14 +1000877 (j = atomicio(write, ofd, bp->buf, count)) != count) {
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000878 wrerr = YES;
Damien Miller95def091999-11-25 00:26:21 +1100879 wrerrno = j >= 0 ? EIO : errno;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000880 }
881#if 0
882 if (ftruncate(ofd, size)) {
883 run_err("%s: truncate: %s", np, strerror(errno));
884 wrerr = DISPLAYED;
885 }
886#endif
887 if (pflag) {
888 if (exists || omode != mode)
889 if (fchmod(ofd, omode))
890 run_err("%s: set mode: %s",
Damien Miller95def091999-11-25 00:26:21 +1100891 np, strerror(errno));
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000892 } else {
893 if (!exists && omode != mode)
894 if (fchmod(ofd, omode & ~mask))
895 run_err("%s: set mode: %s",
Damien Miller95def091999-11-25 00:26:21 +1100896 np, strerror(errno));
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000897 }
Damien Millerbe484b52000-07-15 14:14:16 +1000898 if (close(ofd) == -1) {
899 wrerr = YES;
900 wrerrno = errno;
901 }
Damien Miller95def091999-11-25 00:26:21 +1100902 (void) response();
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000903 if (setimes && wrerr == NO) {
904 setimes = 0;
905 if (utime(np, &ut) < 0) {
906 run_err("%s: set times: %s",
Damien Miller95def091999-11-25 00:26:21 +1100907 np, strerror(errno));
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000908 wrerr = DISPLAYED;
909 }
910 }
Damien Miller95def091999-11-25 00:26:21 +1100911 switch (wrerr) {
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000912 case YES:
913 run_err("%s: %s", np, strerror(wrerrno));
914 break;
915 case NO:
Damien Miller35dabd02000-05-01 21:10:33 +1000916 (void) atomicio(write, remout, "", 1);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000917 break;
918 case DISPLAYED:
919 break;
920 }
921 }
922screwup:
923 run_err("protocol error: %s", why);
924 exit(1);
925}
926
927int
928response()
929{
930 char ch, *cp, resp, rbuf[2048];
931
Damien Millere247cc42000-05-07 12:03:14 +1000932 if (atomicio(read, remin, &resp, sizeof(resp)) != sizeof(resp))
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000933 lostconn(0);
934
935 cp = rbuf;
Damien Miller95def091999-11-25 00:26:21 +1100936 switch (resp) {
937 case 0: /* ok */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000938 return (0);
939 default:
940 *cp++ = resp;
941 /* FALLTHROUGH */
Damien Miller95def091999-11-25 00:26:21 +1100942 case 1: /* error, followed by error msg */
943 case 2: /* fatal error, "" */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000944 do {
Damien Millere247cc42000-05-07 12:03:14 +1000945 if (atomicio(read, remin, &ch, sizeof(ch)) != sizeof(ch))
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000946 lostconn(0);
947 *cp++ = ch;
948 } while (cp < &rbuf[sizeof(rbuf) - 1] && ch != '\n');
949
950 if (!iamremote)
Damien Miller35dabd02000-05-01 21:10:33 +1000951 (void) atomicio(write, STDERR_FILENO, rbuf, cp - rbuf);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000952 ++errs;
953 if (resp == 1)
954 return (-1);
955 exit(1);
956 }
957 /* NOTREACHED */
958}
959
960void
961usage()
962{
Damien Millerad833b32000-08-23 10:46:23 +1000963 (void) fprintf(stderr, "usage: scp "
964 "[-pqrvC46] [-S ssh] [-P port] [-c cipher] [-i identity] f1 f2; or:\n"
965 " scp [options] f1 ... fn directory\n");
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000966 exit(1);
967}
968
969void
Damien Miller95def091999-11-25 00:26:21 +1100970run_err(const char *fmt,...)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000971{
972 static FILE *fp;
973 va_list ap;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000974
975 ++errs;
976 if (fp == NULL && !(fp = fdopen(remout, "w")))
977 return;
Damien Miller95def091999-11-25 00:26:21 +1100978 (void) fprintf(fp, "%c", 0x01);
979 (void) fprintf(fp, "scp: ");
Damien Miller03783f01999-12-31 09:16:40 +1100980 va_start(ap, fmt);
Damien Miller95def091999-11-25 00:26:21 +1100981 (void) vfprintf(fp, fmt, ap);
Damien Miller03783f01999-12-31 09:16:40 +1100982 va_end(ap);
Damien Miller95def091999-11-25 00:26:21 +1100983 (void) fprintf(fp, "\n");
984 (void) fflush(fp);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000985
Damien Miller95def091999-11-25 00:26:21 +1100986 if (!iamremote) {
Damien Miller03783f01999-12-31 09:16:40 +1100987 va_start(ap, fmt);
Damien Miller95def091999-11-25 00:26:21 +1100988 vfprintf(stderr, fmt, ap);
Damien Miller03783f01999-12-31 09:16:40 +1100989 va_end(ap);
Damien Miller95def091999-11-25 00:26:21 +1100990 fprintf(stderr, "\n");
991 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000992}
993
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000994char *
995colon(cp)
996 char *cp;
997{
Damien Miller34132e52000-01-14 15:45:46 +1100998 int flag = 0;
999
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001000 if (*cp == ':') /* Leading colon is part of file name. */
1001 return (0);
Damien Miller34132e52000-01-14 15:45:46 +11001002 if (*cp == '[')
1003 flag = 1;
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001004
1005 for (; *cp; ++cp) {
Damien Miller34132e52000-01-14 15:45:46 +11001006 if (*cp == '@' && *(cp+1) == '[')
1007 flag = 1;
1008 if (*cp == ']' && *(cp+1) == ':' && flag)
1009 return (cp+1);
1010 if (*cp == ':' && !flag)
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001011 return (cp);
1012 if (*cp == '/')
1013 return (0);
1014 }
1015 return (0);
1016}
1017
1018void
1019verifydir(cp)
1020 char *cp;
1021{
1022 struct stat stb;
1023
1024 if (!stat(cp, &stb)) {
1025 if (S_ISDIR(stb.st_mode))
1026 return;
1027 errno = ENOTDIR;
1028 }
1029 run_err("%s: %s", cp, strerror(errno));
1030 exit(1);
1031}
1032
1033int
1034okname(cp0)
1035 char *cp0;
1036{
1037 int c;
1038 char *cp;
1039
1040 cp = cp0;
1041 do {
1042 c = *cp;
1043 if (c & 0200)
1044 goto bad;
1045 if (!isalpha(c) && !isdigit(c) && c != '_' && c != '-')
1046 goto bad;
1047 } while (*++cp);
1048 return (1);
1049
Damien Miller98c7ad62000-03-09 21:27:49 +11001050bad: fprintf(stderr, "%s: invalid user name\n", cp0);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001051 return (0);
1052}
1053
1054BUF *
1055allocbuf(bp, fd, blksize)
1056 BUF *bp;
1057 int fd, blksize;
1058{
1059 size_t size;
1060 struct stat stb;
1061
1062 if (fstat(fd, &stb) < 0) {
1063 run_err("fstat: %s", strerror(errno));
1064 return (0);
1065 }
Damien Miller95def091999-11-25 00:26:21 +11001066 if (stb.st_blksize == 0)
1067 size = blksize;
1068 else
1069 size = blksize + (stb.st_blksize - blksize % stb.st_blksize) %
Damien Millerad833b32000-08-23 10:46:23 +10001070 stb.st_blksize;
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001071 if (bp->cnt >= size)
1072 return (bp);
Damien Miller95def091999-11-25 00:26:21 +11001073 if (bp->buf == NULL)
1074 bp->buf = xmalloc(size);
1075 else
1076 bp->buf = xrealloc(bp->buf, size);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001077 bp->cnt = size;
1078 return (bp);
1079}
1080
1081void
1082lostconn(signo)
1083 int signo;
1084{
1085 if (!iamremote)
1086 fprintf(stderr, "lost connection\n");
1087 exit(1);
1088}
1089
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001090
1091void
1092alarmtimer(int wait)
1093{
Damien Miller95def091999-11-25 00:26:21 +11001094 struct itimerval itv;
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001095
Damien Miller95def091999-11-25 00:26:21 +11001096 itv.it_value.tv_sec = wait;
1097 itv.it_value.tv_usec = 0;
1098 itv.it_interval = itv.it_value;
1099 setitimer(ITIMER_REAL, &itv, NULL);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001100}
1101
1102void
Damien Miller7684ee12000-03-17 23:40:15 +11001103updateprogressmeter(int ignore)
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001104{
1105 int save_errno = errno;
1106
1107 progressmeter(0);
1108 errno = save_errno;
1109}
1110
Damien Miller81428f91999-11-18 09:28:11 +11001111int
1112foregroundproc()
1113{
1114 static pid_t pgrp = -1;
1115 int ctty_pgrp;
1116
1117 if (pgrp == -1)
1118 pgrp = getpgrp();
1119
Damien Miller95def091999-11-25 00:26:21 +11001120 return ((ioctl(STDOUT_FILENO, TIOCGPGRP, &ctty_pgrp) != -1 &&
1121 ctty_pgrp == pgrp));
Damien Miller81428f91999-11-18 09:28:11 +11001122}
1123
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001124void
1125progressmeter(int flag)
1126{
1127 static const char prefixes[] = " KMGTP";
1128 static struct timeval lastupdate;
1129 static off_t lastsize;
1130 struct timeval now, td, wait;
1131 off_t cursize, abbrevsize;
1132 double elapsed;
Damien Miller7c64ba31999-11-11 21:39:50 +11001133 int ratio, barlength, i, remaining;
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001134 char buf[256];
1135
1136 if (flag == -1) {
Damien Miller95def091999-11-25 00:26:21 +11001137 (void) gettimeofday(&start, (struct timezone *) 0);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001138 lastupdate = start;
1139 lastsize = 0;
Damien Miller95def091999-11-25 00:26:21 +11001140 }
Damien Miller81428f91999-11-18 09:28:11 +11001141 if (foregroundproc() == 0)
1142 return;
1143
Damien Miller95def091999-11-25 00:26:21 +11001144 (void) gettimeofday(&now, (struct timezone *) 0);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001145 cursize = statbytes;
Damien Millera2d6efe1999-11-13 13:22:46 +11001146 if (totalbytes != 0) {
Damien Miller5428f641999-11-25 11:54:57 +11001147 ratio = 100.0 * cursize / totalbytes;
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001148 ratio = MAX(ratio, 0);
1149 ratio = MIN(ratio, 100);
Damien Miller95def091999-11-25 00:26:21 +11001150 } else
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001151 ratio = 100;
1152
Damien Miller95def091999-11-25 00:26:21 +11001153 snprintf(buf, sizeof(buf), "\r%-20.20s %3d%% ", curfile, ratio);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001154
1155 barlength = getttywidth() - 51;
Damien Miller484118e2000-07-02 19:13:56 +10001156 barlength = (barlength <= MAX_BARLENGTH)?barlength:MAX_BARLENGTH;
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001157 if (barlength > 0) {
1158 i = barlength * ratio / 100;
1159 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
Damien Miller484118e2000-07-02 19:13:56 +10001160 "|%.*s%*s|", i, BAR, barlength - i, "");
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001161 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001162 i = 0;
1163 abbrevsize = cursize;
1164 while (abbrevsize >= 100000 && i < sizeof(prefixes)) {
1165 i++;
1166 abbrevsize >>= 10;
1167 }
Damien Miller864ea591999-12-15 11:04:25 +11001168 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " %5d %c%c ",
1169 (int) abbrevsize, prefixes[i], prefixes[i] == ' ' ? ' ' :
Damien Miller95def091999-11-25 00:26:21 +11001170 'B');
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001171
1172 timersub(&now, &lastupdate, &wait);
1173 if (cursize > lastsize) {
1174 lastupdate = now;
1175 lastsize = cursize;
1176 if (wait.tv_sec >= STALLTIME) {
1177 start.tv_sec += wait.tv_sec;
1178 start.tv_usec += wait.tv_usec;
1179 }
1180 wait.tv_sec = 0;
1181 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001182 timersub(&now, &start, &td);
1183 elapsed = td.tv_sec + (td.tv_usec / 1000000.0);
1184
1185 if (statbytes <= 0 || elapsed <= 0.0 || cursize > totalbytes) {
1186 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
Damien Miller95def091999-11-25 00:26:21 +11001187 " --:-- ETA");
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001188 } else if (wait.tv_sec >= STALLTIME) {
1189 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
Damien Miller95def091999-11-25 00:26:21 +11001190 " - stalled -");
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001191 } else {
Damien Miller8bb73be2000-04-19 16:26:12 +10001192 if (flag != 1)
1193 remaining =
1194 (int)(totalbytes / (statbytes / elapsed) - elapsed);
1195 else
1196 remaining = elapsed;
1197
Damien Miller01ab4a21999-10-28 15:23:30 +10001198 i = remaining / 3600;
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001199 if (i)
1200 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
Damien Millerad833b32000-08-23 10:46:23 +10001201 "%2d:", i);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001202 else
1203 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
Damien Millerad833b32000-08-23 10:46:23 +10001204 " ");
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001205 i = remaining % 3600;
1206 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
Damien Millerad833b32000-08-23 10:46:23 +10001207 "%02d:%02d%s", i / 60, i % 60,
1208 (flag != 1) ? " ETA" : " ");
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001209 }
1210 atomicio(write, fileno(stdout), buf, strlen(buf));
1211
1212 if (flag == -1) {
Damien Miller864ea591999-12-15 11:04:25 +11001213 struct sigaction sa;
1214 sa.sa_handler = updateprogressmeter;
1215 sigemptyset(&sa.sa_mask);
Damien Miller615f9392000-05-17 22:53:33 +10001216#ifdef SA_RESTART
Damien Miller864ea591999-12-15 11:04:25 +11001217 sa.sa_flags = SA_RESTART;
Damien Miller615f9392000-05-17 22:53:33 +10001218#endif
Damien Miller864ea591999-12-15 11:04:25 +11001219 sigaction(SIGALRM, &sa, NULL);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001220 alarmtimer(1);
1221 } else if (flag == 1) {
1222 alarmtimer(0);
Damien Miller35dabd02000-05-01 21:10:33 +10001223 atomicio(write, fileno(stdout), "\n", 1);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001224 statbytes = 0;
1225 }
1226}
1227
1228int
1229getttywidth(void)
1230{
1231 struct winsize winsize;
1232
1233 if (ioctl(fileno(stdout), TIOCGWINSZ, &winsize) != -1)
Damien Miller95def091999-11-25 00:26:21 +11001234 return (winsize.ws_col ? winsize.ws_col : 80);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001235 else
Damien Miller95def091999-11-25 00:26:21 +11001236 return (80);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001237}