1 /* $OpenBSD: scp.c,v 1.180 2014/06/24 02:21:01 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, nr; 751 int fd = -1, haderr, indx; 752 char *last, *name, buf[16384], 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 ((nr = atomicio(read, fd, 824 bp->buf, amt)) != amt) { 825 haderr = errno; 826 memset(bp->buf + nr, 0, amt - nr); 827 } 828 } 829 /* Keep writing after error to retain sync */ 830 if (haderr) { 831 (void)atomicio(vwrite, remout, bp->buf, amt); 832 memset(bp->buf, 0, amt); 833 continue; 834 } 835 if (atomicio6(vwrite, remout, bp->buf, amt, scpio, 836 &statbytes) != amt) 837 haderr = errno; 838 } 839 unset_nonblock(remout); 840 if (showprogress) 841 stop_progress_meter(); 842 843 if (fd != -1) { 844 if (close(fd) < 0 && !haderr) 845 haderr = errno; 846 fd = -1; 847 } 848 if (!haderr) 849 (void) atomicio(vwrite, remout, "", 1); 850 else 851 run_err("%s: %s", name, strerror(haderr)); 852 (void) response(); 853 } 854 } 855 856 void 857 rsource(char *name, struct stat *statp) 858 { 859 DIR *dirp; 860 struct dirent *dp; 861 char *last, *vect[1], path[MAXPATHLEN]; 862 863 if (!(dirp = opendir(name))) { 864 run_err("%s: %s", name, strerror(errno)); 865 return; 866 } 867 last = strrchr(name, '/'); 868 if (last == 0) 869 last = name; 870 else 871 last++; 872 if (pflag) { 873 if (do_times(remout, verbose_mode, statp) < 0) { 874 closedir(dirp); 875 return; 876 } 877 } 878 (void) snprintf(path, sizeof path, "D%04o %d %.1024s\n", 879 (u_int) (statp->st_mode & FILEMODEMASK), 0, last); 880 if (verbose_mode) 881 fprintf(stderr, "Entering directory: %s", path); 882 (void) atomicio(vwrite, remout, path, strlen(path)); 883 if (response() < 0) { 884 closedir(dirp); 885 return; 886 } 887 while ((dp = readdir(dirp)) != NULL) { 888 if (dp->d_ino == 0) 889 continue; 890 if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, "..")) 891 continue; 892 if (strlen(name) + 1 + strlen(dp->d_name) >= sizeof(path) - 1) { 893 run_err("%s/%s: name too long", name, dp->d_name); 894 continue; 895 } 896 (void) snprintf(path, sizeof path, "%s/%s", name, dp->d_name); 897 vect[0] = path; 898 source(1, vect); 899 } 900 (void) closedir(dirp); 901 (void) atomicio(vwrite, remout, "E\n", 2); 902 (void) response(); 903 } 904 905 void 906 sink(int argc, char **argv) 907 { 908 static BUF buffer; 909 struct stat stb; 910 enum { 911 YES, NO, DISPLAYED 912 } wrerr; 913 BUF *bp; 914 off_t i; 915 size_t j, count; 916 int amt, exists, first, ofd; 917 mode_t mode, omode, mask; 918 off_t size, statbytes; 919 unsigned long long ull; 920 int setimes, targisdir, wrerrno = 0; 921 char ch, *cp, *np, *targ, *why, *vect[1], buf[16384]; 922 struct timeval tv[2]; 923 924 #define atime tv[0] 925 #define mtime tv[1] 926 #define SCREWUP(str) { why = str; goto screwup; } 927 928 setimes = targisdir = 0; 929 mask = umask(0); 930 if (!pflag) 931 (void) umask(mask); 932 if (argc != 1) { 933 run_err("ambiguous target"); 934 exit(1); 935 } 936 targ = *argv; 937 if (targetshouldbedirectory) 938 verifydir(targ); 939 940 (void) atomicio(vwrite, remout, "", 1); 941 if (stat(targ, &stb) == 0 && S_ISDIR(stb.st_mode)) 942 targisdir = 1; 943 for (first = 1;; first = 0) { 944 cp = buf; 945 if (atomicio(read, remin, cp, 1) != 1) 946 return; 947 if (*cp++ == '\n') 948 SCREWUP("unexpected <newline>"); 949 do { 950 if (atomicio(read, remin, &ch, sizeof(ch)) != sizeof(ch)) 951 SCREWUP("lost connection"); 952 *cp++ = ch; 953 } while (cp < &buf[sizeof(buf) - 1] && ch != '\n'); 954 *cp = 0; 955 if (verbose_mode) 956 fprintf(stderr, "Sink: %s", buf); 957 958 if (buf[0] == '\01' || buf[0] == '\02') { 959 if (iamremote == 0) 960 (void) atomicio(vwrite, STDERR_FILENO, 961 buf + 1, strlen(buf + 1)); 962 if (buf[0] == '\02') 963 exit(1); 964 ++errs; 965 continue; 966 } 967 if (buf[0] == 'E') { 968 (void) atomicio(vwrite, remout, "", 1); 969 return; 970 } 971 if (ch == '\n') 972 *--cp = 0; 973 974 cp = buf; 975 if (*cp == 'T') { 976 setimes++; 977 cp++; 978 if (!isdigit((unsigned char)*cp)) 979 SCREWUP("mtime.sec not present"); 980 ull = strtoull(cp, &cp, 10); 981 if (!cp || *cp++ != ' ') 982 SCREWUP("mtime.sec not delimited"); 983 if ((time_t)ull < 0 || 984 (unsigned long long)(time_t)ull != ull) 985 setimes = 0; /* out of range */ 986 mtime.tv_sec = ull; 987 mtime.tv_usec = strtol(cp, &cp, 10); 988 if (!cp || *cp++ != ' ' || mtime.tv_usec < 0 || 989 mtime.tv_usec > 999999) 990 SCREWUP("mtime.usec not delimited"); 991 if (!isdigit((unsigned char)*cp)) 992 SCREWUP("atime.sec not present"); 993 ull = strtoull(cp, &cp, 10); 994 if (!cp || *cp++ != ' ') 995 SCREWUP("atime.sec not delimited"); 996 if ((time_t)ull < 0 || 997 (unsigned long long)(time_t)ull != ull) 998 setimes = 0; /* out of range */ 999 atime.tv_sec = ull; 1000 atime.tv_usec = strtol(cp, &cp, 10); 1001 if (!cp || *cp++ != '\0' || atime.tv_usec < 0 || 1002 atime.tv_usec > 999999) 1003 SCREWUP("atime.usec not delimited"); 1004 (void) atomicio(vwrite, remout, "", 1); 1005 continue; 1006 } 1007 if (*cp != 'C' && *cp != 'D') { 1008 /* 1009 * Check for the case "rcp remote:foo\* local:bar". 1010 * In this case, the line "No match." can be returned 1011 * by the shell before the rcp command on the remote is 1012 * executed so the ^Aerror_message convention isn't 1013 * followed. 1014 */ 1015 if (first) { 1016 run_err("%s", cp); 1017 exit(1); 1018 } 1019 SCREWUP("expected control record"); 1020 } 1021 mode = 0; 1022 for (++cp; cp < buf + 5; cp++) { 1023 if (*cp < '0' || *cp > '7') 1024 SCREWUP("bad mode"); 1025 mode = (mode << 3) | (*cp - '0'); 1026 } 1027 if (*cp++ != ' ') 1028 SCREWUP("mode not delimited"); 1029 1030 for (size = 0; isdigit((unsigned char)*cp);) 1031 size = size * 10 + (*cp++ - '0'); 1032 if (*cp++ != ' ') 1033 SCREWUP("size not delimited"); 1034 if ((strchr(cp, '/') != NULL) || (strcmp(cp, "..") == 0)) { 1035 run_err("error: unexpected filename: %s", cp); 1036 exit(1); 1037 } 1038 if (targisdir) { 1039 static char *namebuf; 1040 static size_t cursize; 1041 size_t need; 1042 1043 need = strlen(targ) + strlen(cp) + 250; 1044 if (need > cursize) { 1045 free(namebuf); 1046 namebuf = xmalloc(need); 1047 cursize = need; 1048 } 1049 (void) snprintf(namebuf, need, "%s%s%s", targ, 1050 strcmp(targ, "/") ? "/" : "", cp); 1051 np = namebuf; 1052 } else 1053 np = targ; 1054 curfile = cp; 1055 exists = stat(np, &stb) == 0; 1056 if (buf[0] == 'D') { 1057 int mod_flag = pflag; 1058 if (!iamrecursive) 1059 SCREWUP("received directory without -r"); 1060 if (exists) { 1061 if (!S_ISDIR(stb.st_mode)) { 1062 errno = ENOTDIR; 1063 goto bad; 1064 } 1065 if (pflag) 1066 (void) chmod(np, mode); 1067 } else { 1068 /* Handle copying from a read-only 1069 directory */ 1070 mod_flag = 1; 1071 if (mkdir(np, mode | S_IRWXU) < 0) 1072 goto bad; 1073 } 1074 vect[0] = xstrdup(np); 1075 sink(1, vect); 1076 if (setimes) { 1077 setimes = 0; 1078 if (utimes(vect[0], tv) < 0) 1079 run_err("%s: set times: %s", 1080 vect[0], strerror(errno)); 1081 } 1082 if (mod_flag) 1083 (void) chmod(vect[0], mode); 1084 free(vect[0]); 1085 continue; 1086 } 1087 omode = mode; 1088 mode |= S_IWUSR; 1089 if ((ofd = open(np, O_WRONLY|O_CREAT, mode)) < 0) { 1090 bad: run_err("%s: %s", np, strerror(errno)); 1091 continue; 1092 } 1093 (void) atomicio(vwrite, remout, "", 1); 1094 if ((bp = allocbuf(&buffer, ofd, COPY_BUFLEN)) == NULL) { 1095 (void) close(ofd); 1096 continue; 1097 } 1098 cp = bp->buf; 1099 wrerr = NO; 1100 1101 statbytes = 0; 1102 if (showprogress) 1103 start_progress_meter(curfile, size, &statbytes); 1104 set_nonblock(remin); 1105 for (count = i = 0; i < size; i += bp->cnt) { 1106 amt = bp->cnt; 1107 if (i + amt > size) 1108 amt = size - i; 1109 count += amt; 1110 do { 1111 j = atomicio6(read, remin, cp, amt, 1112 scpio, &statbytes); 1113 if (j == 0) { 1114 run_err("%s", j != EPIPE ? 1115 strerror(errno) : 1116 "dropped connection"); 1117 exit(1); 1118 } 1119 amt -= j; 1120 cp += j; 1121 } while (amt > 0); 1122 1123 if (count == bp->cnt) { 1124 /* Keep reading so we stay sync'd up. */ 1125 if (wrerr == NO) { 1126 if (atomicio(vwrite, ofd, bp->buf, 1127 count) != count) { 1128 wrerr = YES; 1129 wrerrno = errno; 1130 } 1131 } 1132 count = 0; 1133 cp = bp->buf; 1134 } 1135 } 1136 unset_nonblock(remin); 1137 if (showprogress) 1138 stop_progress_meter(); 1139 if (count != 0 && wrerr == NO && 1140 atomicio(vwrite, ofd, bp->buf, count) != count) { 1141 wrerr = YES; 1142 wrerrno = errno; 1143 } 1144 if (wrerr == NO && (!exists || S_ISREG(stb.st_mode)) && 1145 ftruncate(ofd, size) != 0) { 1146 run_err("%s: truncate: %s", np, strerror(errno)); 1147 wrerr = DISPLAYED; 1148 } 1149 if (pflag) { 1150 if (exists || omode != mode) 1151 #ifdef HAVE_FCHMOD 1152 if (fchmod(ofd, omode)) { 1153 #else /* HAVE_FCHMOD */ 1154 if (chmod(np, omode)) { 1155 #endif /* HAVE_FCHMOD */ 1156 run_err("%s: set mode: %s", 1157 np, strerror(errno)); 1158 wrerr = DISPLAYED; 1159 } 1160 } else { 1161 if (!exists && omode != mode) 1162 #ifdef HAVE_FCHMOD 1163 if (fchmod(ofd, omode & ~mask)) { 1164 #else /* HAVE_FCHMOD */ 1165 if (chmod(np, omode & ~mask)) { 1166 #endif /* HAVE_FCHMOD */ 1167 run_err("%s: set mode: %s", 1168 np, strerror(errno)); 1169 wrerr = DISPLAYED; 1170 } 1171 } 1172 if (close(ofd) == -1) { 1173 wrerr = YES; 1174 wrerrno = errno; 1175 } 1176 (void) response(); 1177 if (setimes && wrerr == NO) { 1178 setimes = 0; 1179 if (utimes(np, tv) < 0) { 1180 run_err("%s: set times: %s", 1181 np, strerror(errno)); 1182 wrerr = DISPLAYED; 1183 } 1184 } 1185 switch (wrerr) { 1186 case YES: 1187 run_err("%s: %s", np, strerror(wrerrno)); 1188 break; 1189 case NO: 1190 (void) atomicio(vwrite, remout, "", 1); 1191 break; 1192 case DISPLAYED: 1193 break; 1194 } 1195 } 1196 screwup: 1197 run_err("protocol error: %s", why); 1198 exit(1); 1199 } 1200 1201 int 1202 response(void) 1203 { 1204 char ch, *cp, resp, rbuf[2048]; 1205 1206 if (atomicio(read, remin, &resp, sizeof(resp)) != sizeof(resp)) 1207 lostconn(0); 1208 1209 cp = rbuf; 1210 switch (resp) { 1211 case 0: /* ok */ 1212 return (0); 1213 default: 1214 *cp++ = resp; 1215 /* FALLTHROUGH */ 1216 case 1: /* error, followed by error msg */ 1217 case 2: /* fatal error, "" */ 1218 do { 1219 if (atomicio(read, remin, &ch, sizeof(ch)) != sizeof(ch)) 1220 lostconn(0); 1221 *cp++ = ch; 1222 } while (cp < &rbuf[sizeof(rbuf) - 1] && ch != '\n'); 1223 1224 if (!iamremote) 1225 (void) atomicio(vwrite, STDERR_FILENO, rbuf, cp - rbuf); 1226 ++errs; 1227 if (resp == 1) 1228 return (-1); 1229 exit(1); 1230 } 1231 /* NOTREACHED */ 1232 } 1233 1234 void 1235 usage(void) 1236 { 1237 (void) fprintf(stderr, 1238 "usage: scp [-12346BCpqrv] [-c cipher] [-F ssh_config] [-i identity_file]\n" 1239 " [-l limit] [-o ssh_option] [-P port] [-S program]\n" 1240 " [[user@]host1:]file1 ... [[user@]host2:]file2\n"); 1241 exit(1); 1242 } 1243 1244 void 1245 run_err(const char *fmt,...) 1246 { 1247 static FILE *fp; 1248 va_list ap; 1249 1250 ++errs; 1251 if (fp != NULL || (remout != -1 && (fp = fdopen(remout, "w")))) { 1252 (void) fprintf(fp, "%c", 0x01); 1253 (void) fprintf(fp, "scp: "); 1254 va_start(ap, fmt); 1255 (void) vfprintf(fp, fmt, ap); 1256 va_end(ap); 1257 (void) fprintf(fp, "\n"); 1258 (void) fflush(fp); 1259 } 1260 1261 if (!iamremote) { 1262 va_start(ap, fmt); 1263 vfprintf(stderr, fmt, ap); 1264 va_end(ap); 1265 fprintf(stderr, "\n"); 1266 } 1267 } 1268 1269 void 1270 verifydir(char *cp) 1271 { 1272 struct stat stb; 1273 1274 if (!stat(cp, &stb)) { 1275 if (S_ISDIR(stb.st_mode)) 1276 return; 1277 errno = ENOTDIR; 1278 } 1279 run_err("%s: %s", cp, strerror(errno)); 1280 killchild(0); 1281 } 1282 1283 int 1284 okname(char *cp0) 1285 { 1286 int c; 1287 char *cp; 1288 1289 cp = cp0; 1290 do { 1291 c = (int)*cp; 1292 if (c & 0200) 1293 goto bad; 1294 if (!isalpha(c) && !isdigit((unsigned char)c)) { 1295 switch (c) { 1296 case '\'': 1297 case '"': 1298 case '`': 1299 case ' ': 1300 case '#': 1301 goto bad; 1302 default: 1303 break; 1304 } 1305 } 1306 } while (*++cp); 1307 return (1); 1308 1309 bad: fprintf(stderr, "%s: invalid user name\n", cp0); 1310 return (0); 1311 } 1312 1313 BUF * 1314 allocbuf(BUF *bp, int fd, int blksize) 1315 { 1316 size_t size; 1317 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE 1318 struct stat stb; 1319 1320 if (fstat(fd, &stb) < 0) { 1321 run_err("fstat: %s", strerror(errno)); 1322 return (0); 1323 } 1324 size = roundup(stb.st_blksize, blksize); 1325 if (size == 0) 1326 size = blksize; 1327 #else /* HAVE_STRUCT_STAT_ST_BLKSIZE */ 1328 size = blksize; 1329 #endif /* HAVE_STRUCT_STAT_ST_BLKSIZE */ 1330 if (bp->cnt >= size) 1331 return (bp); 1332 if (bp->buf == NULL) 1333 bp->buf = xmalloc(size); 1334 else 1335 bp->buf = xrealloc(bp->buf, 1, size); 1336 memset(bp->buf, 0, size); 1337 bp->cnt = size; 1338 return (bp); 1339 } 1340 1341 void 1342 lostconn(int signo) 1343 { 1344 if (!iamremote) 1345 (void)write(STDERR_FILENO, "lost connection\n", 16); 1346 if (signo) 1347 _exit(1); 1348 else 1349 exit(1); 1350 } 1351