]> CyberLeo.Net >> Repos - FreeBSD/releng/10.0.git/blob - crypto/openssh/scp.c
- Copy stable/10 (r259064) to releng/10.0 as part of the
[FreeBSD/releng/10.0.git] / crypto / openssh / scp.c
1 /* $OpenBSD: scp.c,v 1.178 2013/06/22 06:31:57 djm Exp $ */
2 /*
3  * scp - secure remote copy.  This is basically patched BSD rcp which
4  * uses ssh to do the data transfer (instead of using rcmd).
5  *
6  * NOTE: This version should NOT be suid root.  (This uses ssh to
7  * do the transfer and ssh has the necessary privileges.)
8  *
9  * 1995 Timo Rinne <tri@iki.fi>, Tatu Ylonen <ylo@cs.hut.fi>
10  *
11  * As far as I am concerned, the code I have written for this software
12  * can be used freely for any purpose.  Any derived versions of this
13  * software must be clearly marked as such, and if the derived work is
14  * incompatible with the protocol description in the RFC file, it must be
15  * called by a name other than "ssh" or "Secure Shell".
16  */
17 /*
18  * Copyright (c) 1999 Theo de Raadt.  All rights reserved.
19  * Copyright (c) 1999 Aaron Campbell.  All rights reserved.
20  *
21  * Redistribution and use in source and binary forms, with or without
22  * modification, are permitted provided that the following conditions
23  * are met:
24  * 1. Redistributions of source code must retain the above copyright
25  *    notice, this list of conditions and the following disclaimer.
26  * 2. Redistributions in binary form must reproduce the above copyright
27  *    notice, this list of conditions and the following disclaimer in the
28  *    documentation and/or other materials provided with the distribution.
29  *
30  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
31  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
32  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
33  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
34  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
35  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
36  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
37  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
38  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
39  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
40  */
41
42 /*
43  * Parts from:
44  *
45  * Copyright (c) 1983, 1990, 1992, 1993, 1995
46  *      The Regents of the University of California.  All rights reserved.
47  *
48  * Redistribution and use in source and binary forms, with or without
49  * modification, are permitted provided that the following conditions
50  * are met:
51  * 1. Redistributions of source code must retain the above copyright
52  *    notice, this list of conditions and the following disclaimer.
53  * 2. Redistributions in binary form must reproduce the above copyright
54  *    notice, this list of conditions and the following disclaimer in the
55  *    documentation and/or other materials provided with the distribution.
56  * 3. Neither the name of the University nor the names of its contributors
57  *    may be used to endorse or promote products derived from this software
58  *    without specific prior written permission.
59  *
60  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
61  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
62  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
63  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
64  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
65  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
66  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
67  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
68  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
69  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
70  * SUCH DAMAGE.
71  *
72  */
73
74 #include "includes.h"
75
76 #include <sys/types.h>
77 #include <sys/param.h>
78 #ifdef HAVE_SYS_STAT_H
79 # include <sys/stat.h>
80 #endif
81 #ifdef HAVE_POLL_H
82 #include <poll.h>
83 #else
84 # ifdef HAVE_SYS_POLL_H
85 #  include <sys/poll.h>
86 # endif
87 #endif
88 #ifdef HAVE_SYS_TIME_H
89 # include <sys/time.h>
90 #endif
91 #include <sys/wait.h>
92 #include <sys/uio.h>
93
94 #include <ctype.h>
95 #include <dirent.h>
96 #include <errno.h>
97 #include <fcntl.h>
98 #include <pwd.h>
99 #include <signal.h>
100 #include <stdarg.h>
101 #include <stdio.h>
102 #include <stdlib.h>
103 #include <string.h>
104 #include <time.h>
105 #include <unistd.h>
106 #if defined(HAVE_STRNVIS) && defined(HAVE_VIS_H) && !defined(BROKEN_STRNVIS)
107 #include <vis.h>
108 #endif
109
110 #include "xmalloc.h"
111 #include "atomicio.h"
112 #include "pathnames.h"
113 #include "log.h"
114 #include "misc.h"
115 #include "progressmeter.h"
116
117 extern char *__progname;
118
119 #define COPY_BUFLEN     16384
120
121 int do_cmd(char *host, char *remuser, char *cmd, int *fdin, int *fdout);
122 int do_cmd2(char *host, char *remuser, char *cmd, int fdin, int fdout);
123
124 /* Struct for addargs */
125 arglist args;
126 arglist remote_remote_args;
127
128 /* Bandwidth limit */
129 long long limit_kbps = 0;
130 struct bwlimit bwlimit;
131
132 /* Name of current file being transferred. */
133 char *curfile;
134
135 /* This is set to non-zero to enable verbose mode. */
136 int verbose_mode = 0;
137
138 /* This is set to zero if the progressmeter is not desired. */
139 int showprogress = 1;
140
141 /*
142  * This is set to non-zero if remote-remote copy should be piped
143  * through this process.
144  */
145 int throughlocal = 0;
146
147 /* This is the program to execute for the secured connection. ("ssh" or -S) */
148 char *ssh_program = _PATH_SSH_PROGRAM;
149
150 /* This is used to store the pid of ssh_program */
151 pid_t do_cmd_pid = -1;
152
153 static void
154 killchild(int signo)
155 {
156         if (do_cmd_pid > 1) {
157                 kill(do_cmd_pid, signo ? signo : SIGTERM);
158                 waitpid(do_cmd_pid, NULL, 0);
159         }
160
161         if (signo)
162                 _exit(1);
163         exit(1);
164 }
165
166 static void
167 suspchild(int signo)
168 {
169         int status;
170
171         if (do_cmd_pid > 1) {
172                 kill(do_cmd_pid, signo);
173                 while (waitpid(do_cmd_pid, &status, WUNTRACED) == -1 &&
174                     errno == EINTR)
175                         ;
176                 kill(getpid(), SIGSTOP);
177         }
178 }
179
180 static int
181 do_local_cmd(arglist *a)
182 {
183         u_int i;
184         int status;
185         pid_t pid;
186
187         if (a->num == 0)
188                 fatal("do_local_cmd: no arguments");
189
190         if (verbose_mode) {
191                 fprintf(stderr, "Executing:");
192                 for (i = 0; i < a->num; i++)
193                         fprintf(stderr, " %s", a->list[i]);
194                 fprintf(stderr, "\n");
195         }
196         if ((pid = fork()) == -1)
197                 fatal("do_local_cmd: fork: %s", strerror(errno));
198
199         if (pid == 0) {
200                 execvp(a->list[0], a->list);
201                 perror(a->list[0]);
202                 exit(1);
203         }
204
205         do_cmd_pid = pid;
206         signal(SIGTERM, killchild);
207         signal(SIGINT, killchild);
208         signal(SIGHUP, killchild);
209
210         while (waitpid(pid, &status, 0) == -1)
211                 if (errno != EINTR)
212                         fatal("do_local_cmd: waitpid: %s", strerror(errno));
213
214         do_cmd_pid = -1;
215
216         if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
217                 return (-1);
218
219         return (0);
220 }
221
222 /*
223  * This function executes the given command as the specified user on the
224  * given host.  This returns < 0 if execution fails, and >= 0 otherwise. This
225  * assigns the input and output file descriptors on success.
226  */
227
228 int
229 do_cmd(char *host, char *remuser, char *cmd, int *fdin, int *fdout)
230 {
231         int pin[2], pout[2], reserved[2];
232
233         if (verbose_mode)
234                 fprintf(stderr,
235                     "Executing: program %s host %s, user %s, command %s\n",
236                     ssh_program, host,
237                     remuser ? remuser : "(unspecified)", cmd);
238
239         /*
240          * Reserve two descriptors so that the real pipes won't get
241          * descriptors 0 and 1 because that will screw up dup2 below.
242          */
243         if (pipe(reserved) < 0)
244                 fatal("pipe: %s", strerror(errno));
245
246         /* Create a socket pair for communicating with ssh. */
247         if (pipe(pin) < 0)
248                 fatal("pipe: %s", strerror(errno));
249         if (pipe(pout) < 0)
250                 fatal("pipe: %s", strerror(errno));
251
252         /* Free the reserved descriptors. */
253         close(reserved[0]);
254         close(reserved[1]);
255
256         signal(SIGTSTP, suspchild);
257         signal(SIGTTIN, suspchild);
258         signal(SIGTTOU, suspchild);
259
260         /* Fork a child to execute the command on the remote host using ssh. */
261         do_cmd_pid = fork();
262         if (do_cmd_pid == 0) {
263                 /* Child. */
264                 close(pin[1]);
265                 close(pout[0]);
266                 dup2(pin[0], 0);
267                 dup2(pout[1], 1);
268                 close(pin[0]);
269                 close(pout[1]);
270
271                 replacearg(&args, 0, "%s", ssh_program);
272                 if (remuser != NULL) {
273                         addargs(&args, "-l");
274                         addargs(&args, "%s", remuser);
275                 }
276                 addargs(&args, "--");
277                 addargs(&args, "%s", host);
278                 addargs(&args, "%s", cmd);
279
280                 execvp(ssh_program, args.list);
281                 perror(ssh_program);
282                 exit(1);
283         } else if (do_cmd_pid == -1) {
284                 fatal("fork: %s", strerror(errno));
285         }
286         /* Parent.  Close the other side, and return the local side. */
287         close(pin[0]);
288         *fdout = pin[1];
289         close(pout[1]);
290         *fdin = pout[0];
291         signal(SIGTERM, killchild);
292         signal(SIGINT, killchild);
293         signal(SIGHUP, killchild);
294         return 0;
295 }
296
297 /*
298  * This functions executes a command simlar to do_cmd(), but expects the
299  * input and output descriptors to be setup by a previous call to do_cmd().
300  * This way the input and output of two commands can be connected.
301  */
302 int
303 do_cmd2(char *host, char *remuser, char *cmd, int fdin, int fdout)
304 {
305         pid_t pid;
306         int status;
307
308         if (verbose_mode)
309                 fprintf(stderr,
310                     "Executing: 2nd program %s host %s, user %s, command %s\n",
311                     ssh_program, host,
312                     remuser ? remuser : "(unspecified)", cmd);
313
314         /* Fork a child to execute the command on the remote host using ssh. */
315         pid = fork();
316         if (pid == 0) {
317                 dup2(fdin, 0);
318                 dup2(fdout, 1);
319
320                 replacearg(&args, 0, "%s", ssh_program);
321                 if (remuser != NULL) {
322                         addargs(&args, "-l");
323                         addargs(&args, "%s", remuser);
324                 }
325                 addargs(&args, "--");
326                 addargs(&args, "%s", host);
327                 addargs(&args, "%s", cmd);
328
329                 execvp(ssh_program, args.list);
330                 perror(ssh_program);
331                 exit(1);
332         } else if (pid == -1) {
333                 fatal("fork: %s", strerror(errno));
334         }
335         while (waitpid(pid, &status, 0) == -1)
336                 if (errno != EINTR)
337                         fatal("do_cmd2: waitpid: %s", strerror(errno));
338         return 0;
339 }
340
341 typedef struct {
342         size_t cnt;
343         char *buf;
344 } BUF;
345
346 BUF *allocbuf(BUF *, int, int);
347 void lostconn(int);
348 int okname(char *);
349 void run_err(const char *,...);
350 void verifydir(char *);
351
352 struct passwd *pwd;
353 uid_t userid;
354 int errs, remin, remout;
355 int pflag, iamremote, iamrecursive, targetshouldbedirectory;
356
357 #define CMDNEEDS        64
358 char cmd[CMDNEEDS];             /* must hold "rcp -r -p -d\0" */
359
360 int response(void);
361 void rsource(char *, struct stat *);
362 void sink(int, char *[]);
363 void source(int, char *[]);
364 void tolocal(int, char *[]);
365 void toremote(char *, int, char *[]);
366 void usage(void);
367
368 int
369 main(int argc, char **argv)
370 {
371         int ch, fflag, tflag, status, n;
372         char *targ, **newargv;
373         const char *errstr;
374         extern char *optarg;
375         extern int optind;
376
377         /* Ensure that fds 0, 1 and 2 are open or directed to /dev/null */
378         sanitise_stdfd();
379
380         /* Copy argv, because we modify it */
381         newargv = xcalloc(MAX(argc + 1, 1), sizeof(*newargv));
382         for (n = 0; n < argc; n++)
383                 newargv[n] = xstrdup(argv[n]);
384         argv = newargv;
385
386         __progname = ssh_get_progname(argv[0]);
387
388         memset(&args, '\0', sizeof(args));
389         memset(&remote_remote_args, '\0', sizeof(remote_remote_args));
390         args.list = remote_remote_args.list = NULL;
391         addargs(&args, "%s", ssh_program);
392         addargs(&args, "-x");
393         addargs(&args, "-oForwardAgent=no");
394         addargs(&args, "-oPermitLocalCommand=no");
395         addargs(&args, "-oClearAllForwardings=yes");
396
397         fflag = tflag = 0;
398         while ((ch = getopt(argc, argv, "dfl:prtvBCc:i:P:q12346S:o:F:")) != -1)
399                 switch (ch) {
400                 /* User-visible flags. */
401                 case '1':
402                 case '2':
403                 case '4':
404                 case '6':
405                 case 'C':
406                         addargs(&args, "-%c", ch);
407                         addargs(&remote_remote_args, "-%c", ch);
408                         break;
409                 case '3':
410                         throughlocal = 1;
411                         break;
412                 case 'o':
413                 case 'c':
414                 case 'i':
415                 case 'F':
416                         addargs(&remote_remote_args, "-%c", ch);
417                         addargs(&remote_remote_args, "%s", optarg);
418                         addargs(&args, "-%c", ch);
419                         addargs(&args, "%s", optarg);
420                         break;
421                 case 'P':
422                         addargs(&remote_remote_args, "-p");
423                         addargs(&remote_remote_args, "%s", optarg);
424                         addargs(&args, "-p");
425                         addargs(&args, "%s", optarg);
426                         break;
427                 case 'B':
428                         addargs(&remote_remote_args, "-oBatchmode=yes");
429                         addargs(&args, "-oBatchmode=yes");
430                         break;
431                 case 'l':
432                         limit_kbps = strtonum(optarg, 1, 100 * 1024 * 1024,
433                             &errstr);
434                         if (errstr != NULL)
435                                 usage();
436                         limit_kbps *= 1024; /* kbps */
437                         bandwidth_limit_init(&bwlimit, limit_kbps, COPY_BUFLEN);
438                         break;
439                 case 'p':
440                         pflag = 1;
441                         break;
442                 case 'r':
443                         iamrecursive = 1;
444                         break;
445                 case 'S':
446                         ssh_program = xstrdup(optarg);
447                         break;
448                 case 'v':
449                         addargs(&args, "-v");
450                         addargs(&remote_remote_args, "-v");
451                         verbose_mode = 1;
452                         break;
453                 case 'q':
454                         addargs(&args, "-q");
455                         addargs(&remote_remote_args, "-q");
456                         showprogress = 0;
457                         break;
458
459                 /* Server options. */
460                 case 'd':
461                         targetshouldbedirectory = 1;
462                         break;
463                 case 'f':       /* "from" */
464                         iamremote = 1;
465                         fflag = 1;
466                         break;
467                 case 't':       /* "to" */
468                         iamremote = 1;
469                         tflag = 1;
470 #ifdef HAVE_CYGWIN
471                         setmode(0, O_BINARY);
472 #endif
473                         break;
474                 default:
475                         usage();
476                 }
477         argc -= optind;
478         argv += optind;
479
480         if ((pwd = getpwuid(userid = getuid())) == NULL)
481                 fatal("unknown user %u", (u_int) userid);
482
483         if (!isatty(STDOUT_FILENO))
484                 showprogress = 0;
485
486         remin = STDIN_FILENO;
487         remout = STDOUT_FILENO;
488
489         if (fflag) {
490                 /* Follow "protocol", send data. */
491                 (void) response();
492                 source(argc, argv);
493                 exit(errs != 0);
494         }
495         if (tflag) {
496                 /* Receive data. */
497                 sink(argc, argv);
498                 exit(errs != 0);
499         }
500         if (argc < 2)
501                 usage();
502         if (argc > 2)
503                 targetshouldbedirectory = 1;
504
505         remin = remout = -1;
506         do_cmd_pid = -1;
507         /* Command to be executed on remote system using "ssh". */
508         (void) snprintf(cmd, sizeof cmd, "scp%s%s%s%s",
509             verbose_mode ? " -v" : "",
510             iamrecursive ? " -r" : "", pflag ? " -p" : "",
511             targetshouldbedirectory ? " -d" : "");
512
513         (void) signal(SIGPIPE, lostconn);
514
515         if ((targ = colon(argv[argc - 1])))     /* Dest is remote host. */
516                 toremote(targ, argc, argv);
517         else {
518                 if (targetshouldbedirectory)
519                         verifydir(argv[argc - 1]);
520                 tolocal(argc, argv);    /* Dest is local host. */
521         }
522         /*
523          * Finally check the exit status of the ssh process, if one was forked
524          * and no error has occurred yet
525          */
526         if (do_cmd_pid != -1 && errs == 0) {
527                 if (remin != -1)
528                     (void) close(remin);
529                 if (remout != -1)
530                     (void) close(remout);
531                 if (waitpid(do_cmd_pid, &status, 0) == -1)
532                         errs = 1;
533                 else {
534                         if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
535                                 errs = 1;
536                 }
537         }
538         exit(errs != 0);
539 }
540
541 /* Callback from atomicio6 to update progress meter and limit bandwidth */
542 static int
543 scpio(void *_cnt, size_t s)
544 {
545         off_t *cnt = (off_t *)_cnt;
546
547         *cnt += s;
548         if (limit_kbps > 0)
549                 bandwidth_limit(&bwlimit, s);
550         return 0;
551 }
552
553 static int
554 do_times(int fd, int verb, const struct stat *sb)
555 {
556         /* strlen(2^64) == 20; strlen(10^6) == 7 */
557         char buf[(20 + 7 + 2) * 2 + 2];
558
559         (void)snprintf(buf, sizeof(buf), "T%llu 0 %llu 0\n",
560             (unsigned long long) (sb->st_mtime < 0 ? 0 : sb->st_mtime),
561             (unsigned long long) (sb->st_atime < 0 ? 0 : sb->st_atime));
562         if (verb) {
563                 fprintf(stderr, "File mtime %lld atime %lld\n",
564                     (long long)sb->st_mtime, (long long)sb->st_atime);
565                 fprintf(stderr, "Sending file timestamps: %s", buf);
566         }
567         (void) atomicio(vwrite, fd, buf, strlen(buf));
568         return (response());
569 }
570
571 void
572 toremote(char *targ, int argc, char **argv)
573 {
574         char *bp, *host, *src, *suser, *thost, *tuser, *arg;
575         arglist alist;
576         int i;
577         u_int j;
578
579         memset(&alist, '\0', sizeof(alist));
580         alist.list = NULL;
581
582         *targ++ = 0;
583         if (*targ == 0)
584                 targ = ".";
585
586         arg = xstrdup(argv[argc - 1]);
587         if ((thost = strrchr(arg, '@'))) {
588                 /* user@host */
589                 *thost++ = 0;
590                 tuser = arg;
591                 if (*tuser == '\0')
592                         tuser = NULL;
593         } else {
594                 thost = arg;
595                 tuser = NULL;
596         }
597
598         if (tuser != NULL && !okname(tuser)) {
599                 free(arg);
600                 return;
601         }
602
603         for (i = 0; i < argc - 1; i++) {
604                 src = colon(argv[i]);
605                 if (src && throughlocal) {      /* extended remote to remote */
606                         *src++ = 0;
607                         if (*src == 0)
608                                 src = ".";
609                         host = strrchr(argv[i], '@');
610                         if (host) {
611                                 *host++ = 0;
612                                 host = cleanhostname(host);
613                                 suser = argv[i];
614                                 if (*suser == '\0')
615                                         suser = pwd->pw_name;
616                                 else if (!okname(suser))
617                                         continue;
618                         } else {
619                                 host = cleanhostname(argv[i]);
620                                 suser = NULL;
621                         }
622                         xasprintf(&bp, "%s -f %s%s", cmd,
623                             *src == '-' ? "-- " : "", src);
624                         if (do_cmd(host, suser, bp, &remin, &remout) < 0)
625                                 exit(1);
626                         free(bp);
627                         host = cleanhostname(thost);
628                         xasprintf(&bp, "%s -t %s%s", cmd,
629                             *targ == '-' ? "-- " : "", targ);
630                         if (do_cmd2(host, tuser, bp, remin, remout) < 0)
631                                 exit(1);
632                         free(bp);
633                         (void) close(remin);
634                         (void) close(remout);
635                         remin = remout = -1;
636                 } else if (src) {       /* standard remote to remote */
637                         freeargs(&alist);
638                         addargs(&alist, "%s", ssh_program);
639                         addargs(&alist, "-x");
640                         addargs(&alist, "-oClearAllForwardings=yes");
641                         addargs(&alist, "-n");
642                         for (j = 0; j < remote_remote_args.num; j++) {
643                                 addargs(&alist, "%s",
644                                     remote_remote_args.list[j]);
645                         }
646                         *src++ = 0;
647                         if (*src == 0)
648                                 src = ".";
649                         host = strrchr(argv[i], '@');
650
651                         if (host) {
652                                 *host++ = 0;
653                                 host = cleanhostname(host);
654                                 suser = argv[i];
655                                 if (*suser == '\0')
656                                         suser = pwd->pw_name;
657                                 else if (!okname(suser))
658                                         continue;
659                                 addargs(&alist, "-l");
660                                 addargs(&alist, "%s", suser);
661                         } else {
662                                 host = cleanhostname(argv[i]);
663                         }
664                         addargs(&alist, "--");
665                         addargs(&alist, "%s", host);
666                         addargs(&alist, "%s", cmd);
667                         addargs(&alist, "%s", src);
668                         addargs(&alist, "%s%s%s:%s",
669                             tuser ? tuser : "", tuser ? "@" : "",
670                             thost, targ);
671                         if (do_local_cmd(&alist) != 0)
672                                 errs = 1;
673                 } else {        /* local to remote */
674                         if (remin == -1) {
675                                 xasprintf(&bp, "%s -t %s%s", cmd,
676                                     *targ == '-' ? "-- " : "", targ);
677                                 host = cleanhostname(thost);
678                                 if (do_cmd(host, tuser, bp, &remin,
679                                     &remout) < 0)
680                                         exit(1);
681                                 if (response() < 0)
682                                         exit(1);
683                                 free(bp);
684                         }
685                         source(1, argv + i);
686                 }
687         }
688         free(arg);
689 }
690
691 void
692 tolocal(int argc, char **argv)
693 {
694         char *bp, *host, *src, *suser;
695         arglist alist;
696         int i;
697
698         memset(&alist, '\0', sizeof(alist));
699         alist.list = NULL;
700
701         for (i = 0; i < argc - 1; i++) {
702                 if (!(src = colon(argv[i]))) {  /* Local to local. */
703                         freeargs(&alist);
704                         addargs(&alist, "%s", _PATH_CP);
705                         if (iamrecursive)
706                                 addargs(&alist, "-r");
707                         if (pflag)
708                                 addargs(&alist, "-p");
709                         addargs(&alist, "--");
710                         addargs(&alist, "%s", argv[i]);
711                         addargs(&alist, "%s", argv[argc-1]);
712                         if (do_local_cmd(&alist))
713                                 ++errs;
714                         continue;
715                 }
716                 *src++ = 0;
717                 if (*src == 0)
718                         src = ".";
719                 if ((host = strrchr(argv[i], '@')) == NULL) {
720                         host = argv[i];
721                         suser = NULL;
722                 } else {
723                         *host++ = 0;
724                         suser = argv[i];
725                         if (*suser == '\0')
726                                 suser = pwd->pw_name;
727                 }
728                 host = cleanhostname(host);
729                 xasprintf(&bp, "%s -f %s%s",
730                     cmd, *src == '-' ? "-- " : "", src);
731                 if (do_cmd(host, suser, bp, &remin, &remout) < 0) {
732                         free(bp);
733                         ++errs;
734                         continue;
735                 }
736                 free(bp);
737                 sink(1, argv + argc - 1);
738                 (void) close(remin);
739                 remin = remout = -1;
740         }
741 }
742
743 void
744 source(int argc, char **argv)
745 {
746         struct stat stb;
747         static BUF buffer;
748         BUF *bp;
749         off_t i, statbytes;
750         size_t amt;
751         int fd = -1, haderr, indx;
752         char *last, *name, buf[2048], encname[MAXPATHLEN];
753         int len;
754
755         for (indx = 0; indx < argc; ++indx) {
756                 name = argv[indx];
757                 statbytes = 0;
758                 len = strlen(name);
759                 while (len > 1 && name[len-1] == '/')
760                         name[--len] = '\0';
761                 if ((fd = open(name, O_RDONLY|O_NONBLOCK, 0)) < 0)
762                         goto syserr;
763                 if (strchr(name, '\n') != NULL) {
764                         strnvis(encname, name, sizeof(encname), VIS_NL);
765                         name = encname;
766                 }
767                 if (fstat(fd, &stb) < 0) {
768 syserr:                 run_err("%s: %s", name, strerror(errno));
769                         goto next;
770                 }
771                 if (stb.st_size < 0) {
772                         run_err("%s: %s", name, "Negative file size");
773                         goto next;
774                 }
775                 unset_nonblock(fd);
776                 switch (stb.st_mode & S_IFMT) {
777                 case S_IFREG:
778                         break;
779                 case S_IFDIR:
780                         if (iamrecursive) {
781                                 rsource(name, &stb);
782                                 goto next;
783                         }
784                         /* FALLTHROUGH */
785                 default:
786                         run_err("%s: not a regular file", name);
787                         goto next;
788                 }
789                 if ((last = strrchr(name, '/')) == NULL)
790                         last = name;
791                 else
792                         ++last;
793                 curfile = last;
794                 if (pflag) {
795                         if (do_times(remout, verbose_mode, &stb) < 0)
796                                 goto next;
797                 }
798 #define FILEMODEMASK    (S_ISUID|S_ISGID|S_IRWXU|S_IRWXG|S_IRWXO)
799                 snprintf(buf, sizeof buf, "C%04o %lld %s\n",
800                     (u_int) (stb.st_mode & FILEMODEMASK),
801                     (long long)stb.st_size, last);
802                 if (verbose_mode) {
803                         fprintf(stderr, "Sending file modes: %s", buf);
804                 }
805                 (void) atomicio(vwrite, remout, buf, strlen(buf));
806                 if (response() < 0)
807                         goto next;
808                 if ((bp = allocbuf(&buffer, fd, COPY_BUFLEN)) == NULL) {
809 next:                   if (fd != -1) {
810                                 (void) close(fd);
811                                 fd = -1;
812                         }
813                         continue;
814                 }
815                 if (showprogress)
816                         start_progress_meter(curfile, stb.st_size, &statbytes);
817                 set_nonblock(remout);
818                 for (haderr = i = 0; i < stb.st_size; i += bp->cnt) {
819                         amt = bp->cnt;
820                         if (i + (off_t)amt > stb.st_size)
821                                 amt = stb.st_size - i;
822                         if (!haderr) {
823                                 if (atomicio(read, fd, bp->buf, amt) != amt)
824                                         haderr = errno;
825                         }
826                         /* Keep writing after error to retain sync */
827                         if (haderr) {
828                                 (void)atomicio(vwrite, remout, bp->buf, amt);
829                                 continue;
830                         }
831                         if (atomicio6(vwrite, remout, bp->buf, amt, scpio,
832                             &statbytes) != amt)
833                                 haderr = errno;
834                 }
835                 unset_nonblock(remout);
836                 if (showprogress)
837                         stop_progress_meter();
838
839                 if (fd != -1) {
840                         if (close(fd) < 0 && !haderr)
841                                 haderr = errno;
842                         fd = -1;
843                 }
844                 if (!haderr)
845                         (void) atomicio(vwrite, remout, "", 1);
846                 else
847                         run_err("%s: %s", name, strerror(haderr));
848                 (void) response();
849         }
850 }
851
852 void
853 rsource(char *name, struct stat *statp)
854 {
855         DIR *dirp;
856         struct dirent *dp;
857         char *last, *vect[1], path[MAXPATHLEN];
858
859         if (!(dirp = opendir(name))) {
860                 run_err("%s: %s", name, strerror(errno));
861                 return;
862         }
863         last = strrchr(name, '/');
864         if (last == 0)
865                 last = name;
866         else
867                 last++;
868         if (pflag) {
869                 if (do_times(remout, verbose_mode, statp) < 0) {
870                         closedir(dirp);
871                         return;
872                 }
873         }
874         (void) snprintf(path, sizeof path, "D%04o %d %.1024s\n",
875             (u_int) (statp->st_mode & FILEMODEMASK), 0, last);
876         if (verbose_mode)
877                 fprintf(stderr, "Entering directory: %s", path);
878         (void) atomicio(vwrite, remout, path, strlen(path));
879         if (response() < 0) {
880                 closedir(dirp);
881                 return;
882         }
883         while ((dp = readdir(dirp)) != NULL) {
884                 if (dp->d_ino == 0)
885                         continue;
886                 if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
887                         continue;
888                 if (strlen(name) + 1 + strlen(dp->d_name) >= sizeof(path) - 1) {
889                         run_err("%s/%s: name too long", name, dp->d_name);
890                         continue;
891                 }
892                 (void) snprintf(path, sizeof path, "%s/%s", name, dp->d_name);
893                 vect[0] = path;
894                 source(1, vect);
895         }
896         (void) closedir(dirp);
897         (void) atomicio(vwrite, remout, "E\n", 2);
898         (void) response();
899 }
900
901 void
902 sink(int argc, char **argv)
903 {
904         static BUF buffer;
905         struct stat stb;
906         enum {
907                 YES, NO, DISPLAYED
908         } wrerr;
909         BUF *bp;
910         off_t i;
911         size_t j, count;
912         int amt, exists, first, ofd;
913         mode_t mode, omode, mask;
914         off_t size, statbytes;
915         unsigned long long ull;
916         int setimes, targisdir, wrerrno = 0;
917         char ch, *cp, *np, *targ, *why, *vect[1], buf[2048];
918         struct timeval tv[2];
919
920 #define atime   tv[0]
921 #define mtime   tv[1]
922 #define SCREWUP(str)    { why = str; goto screwup; }
923
924         setimes = targisdir = 0;
925         mask = umask(0);
926         if (!pflag)
927                 (void) umask(mask);
928         if (argc != 1) {
929                 run_err("ambiguous target");
930                 exit(1);
931         }
932         targ = *argv;
933         if (targetshouldbedirectory)
934                 verifydir(targ);
935
936         (void) atomicio(vwrite, remout, "", 1);
937         if (stat(targ, &stb) == 0 && S_ISDIR(stb.st_mode))
938                 targisdir = 1;
939         for (first = 1;; first = 0) {
940                 cp = buf;
941                 if (atomicio(read, remin, cp, 1) != 1)
942                         return;
943                 if (*cp++ == '\n')
944                         SCREWUP("unexpected <newline>");
945                 do {
946                         if (atomicio(read, remin, &ch, sizeof(ch)) != sizeof(ch))
947                                 SCREWUP("lost connection");
948                         *cp++ = ch;
949                 } while (cp < &buf[sizeof(buf) - 1] && ch != '\n');
950                 *cp = 0;
951                 if (verbose_mode)
952                         fprintf(stderr, "Sink: %s", buf);
953
954                 if (buf[0] == '\01' || buf[0] == '\02') {
955                         if (iamremote == 0)
956                                 (void) atomicio(vwrite, STDERR_FILENO,
957                                     buf + 1, strlen(buf + 1));
958                         if (buf[0] == '\02')
959                                 exit(1);
960                         ++errs;
961                         continue;
962                 }
963                 if (buf[0] == 'E') {
964                         (void) atomicio(vwrite, remout, "", 1);
965                         return;
966                 }
967                 if (ch == '\n')
968                         *--cp = 0;
969
970                 cp = buf;
971                 if (*cp == 'T') {
972                         setimes++;
973                         cp++;
974                         if (!isdigit((unsigned char)*cp))
975                                 SCREWUP("mtime.sec not present");
976                         ull = strtoull(cp, &cp, 10);
977                         if (!cp || *cp++ != ' ')
978                                 SCREWUP("mtime.sec not delimited");
979                         if ((time_t)ull < 0 ||
980                             (unsigned long long)(time_t)ull != ull)
981                                 setimes = 0;    /* out of range */
982                         mtime.tv_sec = ull;
983                         mtime.tv_usec = strtol(cp, &cp, 10);
984                         if (!cp || *cp++ != ' ' || mtime.tv_usec < 0 ||
985                             mtime.tv_usec > 999999)
986                                 SCREWUP("mtime.usec not delimited");
987                         if (!isdigit((unsigned char)*cp))
988                                 SCREWUP("atime.sec not present");
989                         ull = strtoull(cp, &cp, 10);
990                         if (!cp || *cp++ != ' ')
991                                 SCREWUP("atime.sec not delimited");
992                         if ((time_t)ull < 0 ||
993                             (unsigned long long)(time_t)ull != ull)
994                                 setimes = 0;    /* out of range */
995                         atime.tv_sec = ull;
996                         atime.tv_usec = strtol(cp, &cp, 10);
997                         if (!cp || *cp++ != '\0' || atime.tv_usec < 0 ||
998                             atime.tv_usec > 999999)
999                                 SCREWUP("atime.usec not delimited");
1000                         (void) atomicio(vwrite, remout, "", 1);
1001                         continue;
1002                 }
1003                 if (*cp != 'C' && *cp != 'D') {
1004                         /*
1005                          * Check for the case "rcp remote:foo\* local:bar".
1006                          * In this case, the line "No match." can be returned
1007                          * by the shell before the rcp command on the remote is
1008                          * executed so the ^Aerror_message convention isn't
1009                          * followed.
1010                          */
1011                         if (first) {
1012                                 run_err("%s", cp);
1013                                 exit(1);
1014                         }
1015                         SCREWUP("expected control record");
1016                 }
1017                 mode = 0;
1018                 for (++cp; cp < buf + 5; cp++) {
1019                         if (*cp < '0' || *cp > '7')
1020                                 SCREWUP("bad mode");
1021                         mode = (mode << 3) | (*cp - '0');
1022                 }
1023                 if (*cp++ != ' ')
1024                         SCREWUP("mode not delimited");
1025
1026                 for (size = 0; isdigit(*cp);)
1027                         size = size * 10 + (*cp++ - '0');
1028                 if (*cp++ != ' ')
1029                         SCREWUP("size not delimited");
1030                 if ((strchr(cp, '/') != NULL) || (strcmp(cp, "..") == 0)) {
1031                         run_err("error: unexpected filename: %s", cp);
1032                         exit(1);
1033                 }
1034                 if (targisdir) {
1035                         static char *namebuf;
1036                         static size_t cursize;
1037                         size_t need;
1038
1039                         need = strlen(targ) + strlen(cp) + 250;
1040                         if (need > cursize) {
1041                                 free(namebuf);
1042                                 namebuf = xmalloc(need);
1043                                 cursize = need;
1044                         }
1045                         (void) snprintf(namebuf, need, "%s%s%s", targ,
1046                             strcmp(targ, "/") ? "/" : "", cp);
1047                         np = namebuf;
1048                 } else
1049                         np = targ;
1050                 curfile = cp;
1051                 exists = stat(np, &stb) == 0;
1052                 if (buf[0] == 'D') {
1053                         int mod_flag = pflag;
1054                         if (!iamrecursive)
1055                                 SCREWUP("received directory without -r");
1056                         if (exists) {
1057                                 if (!S_ISDIR(stb.st_mode)) {
1058                                         errno = ENOTDIR;
1059                                         goto bad;
1060                                 }
1061                                 if (pflag)
1062                                         (void) chmod(np, mode);
1063                         } else {
1064                                 /* Handle copying from a read-only
1065                                    directory */
1066                                 mod_flag = 1;
1067                                 if (mkdir(np, mode | S_IRWXU) < 0)
1068                                         goto bad;
1069                         }
1070                         vect[0] = xstrdup(np);
1071                         sink(1, vect);
1072                         if (setimes) {
1073                                 setimes = 0;
1074                                 if (utimes(vect[0], tv) < 0)
1075                                         run_err("%s: set times: %s",
1076                                             vect[0], strerror(errno));
1077                         }
1078                         if (mod_flag)
1079                                 (void) chmod(vect[0], mode);
1080                         free(vect[0]);
1081                         continue;
1082                 }
1083                 omode = mode;
1084                 mode |= S_IWUSR;
1085                 if ((ofd = open(np, O_WRONLY|O_CREAT, mode)) < 0) {
1086 bad:                    run_err("%s: %s", np, strerror(errno));
1087                         continue;
1088                 }
1089                 (void) atomicio(vwrite, remout, "", 1);
1090                 if ((bp = allocbuf(&buffer, ofd, COPY_BUFLEN)) == NULL) {
1091                         (void) close(ofd);
1092                         continue;
1093                 }
1094                 cp = bp->buf;
1095                 wrerr = NO;
1096
1097                 statbytes = 0;
1098                 if (showprogress)
1099                         start_progress_meter(curfile, size, &statbytes);
1100                 set_nonblock(remin);
1101                 for (count = i = 0; i < size; i += bp->cnt) {
1102                         amt = bp->cnt;
1103                         if (i + amt > size)
1104                                 amt = size - i;
1105                         count += amt;
1106                         do {
1107                                 j = atomicio6(read, remin, cp, amt,
1108                                     scpio, &statbytes);
1109                                 if (j == 0) {
1110                                         run_err("%s", j != EPIPE ?
1111                                             strerror(errno) :
1112                                             "dropped connection");
1113                                         exit(1);
1114                                 }
1115                                 amt -= j;
1116                                 cp += j;
1117                         } while (amt > 0);
1118
1119                         if (count == bp->cnt) {
1120                                 /* Keep reading so we stay sync'd up. */
1121                                 if (wrerr == NO) {
1122                                         if (atomicio(vwrite, ofd, bp->buf,
1123                                             count) != count) {
1124                                                 wrerr = YES;
1125                                                 wrerrno = errno;
1126                                         }
1127                                 }
1128                                 count = 0;
1129                                 cp = bp->buf;
1130                         }
1131                 }
1132                 unset_nonblock(remin);
1133                 if (showprogress)
1134                         stop_progress_meter();
1135                 if (count != 0 && wrerr == NO &&
1136                     atomicio(vwrite, ofd, bp->buf, count) != count) {
1137                         wrerr = YES;
1138                         wrerrno = errno;
1139                 }
1140                 if (wrerr == NO && (!exists || S_ISREG(stb.st_mode)) &&
1141                     ftruncate(ofd, size) != 0) {
1142                         run_err("%s: truncate: %s", np, strerror(errno));
1143                         wrerr = DISPLAYED;
1144                 }
1145                 if (pflag) {
1146                         if (exists || omode != mode)
1147 #ifdef HAVE_FCHMOD
1148                                 if (fchmod(ofd, omode)) {
1149 #else /* HAVE_FCHMOD */
1150                                 if (chmod(np, omode)) {
1151 #endif /* HAVE_FCHMOD */
1152                                         run_err("%s: set mode: %s",
1153                                             np, strerror(errno));
1154                                         wrerr = DISPLAYED;
1155                                 }
1156                 } else {
1157                         if (!exists && omode != mode)
1158 #ifdef HAVE_FCHMOD
1159                                 if (fchmod(ofd, omode & ~mask)) {
1160 #else /* HAVE_FCHMOD */
1161                                 if (chmod(np, omode & ~mask)) {
1162 #endif /* HAVE_FCHMOD */
1163                                         run_err("%s: set mode: %s",
1164                                             np, strerror(errno));
1165                                         wrerr = DISPLAYED;
1166                                 }
1167                 }
1168                 if (close(ofd) == -1) {
1169                         wrerr = YES;
1170                         wrerrno = errno;
1171                 }
1172                 (void) response();
1173                 if (setimes && wrerr == NO) {
1174                         setimes = 0;
1175                         if (utimes(np, tv) < 0) {
1176                                 run_err("%s: set times: %s",
1177                                     np, strerror(errno));
1178                                 wrerr = DISPLAYED;
1179                         }
1180                 }
1181                 switch (wrerr) {
1182                 case YES:
1183                         run_err("%s: %s", np, strerror(wrerrno));
1184                         break;
1185                 case NO:
1186                         (void) atomicio(vwrite, remout, "", 1);
1187                         break;
1188                 case DISPLAYED:
1189                         break;
1190                 }
1191         }
1192 screwup:
1193         run_err("protocol error: %s", why);
1194         exit(1);
1195 }
1196
1197 int
1198 response(void)
1199 {
1200         char ch, *cp, resp, rbuf[2048];
1201
1202         if (atomicio(read, remin, &resp, sizeof(resp)) != sizeof(resp))
1203                 lostconn(0);
1204
1205         cp = rbuf;
1206         switch (resp) {
1207         case 0:         /* ok */
1208                 return (0);
1209         default:
1210                 *cp++ = resp;
1211                 /* FALLTHROUGH */
1212         case 1:         /* error, followed by error msg */
1213         case 2:         /* fatal error, "" */
1214                 do {
1215                         if (atomicio(read, remin, &ch, sizeof(ch)) != sizeof(ch))
1216                                 lostconn(0);
1217                         *cp++ = ch;
1218                 } while (cp < &rbuf[sizeof(rbuf) - 1] && ch != '\n');
1219
1220                 if (!iamremote)
1221                         (void) atomicio(vwrite, STDERR_FILENO, rbuf, cp - rbuf);
1222                 ++errs;
1223                 if (resp == 1)
1224                         return (-1);
1225                 exit(1);
1226         }
1227         /* NOTREACHED */
1228 }
1229
1230 void
1231 usage(void)
1232 {
1233         (void) fprintf(stderr,
1234             "usage: scp [-12346BCpqrv] [-c cipher] [-F ssh_config] [-i identity_file]\n"
1235             "           [-l limit] [-o ssh_option] [-P port] [-S program]\n"
1236             "           [[user@]host1:]file1 ... [[user@]host2:]file2\n");
1237         exit(1);
1238 }
1239
1240 void
1241 run_err(const char *fmt,...)
1242 {
1243         static FILE *fp;
1244         va_list ap;
1245
1246         ++errs;
1247         if (fp != NULL || (remout != -1 && (fp = fdopen(remout, "w")))) {
1248                 (void) fprintf(fp, "%c", 0x01);
1249                 (void) fprintf(fp, "scp: ");
1250                 va_start(ap, fmt);
1251                 (void) vfprintf(fp, fmt, ap);
1252                 va_end(ap);
1253                 (void) fprintf(fp, "\n");
1254                 (void) fflush(fp);
1255         }
1256
1257         if (!iamremote) {
1258                 va_start(ap, fmt);
1259                 vfprintf(stderr, fmt, ap);
1260                 va_end(ap);
1261                 fprintf(stderr, "\n");
1262         }
1263 }
1264
1265 void
1266 verifydir(char *cp)
1267 {
1268         struct stat stb;
1269
1270         if (!stat(cp, &stb)) {
1271                 if (S_ISDIR(stb.st_mode))
1272                         return;
1273                 errno = ENOTDIR;
1274         }
1275         run_err("%s: %s", cp, strerror(errno));
1276         killchild(0);
1277 }
1278
1279 int
1280 okname(char *cp0)
1281 {
1282         int c;
1283         char *cp;
1284
1285         cp = cp0;
1286         do {
1287                 c = (int)*cp;
1288                 if (c & 0200)
1289                         goto bad;
1290                 if (!isalpha(c) && !isdigit(c)) {
1291                         switch (c) {
1292                         case '\'':
1293                         case '"':
1294                         case '`':
1295                         case ' ':
1296                         case '#':
1297                                 goto bad;
1298                         default:
1299                                 break;
1300                         }
1301                 }
1302         } while (*++cp);
1303         return (1);
1304
1305 bad:    fprintf(stderr, "%s: invalid user name\n", cp0);
1306         return (0);
1307 }
1308
1309 BUF *
1310 allocbuf(BUF *bp, int fd, int blksize)
1311 {
1312         size_t size;
1313 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
1314         struct stat stb;
1315
1316         if (fstat(fd, &stb) < 0) {
1317                 run_err("fstat: %s", strerror(errno));
1318                 return (0);
1319         }
1320         size = roundup(stb.st_blksize, blksize);
1321         if (size == 0)
1322                 size = blksize;
1323 #else /* HAVE_STRUCT_STAT_ST_BLKSIZE */
1324         size = blksize;
1325 #endif /* HAVE_STRUCT_STAT_ST_BLKSIZE */
1326         if (bp->cnt >= size)
1327                 return (bp);
1328         if (bp->buf == NULL)
1329                 bp->buf = xmalloc(size);
1330         else
1331                 bp->buf = xrealloc(bp->buf, 1, size);
1332         memset(bp->buf, 0, size);
1333         bp->cnt = size;
1334         return (bp);
1335 }
1336
1337 void
1338 lostconn(int signo)
1339 {
1340         if (!iamremote)
1341                 (void)write(STDERR_FILENO, "lost connection\n", 16);
1342         if (signo)
1343                 _exit(1);
1344         else
1345                 exit(1);
1346 }