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