crypto/kerberosIV/appl/bsd/rcp.c

   1 /*
   2  * Copyright (c) 1983, 1990, 1992, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #include "bsd_locl.h"
  35
  36 RCSID("$Id: rcp.c,v 1.52.2.1 2000/06/23 02:35:16 assar Exp $");
  37
  38 /* Globals */
  39 static char     dst_realm_buf[REALM_SZ];
  40 static char     *dest_realm = NULL;
  41 static int      use_kerberos = 1;
  42
  43 static int      doencrypt = 0;
  44 #define OPTIONS "dfKk:prtxl:"
  45
  46 static char *user_name = NULL;  /* Given as -l option. */
  47
  48 static int errs, rem;
  49 static struct passwd *pwd;
  50 static u_short  port;
  51 static uid_t    userid;
  52 static int pflag, iamremote, iamrecursive, targetshouldbedirectory;
  53
  54 static int argc_copy;
  55 static char **argv_copy;
  56
  57 #define CMDNEEDS        64
  58 static char cmd[CMDNEEDS];              /* must hold "rcp -r -p -d\0" */
  59
  60 void rsource(char *name, struct stat *statp);
  61
  62 #define SERVICE_NAME    "rcmd"
  63
  64 CREDENTIALS cred;
  65 MSG_DAT msg_data;
  66 struct sockaddr_in foreign_addr, local_addr;
  67 Key_schedule schedule;
  68
  69 KTEXT_ST ticket;
  70 AUTH_DAT kdata;
  71
  72 static void
  73 send_auth(char *h, char *r)
  74 {
  75     int lslen, fslen, status;
  76     long opts;
  77
  78     lslen = sizeof(struct sockaddr_in);
  79     if (getsockname(rem, (struct sockaddr *)&local_addr, &lslen) < 0)
  80         err(1, "getsockname");
  81     fslen = sizeof(struct sockaddr_in);
  82     if (getpeername(rem, (struct sockaddr *)&foreign_addr, &fslen) < 0)
  83         err(1, "getpeername");
  84     if ((r == NULL) || (*r == '\0'))
  85         r = krb_realmofhost(h);
  86     opts = KOPT_DO_MUTUAL;
  87     if ((status = krb_sendauth(opts, rem, &ticket, SERVICE_NAME, h, r,
  88                                (unsigned long)getpid(), &msg_data, &cred,
  89                                schedule, &local_addr,
  90                                &foreign_addr, "KCMDV0.1")) != KSUCCESS)
  91         errx(1, "krb_sendauth failure: %s", krb_get_err_text(status));
  92 }
  93
  94 static void
  95 answer_auth(void)
  96 {
  97     int lslen, fslen, status;
  98     long opts;
  99     char inst[INST_SZ], v[9];
 100
 101     lslen = sizeof(struct sockaddr_in);
 102     if (getsockname(rem, (struct sockaddr *)&local_addr, &lslen) < 0)
 103         err(1, "getsockname");
 104     fslen = sizeof(struct sockaddr_in);
 105     if(getpeername(rem, (struct sockaddr *)&foreign_addr, &fslen) < 0)
 106             err(1, "getperrname");
 107     k_getsockinst(rem, inst, sizeof(inst));
 108     opts = KOPT_DO_MUTUAL;
 109     if ((status = krb_recvauth(opts, rem, &ticket, SERVICE_NAME, inst,
 110                                &foreign_addr, &local_addr,
 111                                &kdata, "", schedule, v)) != KSUCCESS)
 112         errx(1, "krb_recvauth failure: %s", krb_get_err_text(status));
 113 }
 114
 115 static int
 116 des_read(int fd, char *buf, int len)
 117 {
 118     if (doencrypt)
 119         return(des_enc_read(fd, buf, len, schedule,
 120                             (iamremote? &kdata.session : &cred.session)));
 121     else
 122         return(read(fd, buf, len));
 123 }
 124
 125 static int
 126 des_write(int fd, char *buf, int len)
 127 {
 128     if (doencrypt)
 129         return(des_enc_write(fd, buf, len, schedule,
 130                              (iamremote? &kdata.session : &cred.session)));
 131     else
 132         return(write(fd, buf, len));
 133 }
 134
 135 static void run_err(const char *fmt, ...)
 136 #ifdef __GNUC__
 137 __attribute__ ((format (printf, 1, 2)))
 138 #endif
 139 ;
 140
 141
 142 static void
 143 run_err(const char *fmt, ...)
 144 {
 145         char errbuf[1024];
 146
 147         va_list args;
 148         va_start(args, fmt);
 149         ++errs;
 150 #define RCPERR "\001rcp: "
 151         strlcpy (errbuf, RCPERR, sizeof(errbuf));
 152         vsnprintf (errbuf + strlen(errbuf),
 153                    sizeof(errbuf) - strlen(errbuf),
 154                    fmt, args);
 155         strlcat (errbuf, "\n", sizeof(errbuf));
 156         des_write (rem, errbuf, strlen(errbuf));
 157         if (!iamremote)
 158                 vwarnx(fmt, args);
 159         va_end(args);
 160 }
 161
 162 static void
 163 verifydir(char *cp)
 164 {
 165         struct stat stb;
 166
 167         if (!stat(cp, &stb)) {
 168                 if (S_ISDIR(stb.st_mode))
 169                         return;
 170                 errno = ENOTDIR;
 171         }
 172         run_err("%s: %s", cp, strerror(errno));
 173         exit(1);
 174 }
 175
 176 #define ROUNDUP(x, y)   ((((x)+((y)-1))/(y))*(y))
 177
 178 static BUF *
 179 allocbuf(BUF *bp, int fd, int blksize)
 180 {
 181         struct stat stb;
 182         size_t size;
 183
 184         if (fstat(fd, &stb) < 0) {
 185                 run_err("fstat: %s", strerror(errno));
 186                 return (0);
 187         }
 188 #ifdef HAVE_ST_BLKSIZE
 189         size = ROUNDUP(stb.st_blksize, blksize);
 190 #else
 191         size = blksize;
 192 #endif
 193         if (size == 0)
 194                 size = blksize;
 195         if (bp->cnt >= size)
 196                 return (bp);
 197         if (bp->buf == NULL)
 198                 bp->buf = malloc(size);
 199         else
 200                 bp->buf = realloc(bp->buf, size);
 201         if (bp->buf == NULL) {
 202                 bp->cnt = 0;
 203                 run_err("%s", strerror(errno));
 204                 return (0);
 205         }
 206         bp->cnt = size;
 207         return (bp);
 208 }
 209
 210 static void
 211 usage(void)
 212 {
 213         fprintf(stderr, "%s\n\t%s\n",
 214             "usage: rcp [-Kpx] [-k realm] f1 f2",
 215             "or: rcp [-Kprx] [-k realm] f1 ... fn directory");
 216         exit(1);
 217 }
 218
 219 static void
 220 oldw(const char *s)
 221 {
 222     char *rstar_no_warn = getenv("RSTAR_NO_WARN");
 223     if (rstar_no_warn == 0)
 224         rstar_no_warn = "";
 225     if (strncmp(rstar_no_warn, "yes", 3) != 0)
 226         warnx("%s, using standard rcp", s);
 227 }
 228
 229 static RETSIGTYPE
 230 lostconn(int signo)
 231 {
 232         if (!iamremote)
 233                 warnx("lost connection");
 234         exit(1);
 235 }
 236
 237 static int
 238 response(void)
 239 {
 240         char ch, *cp, resp, rbuf[BUFSIZ];
 241
 242         if (des_read(rem, &resp, sizeof(resp)) != sizeof(resp))
 243                 lostconn(0);
 244
 245         cp = rbuf;
 246         switch(resp) {
 247         case 0:                         /* ok */
 248                 return (0);
 249         default:
 250                 *cp++ = resp;
 251                 /* FALLTHROUGH */
 252         case 1:                         /* error, followed by error msg */
 253         case 2:                         /* fatal error, "" */
 254                 do {
 255                         if (des_read(rem, &ch, sizeof(ch)) != sizeof(ch))
 256                                 lostconn(0);
 257                         *cp++ = ch;
 258                 } while (cp < &rbuf[BUFSIZ] && ch != '\n');
 259
 260                 if (!iamremote)
 261                         write(STDERR_FILENO, rbuf, cp - rbuf);
 262                 ++errs;
 263                 if (resp == 1)
 264                         return (-1);
 265                 exit(1);
 266         }
 267         /* NOTREACHED */
 268 }
 269
 270 static void
 271 source(int argc, char **argv)
 272 {
 273         struct stat stb;
 274         static BUF buffer;
 275         BUF *bp;
 276         off_t i;
 277         int amt, fd, haderr, indx, result;
 278         char *last, *name, buf[BUFSIZ];
 279
 280         for (indx = 0; indx < argc; ++indx) {
 281                 name = argv[indx];
 282                 if ((fd = open(name, O_RDONLY, 0)) < 0)
 283                         goto syserr;
 284                 if (fstat(fd, &stb)) {
 285 syserr:                 run_err("%s: %s", name, strerror(errno));
 286                         goto next;
 287                 }
 288                 switch (stb.st_mode & S_IFMT) {
 289                 case S_IFREG:
 290                         break;
 291                 case S_IFDIR:
 292                         if (iamrecursive) {
 293                                 rsource(name, &stb);
 294                                 goto next;
 295                         }
 296                         /* FALLTHROUGH */
 297                 default:
 298                         run_err("%s: not a regular file", name);
 299                         goto next;
 300                 }
 301                 if ((last = strrchr(name, '/')) == NULL)
 302                         last = name;
 303                 else
 304                         ++last;
 305                 if (pflag) {
 306                         /*
 307                          * Make it compatible with possible future
 308                          * versions expecting microseconds.
 309                          */
 310                         snprintf(buf, sizeof(buf), "T%ld 0 %ld 0\n",
 311                             (long)stb.st_mtime, (long)stb.st_atime);
 312                         des_write(rem, buf, strlen(buf));
 313                         if (response() < 0)
 314                                 goto next;
 315                 }
 316                 snprintf(buf, sizeof(buf), "C%04o %ld %s\n",
 317                     (int)stb.st_mode & MODEMASK, (long) stb.st_size, last);
 318                 des_write(rem, buf, strlen(buf));
 319                 if (response() < 0)
 320                         goto next;
 321                 if ((bp = allocbuf(&buffer, fd, BUFSIZ)) == NULL) {
 322 next:                   close(fd);
 323                         continue;
 324                 }
 325
 326                 /* Keep writing after an error so that we stay sync'd up. */
 327                 for (haderr = i = 0; i < stb.st_size; i += bp->cnt) {
 328                         amt = bp->cnt;
 329                         if (i + amt > stb.st_size)
 330                                 amt = stb.st_size - i;
 331                         if (!haderr) {
 332                                 result = read(fd, bp->buf, amt);
 333                                 if (result != amt)
 334                                         haderr = result >= 0 ? EIO : errno;
 335                         }
 336                         if (haderr)
 337                                 des_write(rem, bp->buf, amt);
 338                         else {
 339                                 result = des_write(rem, bp->buf, amt);
 340                                 if (result != amt)
 341                                         haderr = result >= 0 ? EIO : errno;
 342                         }
 343                 }
 344                 if (close(fd) && !haderr)
 345                         haderr = errno;
 346                 if (!haderr)
 347                         des_write(rem, "", 1);
 348                 else
 349                         run_err("%s: %s", name, strerror(haderr));
 350                 response();
 351         }
 352 }
 353
 354 void
 355 rsource(char *name, struct stat *statp)
 356 {
 357         DIR *dirp;
 358         struct dirent *dp;
 359         char *last, *vect[1], path[MaxPathLen];
 360         char *p;
 361
 362         if (!(dirp = opendir(name))) {
 363                 run_err("%s: %s", name, strerror(errno));
 364                 return;
 365         }
 366         for (p = name + strlen(name) - 1; p >= name && *p == '/'; --p)
 367             *p = '\0';
 368
 369         last = strrchr(name, '/');
 370         if (last == 0)
 371                 last = name;
 372         else
 373                 last++;
 374         if (pflag) {
 375                 snprintf(path, sizeof(path), "T%ld 0 %ld 0\n",
 376                     (long)statp->st_mtime, (long)statp->st_atime);
 377                 des_write(rem, path, strlen(path));
 378                 if (response() < 0) {
 379                         closedir(dirp);
 380                         return;
 381                 }
 382         }
 383         snprintf(path, sizeof(path),
 384                  "D%04o %d %s\n", (int)statp->st_mode & MODEMASK, 0, last);
 385         des_write(rem, path, strlen(path));
 386         if (response() < 0) {
 387                 closedir(dirp);
 388                 return;
 389         }
 390         while ((dp = readdir(dirp))) {
 391                 if (dp->d_ino == 0)
 392                         continue;
 393                 if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
 394                         continue;
 395                 if (strlen(name) + 1 + strlen(dp->d_name) >= MaxPathLen - 1) {
 396                         run_err("%s/%s: name too long", name, dp->d_name);
 397                         continue;
 398                 }
 399                 if (snprintf(path, sizeof(path),
 400                              "%s/%s", name, dp->d_name) >= sizeof(path)) {
 401                         run_err("%s/%s: name too long", name, dp->d_name);
 402                         continue;
 403                 }
 404                 vect[0] = path;
 405                 source(1, vect);
 406         }
 407         closedir(dirp);
 408         des_write(rem, "E\n", 2);
 409         response();
 410 }
 411
 412 static int
 413 kerberos(char **host, char *bp, char *locuser, char *user)
 414 {
 415         int sock = -1, err;
 416
 417         if (use_kerberos) {
 418                 paranoid_setuid(getuid());
 419                 rem = KSUCCESS;
 420                 errno = 0;
 421                 if (dest_realm == NULL)
 422                         dest_realm = krb_realmofhost(*host);
 423
 424 #if 0
 425                 rem = krcmd(host, port, user, bp, 0, dest_realm);
 426 #else
 427                 err = kcmd(
 428                     &sock,
 429                     host,
 430                     port,
 431                     NULL,       /* locuser not used */
 432                     user,
 433                     bp,
 434                     0,
 435                     &ticket,
 436                     SERVICE_NAME,
 437                     dest_realm,
 438                     (CREDENTIALS *) NULL, /* credentials not used */
 439                     0,          /* key schedule not used */
 440                     (MSG_DAT *) NULL, /* MSG_DAT not used */
 441                     (struct sockaddr_in *) NULL, /* local addr not used */
 442                     (struct sockaddr_in *) NULL, /* foreign addr not used */
 443                     0L);        /* authopts */
 444                 if (err > KSUCCESS && err < MAX_KRB_ERRORS) {
 445                     warnx("kcmd: %s", krb_get_err_text(err));
 446                     rem = -1;
 447                 } else if (err < 0)
 448                     rem = -1;
 449                 else
 450                     rem = sock;
 451 #endif
 452                 if (rem < 0) {
 453                         if (errno == ECONNREFUSED)
 454                             oldw("remote host doesn't support Kerberos");
 455                         else if (errno == ENOENT)
 456                             oldw("can't provide Kerberos authentication data");
 457                         execv(_PATH_RCP, argv_copy);
 458                 }
 459         } else {
 460                 if (doencrypt)
 461                         errx(1,
 462                            "the -x option requires Kerberos authentication");
 463                 if (geteuid() != 0) {
 464                     errx(1, "not installed setuid root, "
 465                          "only root may use non kerberized rcp");
 466                 }
 467                 rem = rcmd(host, port, locuser, user, bp, 0);
 468         }
 469         return (rem);
 470 }
 471
 472 static void
 473 toremote(char *targ, int argc, char **argv)
 474 {
 475         int i, len;
 476 #ifdef IP_TOS
 477         int tos;
 478 #endif
 479         char *bp, *host, *src, *suser, *thost, *tuser;
 480
 481         *targ++ = 0;
 482         if (*targ == 0)
 483                 targ = ".";
 484
 485         if ((thost = strchr(argv[argc - 1], '@'))) {
 486                 /* user@host */
 487                 *thost++ = 0;
 488                 tuser = argv[argc - 1];
 489                 if (*tuser == '\0')
 490                         tuser = NULL;
 491                 else if (!okname(tuser))
 492                         exit(1);
 493         } else {
 494                 thost = argv[argc - 1];
 495                 tuser = user_name;
 496         }
 497
 498         for (i = 0; i < argc - 1; i++) {
 499                 src = colon(argv[i]);
 500                 if (src) {                      /* remote to remote */
 501                         *src++ = 0;
 502                         if (*src == 0)
 503                                 src = ".";
 504                         host = strchr(argv[i], '@');
 505                         if (host) {
 506                             *host++ = 0;
 507                             suser = argv[i];
 508                             if (*suser == '\0')
 509                                 suser = pwd->pw_name;
 510                             else if (!okname(suser))
 511                                 continue;
 512                             asprintf(&bp, "%s %s -l %s -n %s %s '%s%s%s:%s'",
 513                                      _PATH_RSH, host, suser, cmd, src,
 514                                      tuser ? tuser : "", tuser ? "@" : "",
 515                                      thost, targ);
 516                         } else
 517                             asprintf(&bp, "exec %s %s -n %s %s '%s%s%s:%s'",
 518                                      _PATH_RSH, argv[i], cmd, src,
 519                                      tuser ? tuser : "", tuser ? "@" : "",
 520                                      thost, targ);
 521                         if(bp == NULL)
 522                             errx(1, "out of memory");
 523                         susystem(bp, userid);
 524                         free(bp);
 525                 } else {                        /* local to remote */
 526                         if (rem == -1) {
 527                                 len = strlen(targ) + CMDNEEDS + 20;
 528                                 if (!(bp = malloc(len)))
 529                                         err(1, " ");
 530                                 snprintf(bp, len, "%s -t %s", cmd, targ);
 531                                 host = thost;
 532                                 if (use_kerberos)
 533                                         rem = kerberos(&host, bp,
 534 #ifdef __CYGWIN32__
 535                                                        tuser,
 536 #else
 537                                             pwd->pw_name,
 538 #endif
 539                                             tuser ? tuser : pwd->pw_name);
 540                                 else
 541                                         rem = rcmd(&host, port,
 542 #ifdef __CYGWIN32__
 543                                                    tuser,
 544 #else
 545                                                    pwd->pw_name,
 546 #endif
 547                                             tuser ? tuser : pwd->pw_name,
 548                                             bp, 0);
 549                                 if (rem < 0)
 550                                         exit(1);
 551 #if defined(IP_TOS) && defined(HAVE_SETSOCKOPT)
 552                                 tos = IPTOS_THROUGHPUT;
 553                                 if (setsockopt(rem, IPPROTO_IP, IP_TOS,
 554                                     (void *)&tos, sizeof(int)) < 0)
 555                                         warn("TOS (ignored)");
 556 #endif /* IP_TOS */
 557                                 if (doencrypt)
 558                                     send_auth(host, dest_realm);
 559                                 if (response() < 0)
 560                                         exit(1);
 561                                 free(bp);
 562                                 paranoid_setuid(userid);
 563                         }
 564                         source(1, argv+i);
 565                 }
 566         }
 567 }
 568
 569 static void
 570 sink(int argc, char **argv)
 571 {
 572         static BUF buffer;
 573         struct stat stb;
 574         struct timeval tv[2];
 575         enum { YES, NO, DISPLAYED } wrerr;
 576         BUF *bp;
 577         off_t i, j;
 578         int amt, count, exists, first, mask, mode, ofd, omode;
 579         int setimes, size, targisdir, wrerrno=0;
 580         char ch, *cp, *np, *targ, *why, *vect[1], buf[BUFSIZ];
 581
 582 #define atime   tv[0]
 583 #define mtime   tv[1]
 584 #define SCREWUP(str)    { why = str; goto screwup; }
 585
 586         setimes = targisdir = 0;
 587         mask = umask(0);
 588         if (!pflag)
 589                 umask(mask);
 590         if (argc != 1) {
 591                 run_err("ambiguous target");
 592                 exit(1);
 593         }
 594         targ = *argv;
 595         if (targetshouldbedirectory)
 596                 verifydir(targ);
 597         des_write(rem, "", 1);
 598         if (stat(targ, &stb) == 0 && S_ISDIR(stb.st_mode))
 599                 targisdir = 1;
 600         for (first = 1;; first = 0) {
 601                 cp = buf;
 602                 if (des_read(rem, cp, 1) <= 0)
 603                         return;
 604                 if (*cp++ == '\n')
 605                         SCREWUP("unexpected <newline>");
 606                 do {
 607                         if (des_read(rem, &ch, sizeof(ch)) != sizeof(ch))
 608                                 SCREWUP("lost connection");
 609                         *cp++ = ch;
 610                 } while (cp < &buf[BUFSIZ - 1] && ch != '\n');
 611                 *cp = 0;
 612
 613                 if (buf[0] == '\01' || buf[0] == '\02') {
 614                         if (iamremote == 0)
 615                                 write(STDERR_FILENO,
 616                                     buf + 1, strlen(buf + 1));
 617                         if (buf[0] == '\02')
 618                                 exit(1);
 619                         ++errs;
 620                         continue;
 621                 }
 622                 if (buf[0] == 'E') {
 623                         des_write(rem, "", 1);
 624                         return;
 625                 }
 626
 627                 if (ch == '\n')
 628                         *--cp = 0;
 629
 630 #define getnum(t)                                       \
 631                 do {                                    \
 632                     (t) = 0;                            \
 633                     while (isdigit((unsigned char)*cp)) \
 634                         (t) = (t) * 10 + (*cp++ - '0'); \
 635                 } while(0)
 636
 637                 cp = buf;
 638                 if (*cp == 'T') {
 639                         setimes++;
 640                         cp++;
 641                         getnum(mtime.tv_sec);
 642                         if (*cp++ != ' ')
 643                                 SCREWUP("mtime.sec not delimited");
 644                         getnum(mtime.tv_usec);
 645                         if (*cp++ != ' ')
 646                                 SCREWUP("mtime.usec not delimited");
 647                         getnum(atime.tv_sec);
 648                         if (*cp++ != ' ')
 649                                 SCREWUP("atime.sec not delimited");
 650                         getnum(atime.tv_usec);
 651                         if (*cp++ != '\0')
 652                                 SCREWUP("atime.usec not delimited");
 653                         des_write(rem, "", 1);
 654                         continue;
 655                 }
 656                 if (*cp != 'C' && *cp != 'D') {
 657                         /*
 658                          * Check for the case "rcp remote:foo\* local:bar".
 659                          * In this case, the line "No match." can be returned
 660                          * by the shell before the rcp command on the remote is
 661                          * executed so the ^Aerror_message convention isn't
 662                          * followed.
 663                          */
 664                         if (first) {
 665                                 run_err("%s", cp);
 666                                 exit(1);
 667                         }
 668                         SCREWUP("expected control record");
 669                 }
 670                 mode = 0;
 671                 for (++cp; cp < buf + 5; cp++) {
 672                         if (*cp < '0' || *cp > '7')
 673                                 SCREWUP("bad mode");
 674                         mode = (mode << 3) | (*cp - '0');
 675                 }
 676                 if (*cp++ != ' ')
 677                         SCREWUP("mode not delimited");
 678
 679                 for (size = 0; isdigit((unsigned char)*cp);)
 680                         size = size * 10 + (*cp++ - '0');
 681                 if (*cp++ != ' ')
 682                         SCREWUP("size not delimited");
 683                 if (targisdir) {
 684                         static char *namebuf;
 685                         static int cursize;
 686                         size_t need;
 687
 688                         need = strlen(targ) + strlen(cp) + 250;
 689                         if (need > cursize) {
 690                                 if (!(namebuf = malloc(need)))
 691                                         run_err("%s", strerror(errno));
 692                         }
 693                         snprintf(namebuf, need, "%s%s%s", targ,
 694                             *targ ? "/" : "", cp);
 695                         np = namebuf;
 696                 } else
 697                         np = targ;
 698                 exists = stat(np, &stb) == 0;
 699                 if (buf[0] == 'D') {
 700                         int mod_flag = pflag;
 701                         if (exists) {
 702                                 if (!S_ISDIR(stb.st_mode)) {
 703                                         errno = ENOTDIR;
 704                                         goto bad;
 705                                 }
 706                                 if (pflag)
 707                                         chmod(np, mode);
 708                         } else {
 709                                 /* Handle copying from a read-only directory */
 710                                 mod_flag = 1;
 711                                 if (mkdir(np, mode | S_IRWXU) < 0)
 712                                         goto bad;
 713                         }
 714                         vect[0] = np;
 715                         sink(1, vect);
 716                         if (setimes) {
 717                                 struct utimbuf times;
 718                                 times.actime = atime.tv_sec;
 719                                 times.modtime = mtime.tv_sec;
 720                                 setimes = 0;
 721                                 if (utime(np, &times) < 0)
 722                                     run_err("%s: set times: %s",
 723                                             np, strerror(errno));
 724                         }
 725                         if (mod_flag)
 726                                 chmod(np, mode);
 727                         continue;
 728                 }
 729                 omode = mode;
 730                 mode |= S_IWRITE;
 731                 if ((ofd = open(np, O_WRONLY|O_CREAT, mode)) < 0) {
 732 bad:                    run_err("%s: %s", np, strerror(errno));
 733                         continue;
 734                 }
 735                 des_write(rem, "", 1);
 736                 if ((bp = allocbuf(&buffer, ofd, BUFSIZ)) == NULL) {
 737                         close(ofd);
 738                         continue;
 739                 }
 740                 cp = bp->buf;
 741                 wrerr = NO;
 742                 for (count = i = 0; i < size; i += BUFSIZ) {
 743                         amt = BUFSIZ;
 744                         if (i + amt > size)
 745                                 amt = size - i;
 746                         count += amt;
 747                         do {
 748                                 j = des_read(rem, cp, amt);
 749                                 if (j <= 0) {
 750                                         run_err("%s", j ? strerror(errno) :
 751                                                 "dropped connection");
 752                                         exit(1);
 753                                 }
 754                                 amt -= j;
 755                                 cp += j;
 756                         } while (amt > 0);
 757                         if (count == bp->cnt) {
 758                                 /* Keep reading so we stay sync'd up. */
 759                                 if (wrerr == NO) {
 760                                         j = write(ofd, bp->buf, count);
 761                                         if (j != count) {
 762                                                 wrerr = YES;
 763                                                 wrerrno = j >= 0 ? EIO : errno;
 764                                         }
 765                                 }
 766                                 count = 0;
 767                                 cp = bp->buf;
 768                         }
 769                 }
 770                 if (count != 0 && wrerr == NO &&
 771                     (j = write(ofd, bp->buf, count)) != count) {
 772                         wrerr = YES;
 773                         wrerrno = j >= 0 ? EIO : errno;
 774                 }
 775                 if (ftruncate(ofd, size)) {
 776                         run_err("%s: truncate: %s", np, strerror(errno));
 777                         wrerr = DISPLAYED;
 778                 }
 779                 if (pflag) {
 780                         if (exists || omode != mode)
 781 #ifdef HAVE_FCHMOD
 782                                 if (fchmod(ofd, omode))
 783 #else
 784                                 if (chmod(np, omode))
 785 #endif
 786                                         run_err("%s: set mode: %s",
 787                                                 np, strerror(errno));
 788                 } else {
 789                         if (!exists && omode != mode)
 790 #ifdef HAVE_FCHMOD
 791                                 if (fchmod(ofd, omode & ~mask))
 792 #else
 793                                 if (chmod(np, omode & ~mask))
 794 #endif
 795                                         run_err("%s: set mode: %s",
 796                                                 np, strerror(errno));
 797                 }
 798                 close(ofd);
 799                 response();
 800                 if (setimes && wrerr == NO) {
 801                         struct utimbuf times;
 802                         times.actime = atime.tv_sec;
 803                         times.modtime = mtime.tv_sec;
 804                         setimes = 0;
 805                         if (utime(np, &times) < 0) {
 806                                 run_err("%s: set times: %s",
 807                                         np, strerror(errno));
 808                                 wrerr = DISPLAYED;
 809                         }
 810                 }
 811                 switch(wrerr) {
 812                 case YES:
 813                         run_err("%s: %s", np, strerror(wrerrno));
 814                         break;
 815                 case NO:
 816                         des_write(rem, "", 1);
 817                         break;
 818                 case DISPLAYED:
 819                         break;
 820                 }
 821         }
 822 screwup:
 823         run_err("protocol error: %s", why);
 824         exit(1);
 825 }
 826
 827 static void
 828 tolocal(int argc, char **argv)
 829 {
 830         int i, len;
 831 #ifdef IP_TOS
 832         int tos;
 833 #endif
 834         char *bp, *host, *src, *suser;
 835
 836         for (i = 0; i < argc - 1; i++) {
 837                 if (!(src = colon(argv[i]))) {          /* Local to local. */
 838                         len = strlen(_PATH_CP) + strlen(argv[i]) +
 839                             strlen(argv[argc - 1]) + 20;
 840                         if (!(bp = malloc(len)))
 841                                 err(1, " ");
 842                         snprintf(bp, len, "exec %s%s%s %s %s", _PATH_CP,
 843                                  iamrecursive ? " -r" : "", pflag ? " -p" : "",
 844                                  argv[i], argv[argc - 1]);
 845                         if (susystem(bp, userid))
 846                                 ++errs;
 847                         free(bp);
 848                         continue;
 849                 }
 850                 *src++ = 0;
 851                 if (*src == 0)
 852                         src = ".";
 853                 if ((host = strchr(argv[i], '@')) == NULL) {
 854 #ifdef __CYGWIN32__
 855                         errx (1, "Sorry, you need to specify the username");
 856 #else
 857                         host = argv[i];
 858                         suser = pwd->pw_name;
 859                         if (user_name)
 860                             suser = user_name;
 861 #endif
 862                 } else {
 863                         *host++ = 0;
 864                         suser = argv[i];
 865                         if (*suser == '\0')
 866 #ifdef __CYGWIN32__
 867                         errx (1, "Sorry, you need to specify the username");
 868 #else
 869                                 suser = pwd->pw_name;
 870 #endif
 871                         else if (!okname(suser))
 872                                 continue;
 873                 }
 874                 len = strlen(src) + CMDNEEDS + 20;
 875                 if ((bp = malloc(len)) == NULL)
 876                         err(1, " ");
 877                 snprintf(bp, len, "%s -f %s", cmd, src);
 878                 rem =
 879                     use_kerberos ?
 880                         kerberos(&host, bp,
 881 #ifndef __CYGWIN32__
 882                                  pwd->pw_name,
 883 #else
 884                                  suser,
 885 #endif
 886                                  suser) :
 887                         rcmd(&host, port,
 888 #ifndef __CYGWIN32__
 889                              pwd->pw_name,
 890 #else
 891                              suser,
 892 #endif
 893                              suser, bp, 0);
 894                 free(bp);
 895                 if (rem < 0) {
 896                         ++errs;
 897                         continue;
 898                 }
 899                 seteuid(userid);
 900 #if defined(IP_TOS) && defined(HAVE_SETSOCKOPT)
 901                 tos = IPTOS_THROUGHPUT;
 902                 if (setsockopt(rem, IPPROTO_IP, IP_TOS, (void *)&tos,
 903                                sizeof(int)) < 0)
 904                         warn("TOS (ignored)");
 905 #endif /* IP_TOS */
 906                 if (doencrypt)
 907                         send_auth(host, dest_realm);
 908                 sink(1, argv + argc - 1);
 909                 seteuid(0);
 910                 close(rem);
 911                 rem = -1;
 912         }
 913 }
 914
 915
 916 int
 917 main(int argc, char **argv)
 918 {
 919         int ch, fflag, tflag;
 920         char *targ;
 921         int i;
 922
 923         set_progname(argv[0]);
 924
 925         /*
 926          * Prepare for execing ourselves.
 927          */
 928
 929         argc_copy = argc + 1;
 930         argv_copy = malloc((argc_copy + 1) * sizeof(*argv_copy));
 931         if (argv_copy == NULL)
 932             err(1, "malloc");
 933         argv_copy[0] = argv[0];
 934         argv_copy[1] = "-K";
 935         for(i = 1; i < argc; ++i) {
 936             argv_copy[i + 1] = strdup(argv[i]);
 937             if (argv_copy[i + 1] == NULL)
 938                 errx(1, "strdup: out of memory");
 939         }
 940         argv_copy[argc + 1] = NULL;
 941
 942
 943         fflag = tflag = 0;
 944         while ((ch = getopt(argc, argv, OPTIONS)) != -1)
 945                 switch(ch) {                    /* User-visible flags. */
 946                 case 'K':
 947                         use_kerberos = 0;
 948                         break;
 949                 case 'k':
 950                         dest_realm = dst_realm_buf;
 951                         strlcpy(dst_realm_buf, optarg, REALM_SZ);
 952                         break;
 953                 case 'x':
 954                         doencrypt = 1;
 955                         LEFT_JUSTIFIED = 1;
 956                         break;
 957                 case 'p':
 958                         pflag = 1;
 959                         break;
 960                 case 'r':
 961                         iamrecursive = 1;
 962                         break;
 963                                                 /* Server options. */
 964                 case 'd':
 965                         targetshouldbedirectory = 1;
 966                         break;
 967                 case 'f':                       /* "from" */
 968                         iamremote = 1;
 969                         fflag = 1;
 970                         break;
 971                 case 't':                       /* "to" */
 972                         iamremote = 1;
 973                         tflag = 1;
 974                         break;
 975                 case 'l':
 976                         user_name = optarg;
 977                         break;
 978                 case '?':
 979                 default:
 980                         usage();
 981                 }
 982         argc -= optind;
 983         argv += optind;
 984
 985         /* Rcp implements encrypted file transfer without using the
 986          * kshell service, pass 0 for no encryption */
 987         port = get_shell_port(use_kerberos, 0);
 988
 989         userid = getuid();
 990
 991 #ifndef __CYGWIN32__
 992         if ((pwd = k_getpwuid(userid)) == NULL)
 993                 errx(1, "unknown user %d", (int)userid);
 994 #endif
 995
 996         rem = STDIN_FILENO;             /* XXX */
 997
 998         if (fflag || tflag) {
 999             if (doencrypt)
1000                 answer_auth();
1001             if(fflag)
1002                 response();
1003             if(do_osfc2_magic(pwd->pw_uid))
1004                 exit(1);
1005             paranoid_setuid(userid);
1006             if (k_hasafs()) {
1007                 /* Sometimes we will need cell specific tokens
1008                  * to be able to read and write files, thus,
1009                  * the token stuff done in rshd might not
1010                  * suffice.
1011                  */
1012                 char cell[64];
1013                 if (k_afs_cell_of_file(pwd->pw_dir,
1014                                        cell, sizeof(cell)) == 0)
1015                     krb_afslog(cell, 0);
1016                 krb_afslog(0, 0);
1017             }
1018             if(fflag)
1019                 source(argc, argv);
1020             else
1021                 sink(argc, argv);
1022             exit(errs);
1023         }
1024
1025         if (argc < 2)
1026                 usage();
1027         if (argc > 2)
1028                 targetshouldbedirectory = 1;
1029
1030         rem = -1;
1031         /* Command to be executed on remote system using "rsh". */
1032         snprintf(cmd, sizeof(cmd),
1033                  "rcp%s%s%s%s", iamrecursive ? " -r" : "",
1034                  (doencrypt && use_kerberos ? " -x" : ""),
1035                  pflag ? " -p" : "", targetshouldbedirectory ? " -d" : "");
1036
1037         signal(SIGPIPE, lostconn);
1038
1039         if ((targ = colon(argv[argc - 1])))     /* Dest is remote host. */
1040                 toremote(targ, argc, argv);
1041         else {
1042                 tolocal(argc, argv);            /* Dest is local host. */
1043                 if (targetshouldbedirectory)
1044                         verifydir(argv[argc - 1]);
1045         }
1046         exit(errs);
1047 }