1 /* $OpenBSD: scp.c,v 1.179 2013/11/20 20:53:10 deraadt 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((unsigned char)*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((unsigned char)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 } 1347