X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/484310255a9b00469158262f7a59f14f0b3f232d..8c20c4b329cc491b7faef0defe1b445ca73dd482:/usr/src/bin/rcp/rcp.c

diff --git a/usr/src/bin/rcp/rcp.c b/usr/src/bin/rcp/rcp.c
index be5cdbac72..0d15b68e41 100644
--- a/usr/src/bin/rcp/rcp.c
+++ b/usr/src/bin/rcp/rcp.c
@@ -1,18 +1,45 @@
 /*
- * Copyright (c) 1983 Regents of the University of California.
- * All rights reserved.  The Berkeley software License Agreement
- * specifies the terms and conditions for redistribution.
+ * Copyright (c) 1983, 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
  */
 
 #ifndef lint
 char copyright[] =
-"@(#) Copyright (c) 1983 Regents of the University of California.\n\
+"@(#) Copyright (c) 1983, 1990 The Regents of the University of California.\n\
  All rights reserved.\n";
-#endif not lint
+#endif /* not lint */
 
 #ifndef lint
-static char sccsid[] = "@(#)rcp.c	5.6 (Berkeley) %G%";
-#endif not lint
+static char sccsid[] = "@(#)rcp.c	5.32 (Berkeley) 2/25/91";
+#endif /* not lint */
 
 /*
  * rcp
@@ -21,206 +48,339 @@ static char sccsid[] = "@(#)rcp.c	5.6 (Berkeley) %G%";
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/ioctl.h>
-
+#include <sys/socket.h>
+#include <sys/wait.h>
 #include <netinet/in.h>
-
-#include <stdio.h>
+#include <netinet/in_systm.h>
+#include <netinet/ip.h>
+#include <dirent.h>
+#include <fcntl.h>
 #include <signal.h>
 #include <pwd.h>
-#include <ctype.h>
 #include <netdb.h>
 #include <errno.h>
-
-int	rem;
-char	*colon(), *index(), *rindex(), *malloc(), *strcpy(), *sprintf();
-int	errs;
-int	lostconn();
-int	errno;
-char	*sys_errlist[];
-int	iamremote, targetshouldbedirectory;
-int	iamrecursive;
-int	pflag;
-struct	passwd *pwd;
-struct	passwd *getpwuid();
-int	userid;
-int	port;
-
-struct buffer {
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include "pathnames.h"
+
+#ifdef KERBEROS
+#include <kerberosIV/des.h>
+#include <kerberosIV/krb.h>
+char	dst_realm_buf[REALM_SZ];
+char	*dest_realm = NULL;
+int	use_kerberos = 1;
+CREDENTIALS 	cred;
+Key_schedule	schedule;
+extern	char	*krb_realmofhost();
+#ifdef CRYPT
+int	doencrypt = 0;
+#define	OPTIONS	"dfk:prtx"
+#else
+#define	OPTIONS	"dfk:prt"
+#endif
+#else
+#define	OPTIONS "dfprt"
+#endif
+
+struct passwd *pwd;
+u_short	port;
+uid_t	userid;
+int errs, rem;
+int pflag, iamremote, iamrecursive, targetshouldbedirectory;
+
+#define	CMDNEEDS	64
+char cmd[CMDNEEDS];		/* must hold "rcp -r -p -d\0" */
+
+typedef struct _buf {
 	int	cnt;
 	char	*buf;
-} *allocbuf();
+} BUF;
 
-/*VARARGS*/
-int	error();
-
-#define	ga()	 	(void) write(rem, "", 1)
+void lostconn();
 
 main(argc, argv)
 	int argc;
 	char **argv;
 {
-	char *targ, *host, *src;
-	char *suser, *tuser, *thost;
-	int i;
-	char buf[BUFSIZ], cmd[16];
+	extern int optind;
+	extern char *optarg;
 	struct servent *sp;
+	int ch, fflag, tflag;
+	char *targ, *shell, *colon();
+
+	fflag = tflag = 0;
+	while ((ch = getopt(argc, argv, OPTIONS)) != EOF)
+		switch(ch) {
+		/* user-visible flags */
+		case 'p':			/* preserve access/mod times */
+			++pflag;
+			break;
+		case 'r':
+			++iamrecursive;
+			break;
+#ifdef	KERBEROS
+		case 'k':
+			strncpy(dst_realm_buf, optarg, REALM_SZ);
+			dest_realm = dst_realm_buf;
+			break;
+#ifdef CRYPT
+		case 'x':
+			doencrypt = 1;
+			/* des_set_key(cred.session, schedule); */
+			break;
+#endif
+#endif
+		/* rshd-invoked options (server) */
+		case 'd':
+			targetshouldbedirectory = 1;
+			break;
+		case 'f':			/* "from" */
+			iamremote = 1;
+			fflag = 1;
+			break;
+		case 't':			/* "to" */
+			iamremote = 1;
+			tflag = 1;
+			break;
 
-	sp = getservbyname("shell", "tcp");
+		case '?':
+		default:
+			usage();
+		}
+	argc -= optind;
+	argv += optind;
+
+#ifdef KERBEROS
+#ifdef CRYPT
+	shell = doencrypt ? "ekshell" : "kshell";
+#else
+	shell = "kshell";
+#endif
+	sp = getservbyname(shell, "tcp");
+	if (sp == NULL) {
+		char	msgbuf[64];
+		use_kerberos = 0;
+		(void)snprintf(msgbuf, sizeof(msgbuf),
+		    "can't get entry for %s/tcp service", shell);
+		old_warning(msgbuf);
+		sp = getservbyname(shell = "shell", "tcp");
+	}
+#else
+	sp = getservbyname(shell = "shell", "tcp");
+#endif
 	if (sp == NULL) {
-		fprintf(stderr, "rcp: shell/tcp: unknown service\n");
+		(void)fprintf(stderr, "rcp: %s/tcp: unknown service\n", shell);
 		exit(1);
 	}
 	port = sp->s_port;
-	pwd = getpwuid(userid = getuid());
-	if (pwd == 0) {
-		fprintf(stderr, "who are you?\n");
+
+	if (!(pwd = getpwuid(userid = getuid()))) {
+		(void)fprintf(stderr, "rcp: unknown user %d.\n", (int)userid);
 		exit(1);
 	}
 
-	for (argc--, argv++; argc > 0 && **argv == '-'; argc--, argv++) {
-		(*argv)++;
-		while (**argv) switch (*(*argv)++) {
+	if (fflag) {
+		/* follow "protocol", send data */
+		(void)response();
+		(void)setuid(userid);
+		source(argc, argv);
+		exit(errs);
+	}
 
-		    case 'r':
-			iamrecursive++;
-			break;
+	if (tflag) {
+		/* receive data */
+		(void)setuid(userid);
+		sink(argc, argv);
+		exit(errs);
+	}
 
-		    case 'p':		/* preserve mtimes and atimes */
-			pflag++;
-			break;
+	if (argc < 2)
+		usage();
+	if (argc > 2)
+		targetshouldbedirectory = 1;
 
-		    /* The rest of these are not for users. */
-		    case 'd':
-			targetshouldbedirectory = 1;
-			break;
+	rem = -1;
+	/* command to be executed on remote system using "rsh" */
+#ifdef	KERBEROS
+	(void)snprintf(cmd, sizeof(cmd),
+	    "rcp%s%s%s%s", iamrecursive ? " -r" : "",
+#ifdef CRYPT
+	    ((doencrypt && use_kerberos) ? " -x" : ""),
+#else
+	    "",
+#endif
+	    pflag ? " -p" : "", targetshouldbedirectory ? " -d" : "");
+#else
+	(void)snprintf(cmd, sizeof(cmd), "rcp%s%s%s",
+	    iamrecursive ? " -r" : "", pflag ? " -p" : "",
+	    targetshouldbedirectory ? " -d" : "");
+#endif
 
-		    case 'f':		/* "from" */
-			iamremote = 1;
-			(void) response();
-			(void) setuid(userid);
-			source(--argc, ++argv);
-			exit(errs);
+	(void)signal(SIGPIPE, lostconn);
 
-		    case 't':		/* "to" */
-			iamremote = 1;
-			(void) setuid(userid);
-			sink(--argc, ++argv);
-			exit(errs);
+	if (targ = colon(argv[argc - 1]))
+		toremote(targ, argc, argv);	/* destination is remote host */
+	else {
+		tolocal(argc, argv);		/* destination is local host */
+		if (targetshouldbedirectory)
+			verifydir(argv[argc - 1]);
+	}
+	exit(errs);
+}
 
-		    default:
-			fprintf(stderr,
-		"Usage: rcp [-p] f1 f2; or: rcp [-rp] f1 ... fn d2\n");
+toremote(targ, argc, argv)
+	char *targ;
+	int argc;
+	char **argv;
+{
+	int i, len, tos;
+	char *bp, *host, *src, *suser, *thost, *tuser;
+	char *colon();
+
+	*targ++ = 0;
+	if (*targ == 0)
+		targ = ".";
+
+	if (thost = index(argv[argc - 1], '@')) {
+		/* user@host */
+		*thost++ = 0;
+		tuser = argv[argc - 1];
+		if (*tuser == '\0')
+			tuser = NULL;
+		else if (!okname(tuser))
 			exit(1);
-		}
+	} else {
+		thost = argv[argc - 1];
+		tuser = NULL;
 	}
-	rem = -1;
-	if (argc > 2)
-		targetshouldbedirectory = 1;
-	(void) sprintf(cmd, "rcp%s%s%s",
-	    iamrecursive ? " -r" : "", pflag ? " -p" : "", 
-	    targetshouldbedirectory ? " -d" : "");
-	(void) signal(SIGPIPE, lostconn);
-	targ = colon(argv[argc - 1]);
-	if (targ) {				/* ... to remote */
-		*targ++ = 0;
-		if (*targ == 0)
-			targ = ".";
-		thost = index(argv[argc - 1], '@');
-		if (thost) {
-			*thost++ = 0;
-			tuser = argv[argc - 1];
-			if (*tuser == '\0')
-				tuser = NULL;
-			else if (!okname(tuser))
-				exit(1);
-		} else {
-			thost = argv[argc - 1];
-			tuser = NULL;
-		}
-		for (i = 0; i < argc - 1; i++) {
-			src = colon(argv[i]);
-			if (src) {		/* remote to remote */
-				*src++ = 0;
-				if (*src == 0)
-					src = ".";
-				host = index(argv[i], '@');
-				if (host) {
-					*host++ = 0;
-					suser = argv[i];
-					if (*suser == '\0')
-						suser = pwd->pw_name;
-					else if (!okname(suser))
-						continue;
-		(void) sprintf(buf, "/usr/ucb/rsh %s -l %s -n %s %s '%s%s%s:%s'",
-					    host, suser, cmd, src,
-					    tuser ? tuser : "",
-					    tuser ? "@" : "",
-					    thost, targ);
-				} else
-		(void) sprintf(buf, "/usr/ucb/rsh %s -n %s %s '%s%s%s:%s'",
-					    argv[i], cmd, src,
-					    tuser ? tuser : "",
-					    tuser ? "@" : "",
-					    thost, targ);
-				(void) susystem(buf);
-			} else {		/* local to remote */
-				if (rem == -1) {
-					(void) sprintf(buf, "%s -t %s",
-					    cmd, targ);
-					host = thost;
+
+	for (i = 0; i < argc - 1; i++) {
+		src = colon(argv[i]);
+		if (src) {			/* remote to remote */
+			*src++ = 0;
+			if (*src == 0)
+				src = ".";
+			host = index(argv[i], '@');
+			len = strlen(_PATH_RSH) + strlen(argv[i]) +
+			    strlen(src) + (tuser ? strlen(tuser) : 0) +
+			    strlen(thost) + strlen(targ) + CMDNEEDS + 20;
+			if (!(bp = malloc(len)))
+				nospace();
+			if (host) {
+				*host++ = 0;
+				suser = argv[i];
+				if (*suser == '\0')
+					suser = pwd->pw_name;
+				else if (!okname(suser))
+					continue;
+				(void)snprintf(bp, len,
+				    "%s %s -l %s -n %s %s '%s%s%s:%s'",
+				    _PATH_RSH, host, suser, cmd, src,
+				    tuser ? tuser : "", tuser ? "@" : "",
+				    thost, targ);
+			} else
+				(void)snprintf(bp, len,
+				    "%s %s -n %s %s '%s%s%s:%s'",
+				    _PATH_RSH, argv[i], cmd, src,
+				    tuser ? tuser : "", tuser ? "@" : "",
+				    thost, targ);
+			(void)susystem(bp);
+			(void)free(bp);
+		} else {			/* local to remote */
+			if (rem == -1) {
+				len = strlen(targ) + CMDNEEDS + 20;
+				if (!(bp = malloc(len)))
+					nospace();
+				(void)snprintf(bp, len, "%s -t %s", cmd, targ);
+				host = thost;
+#ifdef KERBEROS
+				if (use_kerberos)
+					rem = kerberos(&host, bp,
+					    pwd->pw_name,
+					    tuser ? tuser : pwd->pw_name);
+				else
+#endif
 					rem = rcmd(&host, port, pwd->pw_name,
 					    tuser ? tuser : pwd->pw_name,
-					    buf, 0);
-					if (rem < 0)
-						exit(1);
-					if (response() < 0)
-						exit(1);
-					(void) setuid(userid);
-				}
-				source(1, argv+i);
-			}
-		}
-	} else {				/* ... to local */
-		if (targetshouldbedirectory)
-			verifydir(argv[argc - 1]);
-		for (i = 0; i < argc - 1; i++) {
-			src = colon(argv[i]);
-			if (src == 0) {		/* local to local */
-				(void) sprintf(buf, "/bin/cp%s%s %s %s",
-				    iamrecursive ? " -r" : "",
-				    pflag ? " -p" : "",
-				    argv[i], argv[argc - 1]);
-				(void) susystem(buf);
-			} else {		/* remote to local */
-				*src++ = 0;
-				if (*src == 0)
-					src = ".";
-				host = index(argv[i], '@');
-				if (host) {
-					*host++ = 0;
-					suser = argv[i];
-					if (*suser == '\0')
-						suser = pwd->pw_name;
-					else if (!okname(suser))
-						continue;
-				} else {
-					host = argv[i];
-					suser = pwd->pw_name;
-				}
-				(void) sprintf(buf, "%s -f %s", cmd, src);
-				rem = rcmd(&host, port, pwd->pw_name, suser,
-				    buf, 0);
+					    bp, 0);
 				if (rem < 0)
-					continue;
-				(void) setreuid(0, userid);
-				sink(1, argv+argc-1);
-				(void) setreuid(userid, 0);
-				(void) close(rem);
-				rem = -1;
+					exit(1);
+				tos = IPTOS_THROUGHPUT;
+				if (setsockopt(rem, IPPROTO_IP, IP_TOS,
+				    (char *)&tos, sizeof(int)) < 0)
+					perror("rcp: setsockopt TOS (ignored)");
+				if (response() < 0)
+					exit(1);
+				(void)free(bp);
+				(void)setuid(userid);
 			}
+			source(1, argv+i);
 		}
 	}
-	exit(errs);
+}
+
+tolocal(argc, argv)
+	int argc;
+	char **argv;
+{
+	int i, len, tos;
+	char *bp, *host, *src, *suser;
+	char *colon();
+
+	for (i = 0; i < argc - 1; i++) {
+		if (!(src = colon(argv[i]))) {	/* local to local */
+			len = strlen(_PATH_CP) + strlen(argv[i]) +
+			    strlen(argv[argc - 1]) + 20;
+			if (!(bp = malloc(len)))
+				nospace();
+			(void)snprintf(bp, len, "%s%s%s %s %s", _PATH_CP,
+			    iamrecursive ? " -r" : "", pflag ? " -p" : "",
+			    argv[i], argv[argc - 1]);
+			(void)susystem(bp);
+			(void)free(bp);
+			continue;
+		}
+		*src++ = 0;
+		if (*src == 0)
+			src = ".";
+		host = index(argv[i], '@');
+		if (host) {
+			*host++ = 0;
+			suser = argv[i];
+			if (*suser == '\0')
+				suser = pwd->pw_name;
+			else if (!okname(suser))
+				continue;
+		} else {
+			host = argv[i];
+			suser = pwd->pw_name;
+		}
+		len = strlen(src) + CMDNEEDS + 20;
+		if (!(bp = malloc(len)))
+			nospace();
+		(void)snprintf(bp, len, "%s -f %s", cmd, src);
+#ifdef KERBEROS
+		if (use_kerberos)
+			rem = kerberos(&host, bp, pwd->pw_name, suser);
+		else
+#endif
+			rem = rcmd(&host, port, pwd->pw_name, suser, bp, 0);
+		(void)free(bp);
+		if (rem < 0)
+			continue;
+		(void)seteuid(userid);
+		tos = IPTOS_THROUGHPUT;
+		if (setsockopt(rem, IPPROTO_IP, IP_TOS,
+		    (char *)&tos, sizeof(int)) < 0)
+			perror("rcp: setsockopt TOS (ignored)");
+		sink(1, argv + argc - 1);
+		(void)seteuid(0);
+		(void)close(rem);
+		rem = -1;
+	}
 }
 
 verifydir(cp)
@@ -233,23 +393,21 @@ verifydir(cp)
 			return;
 		errno = ENOTDIR;
 	}
-	error("rcp: %s: %s.\n", cp, sys_errlist[errno]);
+	error("rcp: %s: %s.\n", cp, strerror(errno));
 	exit(1);
 }
 
 char *
 colon(cp)
-	char *cp;
+	register char *cp;
 {
-
-	while (*cp) {
+	for (; *cp; ++cp) {
 		if (*cp == ':')
-			return (cp);
+			return(cp);
 		if (*cp == '/')
-			return (0);
-		cp++;
+			return(0);
 	}
-	return (0);
+	return(0);
 }
 
 okname(cp0)
@@ -264,23 +422,22 @@ okname(cp0)
 			goto bad;
 		if (!isalpha(c) && !isdigit(c) && c != '_' && c != '-')
 			goto bad;
-		cp++;
-	} while (*cp);
-	return (1);
+	} while (*++cp);
+	return(1);
 bad:
-	fprintf(stderr, "rcp: invalid user name %s\n", cp0);
-	return (0);
+	(void)fprintf(stderr, "rcp: invalid user name %s\n", cp0);
+	return(0);
 }
 
 susystem(s)
 	char *s;
 {
 	int status, pid, w;
-	register int (*istat)(), (*qstat)();
+	register sig_t istat, qstat;
 
 	if ((pid = vfork()) == 0) {
-		(void) setuid(userid);
-		execl("/bin/sh", "sh", "-c", s, (char *)0);
+		(void)setuid(userid);
+		execl(_PATH_BSHELL, "sh", "-c", s, (char *)0);
 		_exit(127);
 	}
 	istat = signal(SIGINT, SIG_IGN);
@@ -289,27 +446,27 @@ susystem(s)
 		;
 	if (w == -1)
 		status = -1;
-	(void) signal(SIGINT, istat);
-	(void) signal(SIGQUIT, qstat);
-	return (status);
+	(void)signal(SIGINT, istat);
+	(void)signal(SIGQUIT, qstat);
+	return(status);
 }
 
 source(argc, argv)
 	int argc;
 	char **argv;
 {
-	char *last, *name;
 	struct stat stb;
-	static struct buffer buffer;
-	struct buffer *bp;
-	int x, sizerr, f, amt;
+	static BUF buffer;
+	BUF *bp;
 	off_t i;
-	char buf[BUFSIZ];
+	int x, readerr, f, amt;
+	char *last, *name, buf[BUFSIZ];
+	BUF *allocbuf();
 
 	for (x = 0; x < argc; x++) {
 		name = argv[x];
-		if ((f = open(name, 0)) < 0) {
-			error("rcp: %s: %s\n", name, sys_errlist[errno]);
+		if ((f = open(name, O_RDONLY, 0)) < 0) {
+			error("rcp: %s: %s\n", name, strerror(errno));
 			continue;
 		}
 		if (fstat(f, &stb) < 0)
@@ -321,14 +478,13 @@ source(argc, argv)
 
 		case S_IFDIR:
 			if (iamrecursive) {
-				(void) close(f);
+				(void)close(f);
 				rsource(name, &stb);
 				continue;
 			}
-			/* fall into ... */
+			/* FALLTHROUGH */
 		default:
-notreg:
-			(void) close(f);
+notreg:			(void)close(f);
 			error("rcp: %s: not a plain file\n", name);
 			continue;
 		}
@@ -342,57 +498,53 @@ notreg:
 			 * Make it compatible with possible future
 			 * versions expecting microseconds.
 			 */
-			(void) sprintf(buf, "T%ld 0 %ld 0\n",
-			    stb.st_mtime, stb.st_atime);
-			(void) write(rem, buf, strlen(buf));
+			(void)snprintf(buf, sizeof(buf),
+			    "T%ld 0 %ld 0\n", stb.st_mtime, stb.st_atime);
+			(void)write(rem, buf, (int)strlen(buf));
 			if (response() < 0) {
-				(void) close(f);
+				(void)close(f);
 				continue;
 			}
 		}
-		(void) sprintf(buf, "C%04o %ld %s\n",
-		    stb.st_mode&07777, stb.st_size, last);
-		(void) write(rem, buf, strlen(buf));
+		(void)snprintf(buf, sizeof(buf),
+		    "C%04o %ld %s\n", stb.st_mode&07777, stb.st_size, last);
+		(void)write(rem, buf, (int)strlen(buf));
 		if (response() < 0) {
-			(void) close(f);
+			(void)close(f);
 			continue;
 		}
-		if ((bp = allocbuf(&buffer, f, BUFSIZ)) < 0) {
-			(void) close(f);
+		if ((bp = allocbuf(&buffer, f, BUFSIZ)) == 0) {
+			(void)close(f);
 			continue;
 		}
-		sizerr = 0;
+		readerr = 0;
 		for (i = 0; i < stb.st_size; i += bp->cnt) {
 			amt = bp->cnt;
 			if (i + amt > stb.st_size)
 				amt = stb.st_size - i;
-			if (sizerr == 0 && read(f, bp->buf, amt) != amt)
-				sizerr = 1;
-			(void) write(rem, bp->buf, amt);
+			if (readerr == 0 && read(f, bp->buf, amt) != amt)
+				readerr = errno;
+			(void)write(rem, bp->buf, amt);
 		}
-		(void) close(f);
-		if (sizerr == 0)
-			ga();
+		(void)close(f);
+		if (readerr == 0)
+			(void)write(rem, "", 1);
 		else
-			error("rcp: %s: file changed size\n", name);
-		(void) response();
+			error("rcp: %s: %s\n", name, strerror(readerr));
+		(void)response();
 	}
 }
 
-#include <sys/dir.h>
-
 rsource(name, statp)
 	char *name;
 	struct stat *statp;
 {
-	DIR *d = opendir(name);
-	char *last;
-	struct direct *dp;
-	char buf[BUFSIZ];
-	char *bufv[1];
-
-	if (d == 0) {
-		error("rcp: %s: %s\n", name, sys_errlist[errno]);
+	DIR *dirp;
+	struct dirent *dp;
+	char *last, *vect[1], path[MAXPATHLEN];
+
+	if (!(dirp = opendir(name))) {
+		error("rcp: %s: %s\n", name, strerror(errno));
 		return;
 	}
 	last = rindex(name, '/');
@@ -401,74 +553,77 @@ rsource(name, statp)
 	else
 		last++;
 	if (pflag) {
-		(void) sprintf(buf, "T%ld 0 %ld 0\n",
-		    statp->st_mtime, statp->st_atime);
-		(void) write(rem, buf, strlen(buf));
+		(void)snprintf(path, sizeof(path),
+		    "T%ld 0 %ld 0\n", statp->st_mtime, statp->st_atime);
+		(void)write(rem, path, (int)strlen(path));
 		if (response() < 0) {
-			closedir(d);
+			closedir(dirp);
 			return;
 		}
 	}
-	(void) sprintf(buf, "D%04o %d %s\n", statp->st_mode&07777, 0, last);
-	(void) write(rem, buf, strlen(buf));
+	(void)snprintf(path, sizeof(path),
+	    "D%04o %d %s\n", statp->st_mode&07777, 0, last);
+	(void)write(rem, path, (int)strlen(path));
 	if (response() < 0) {
-		closedir(d);
+		closedir(dirp);
 		return;
 	}
-	while (dp = readdir(d)) {
+	while (dp = readdir(dirp)) {
 		if (dp->d_ino == 0)
 			continue;
 		if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
 			continue;
-		if (strlen(name) + 1 + strlen(dp->d_name) >= BUFSIZ - 1) {
-			error("%s/%s: Name too long.\n", name, dp->d_name);
+		if (strlen(name) + 1 + strlen(dp->d_name) >= MAXPATHLEN - 1) {
+			error("%s/%s: name too long.\n", name, dp->d_name);
 			continue;
 		}
-		(void) sprintf(buf, "%s/%s", name, dp->d_name);
-		bufv[0] = buf;
-		source(1, bufv);
+		(void)snprintf(path, sizeof(path), "%s/%s", name, dp->d_name);
+		vect[0] = path;
+		source(1, vect);
 	}
-	closedir(d);
-	(void) write(rem, "E\n", 2);
-	(void) response();
+	closedir(dirp);
+	(void)write(rem, "E\n", 2);
+	(void)response();
 }
 
 response()
 {
-	char resp, c, rbuf[BUFSIZ], *cp = rbuf;
+	register char *cp;
+	char ch, resp, rbuf[BUFSIZ];
 
-	if (read(rem, &resp, 1) != 1)
+	if (read(rem, &resp, sizeof(resp)) != sizeof(resp))
 		lostconn();
-	switch (resp) {
 
+	cp = rbuf;
+	switch(resp) {
 	case 0:				/* ok */
-		return (0);
-
+		return(0);
 	default:
 		*cp++ = resp;
-		/* fall into... */
+		/* FALLTHROUGH */
 	case 1:				/* error, followed by err msg */
 	case 2:				/* fatal error, "" */
 		do {
-			if (read(rem, &c, 1) != 1)
+			if (read(rem, &ch, sizeof(ch)) != sizeof(ch))
 				lostconn();
-			*cp++ = c;
-		} while (cp < &rbuf[BUFSIZ] && c != '\n');
-		if (iamremote == 0)
-			(void) write(2, rbuf, cp - rbuf);
-		errs++;
+			*cp++ = ch;
+		} while (cp < &rbuf[BUFSIZ] && ch != '\n');
+
+		if (!iamremote)
+			(void)write(2, rbuf, cp - rbuf);
+		++errs;
 		if (resp == 1)
-			return (-1);
+			return(-1);
 		exit(1);
 	}
 	/*NOTREACHED*/
 }
 
+void
 lostconn()
 {
-
-	if (iamremote == 0)
-		fprintf(stderr, "rcp: lost connection\n");
+	if (!iamremote)
+		(void)fprintf(stderr, "rcp: lost connection\n");
 	exit(1);
 }
 
@@ -476,24 +631,26 @@ sink(argc, argv)
 	int argc;
 	char **argv;
 {
-	off_t i, j;
-	char *targ, *whopp, *cp;
-	int of, mode, wrerr, exists, first, count, amt, size;
-	struct buffer *bp;
-	static struct buffer buffer;
+	register char *cp;
+	static BUF buffer;
 	struct stat stb;
-	int targisdir = 0;
-	int mask = umask(0);
-	char *myargv[1];
-	char cmdbuf[BUFSIZ], nambuf[BUFSIZ];
-	int setimes = 0;
 	struct timeval tv[2];
-#define atime	tv[0]
-#define mtime	tv[1]
-#define	SCREWUP(str)	{ whopp = str; goto screwup; }
+	enum { YES, NO, DISPLAYED } wrerr;
+	BUF *bp, *allocbuf();
+	off_t i, j;
+	char ch, *targ, *why;
+	int amt, count, exists, first, mask, mode;
+	int ofd, setimes, size, targisdir;
+	char *np, *vect[1], buf[BUFSIZ];
+
+#define	atime	tv[0]
+#define	mtime	tv[1]
+#define	SCREWUP(str)	{ why = str; goto screwup; }
 
+	setimes = targisdir = 0;
+	mask = umask(0);
 	if (!pflag)
-		(void) umask(mask);
+		(void)umask(mask);
 	if (argc != 1) {
 		error("rcp: ambiguous target\n");
 		exit(1);
@@ -501,36 +658,40 @@ sink(argc, argv)
 	targ = *argv;
 	if (targetshouldbedirectory)
 		verifydir(targ);
-	ga();
+	(void)write(rem, "", 1);
 	if (stat(targ, &stb) == 0 && (stb.st_mode & S_IFMT) == S_IFDIR)
 		targisdir = 1;
-	for (first = 1; ; first = 0) {
-		cp = cmdbuf;
+	for (first = 1;; first = 0) {
+		cp = buf;
 		if (read(rem, cp, 1) <= 0)
 			return;
 		if (*cp++ == '\n')
-			SCREWUP("unexpected '\\n'");
+			SCREWUP("unexpected <newline>");
 		do {
-			if (read(rem, cp, 1) != 1)
+			if (read(rem, &ch, sizeof(ch)) != sizeof(ch))
 				SCREWUP("lost connection");
-		} while (*cp++ != '\n');
+			*cp++ = ch;
+		} while (cp < &buf[BUFSIZ - 1] && ch != '\n');
 		*cp = 0;
-		if (cmdbuf[0] == '\01' || cmdbuf[0] == '\02') {
+
+		if (buf[0] == '\01' || buf[0] == '\02') {
 			if (iamremote == 0)
-				(void) write(2, cmdbuf+1, strlen(cmdbuf+1));
-			if (cmdbuf[0] == '\02')
+				(void)write(2, buf + 1, (int)strlen(buf + 1));
+			if (buf[0] == '\02')
 				exit(1);
 			errs++;
 			continue;
 		}
-		*--cp = 0;
-		cp = cmdbuf;
-		if (*cp == 'E') {
-			ga();
+		if (buf[0] == 'E') {
+			(void)write(rem, "", 1);
 			return;
 		}
 
+		if (ch == '\n')
+			*--cp = 0;
+
 #define getnum(t) (t) = 0; while (isdigit(*cp)) (t) = (t) * 10 + (*cp++ - '0');
+		cp = buf;
 		if (*cp == 'T') {
 			setimes++;
 			cp++;
@@ -546,7 +707,7 @@ sink(argc, argv)
 			getnum(atime.tv_usec);
 			if (*cp++ != '\0')
 				SCREWUP("atime.usec not delimited");
-			ga();
+			(void)write(rem, "", 1);
 			continue;
 		}
 		if (*cp != 'C' && *cp != 'D') {
@@ -563,9 +724,8 @@ sink(argc, argv)
 			}
 			SCREWUP("expected control record");
 		}
-		cp++;
 		mode = 0;
-		for (; cp < cmdbuf+5; cp++) {
+		for (++cp; cp < buf + 5; cp++) {
 			if (*cp < '0' || *cp > '7')
 				SCREWUP("bad mode");
 			mode = (mode << 3) | (*cp - '0');
@@ -577,47 +737,57 @@ sink(argc, argv)
 			size = size * 10 + (*cp++ - '0');
 		if (*cp++ != ' ')
 			SCREWUP("size not delimited");
-		if (targisdir)
-			(void) sprintf(nambuf, "%s%s%s", targ,
+		if (targisdir) {
+			static char *namebuf;
+			static int cursize;
+			size_t need;
+
+			need = strlen(targ) + strlen(cp) + 250;
+			if (need > cursize) {
+				if (!(namebuf = malloc(need)))
+					error("out of memory\n");
+			}
+			(void)snprintf(namebuf, need, "%s%s%s", targ,
 			    *targ ? "/" : "", cp);
+			np = namebuf;
+		}
 		else
-			(void) strcpy(nambuf, targ);
-		exists = stat(nambuf, &stb) == 0;
-		if (cmdbuf[0] == 'D') {
+			np = targ;
+		exists = stat(np, &stb) == 0;
+		if (buf[0] == 'D') {
 			if (exists) {
 				if ((stb.st_mode&S_IFMT) != S_IFDIR) {
 					errno = ENOTDIR;
 					goto bad;
 				}
 				if (pflag)
-					(void) chmod(nambuf, mode);
-			} else if (mkdir(nambuf, mode) < 0)
+					(void)chmod(np, mode);
+			} else if (mkdir(np, mode) < 0)
 				goto bad;
-			myargv[0] = nambuf;
-			sink(1, myargv);
+			vect[0] = np;
+			sink(1, vect);
 			if (setimes) {
 				setimes = 0;
-				if (utimes(nambuf, tv) < 0)
-					error("rcp: can't set times on %s: %s\n",
-					    nambuf, sys_errlist[errno]);
+				if (utimes(np, tv) < 0)
+				    error("rcp: can't set times on %s: %s\n",
+					np, strerror(errno));
 			}
 			continue;
 		}
-		if ((of = creat(nambuf, mode)) < 0) {
-	bad:
-			error("rcp: %s: %s\n", nambuf, sys_errlist[errno]);
+		if ((ofd = open(np, O_WRONLY|O_CREAT, mode)) < 0) {
+bad:			error("rcp: %s: %s\n", np, strerror(errno));
 			continue;
 		}
 		if (exists && pflag)
-			(void) fchmod(of, mode);
-		ga();
-		if ((bp = allocbuf(&buffer, of, BUFSIZ)) < 0) {
-			(void) close(of);
+			(void)fchmod(ofd, mode);
+		(void)write(rem, "", 1);
+		if ((bp = allocbuf(&buffer, ofd, BUFSIZ)) == 0) {
+			(void)close(ofd);
 			continue;
 		}
 		cp = bp->buf;
 		count = 0;
-		wrerr = 0;
+		wrerr = NO;
 		for (i = 0; i < size; i += BUFSIZ) {
 			amt = BUFSIZ;
 			if (i + amt > size)
@@ -626,56 +796,67 @@ sink(argc, argv)
 			do {
 				j = read(rem, cp, amt);
 				if (j <= 0) {
-					if (j == 0)
-					    error("rcp: dropped connection");
-					else
-					    error("rcp: %s\n",
-						sys_errlist[errno]);
+					error("rcp: %s\n",
+					    j ? strerror(errno) :
+					    "dropped connection");
 					exit(1);
 				}
 				amt -= j;
 				cp += j;
 			} while (amt > 0);
 			if (count == bp->cnt) {
-				if (wrerr == 0 &&
-				    write(of, bp->buf, count) != count)
-					wrerr++;
+				if (wrerr == NO &&
+				    write(ofd, bp->buf, count) != count)
+					wrerr = YES;
 				count = 0;
 				cp = bp->buf;
 			}
 		}
-		if (count != 0 && wrerr == 0 &&
-		    write(of, bp->buf, count) != count)
-			wrerr++;
-		(void) close(of);
-		(void) response();
-		if (setimes) {
+		if (count != 0 && wrerr == NO &&
+		    write(ofd, bp->buf, count) != count)
+			wrerr = YES;
+		if (ftruncate(ofd, size)) {
+			error("rcp: can't truncate %s: %s\n", np,
+			    strerror(errno));
+			wrerr = DISPLAYED;
+		}
+		(void)close(ofd);
+		(void)response();
+		if (setimes && wrerr == NO) {
 			setimes = 0;
-			if (utimes(nambuf, tv) < 0)
+			if (utimes(np, tv) < 0) {
 				error("rcp: can't set times on %s: %s\n",
-				    nambuf, sys_errlist[errno]);
-		}				   
-		if (wrerr)
-			error("rcp: %s: %s\n", nambuf, sys_errlist[errno]);
-		else
-			ga();
+				    np, strerror(errno));
+				wrerr = DISPLAYED;
+			}
+		}
+		switch(wrerr) {
+		case YES:
+			error("rcp: %s: %s\n", np, strerror(errno));
+			break;
+		case NO:
+			(void)write(rem, "", 1);
+			break;
+		case DISPLAYED:
+			break;
+		}
 	}
 screwup:
-	error("rcp: protocol screwup: %s\n", whopp);
+	error("rcp: protocol screwup: %s\n", why);
 	exit(1);
 }
 
-struct buffer *
+BUF *
 allocbuf(bp, fd, blksize)
-	struct buffer *bp;
+	BUF *bp;
 	int fd, blksize;
 {
 	struct stat stb;
-	int size;
+	size_t size;
 
 	if (fstat(fd, &stb) < 0) {
-		error("rcp: fstat: %s\n", sys_errlist[errno]);
-		return ((struct buffer *)-1);
+		error("rcp: fstat: %s\n", strerror(errno));
+		return(0);
 	}
 	size = roundup(stb.st_blksize, blksize);
 	if (size == 0)
@@ -683,27 +864,121 @@ allocbuf(bp, fd, blksize)
 	if (bp->cnt < size) {
 		if (bp->buf != 0)
 			free(bp->buf);
-		bp->buf = (char *)malloc((unsigned) size);
-		if (bp->buf == 0) {
+		bp->buf = malloc(size);
+		if (!bp->buf) {
 			error("rcp: malloc: out of memory\n");
-			return ((struct buffer *)-1);
+			return(0);
 		}
 	}
 	bp->cnt = size;
-	return (bp);
+	return(bp);
 }
 
-/*VARARGS1*/
-error(fmt, a1, a2, a3, a4, a5)
+/* VARARGS1 */
+error(fmt, a1, a2, a3)
 	char *fmt;
-	int a1, a2, a3, a4, a5;
+	int a1, a2, a3;
+{
+	static FILE *fp;
+
+	++errs;
+	if (!fp && !(fp = fdopen(rem, "w")))
+		return;
+	(void)fprintf(fp, "%c", 0x01);
+	(void)fprintf(fp, fmt, a1, a2, a3);
+	(void)fflush(fp);
+	if (!iamremote)
+		(void)fprintf(stderr, fmt, a1, a2, a3);
+}
+
+nospace()
+{
+	(void)fprintf(stderr, "rcp: out of memory.\n");
+	exit(1);
+}
+
+
+usage()
+{
+#ifdef KERBEROS
+#ifdef CRYPT
+	(void)fprintf(stderr, "%s\n\t%s\n",
+	    "usage: rcp [-k realm] [-px] f1 f2",
+	    "or: rcp [-k realm] [-rpx] f1 ... fn directory");
+#else
+	(void)fprintf(stderr, "%s\n\t%s\n",
+	    "usage: rcp [-k realm] [-p] f1 f2",
+	    "or: rcp [-k realm] [-rp] f1 ... fn directory");
+#endif
+#else
+	(void)fprintf(stderr,
+	    "usage: rcp [-p] f1 f2; or: rcp [-rp] f1 ... fn directory\n");
+#endif
+	exit(1);
+}
+
+#ifdef KERBEROS
+old_warning(str)
+	char *str;
+{
+	(void)fprintf(stderr, "rcp: warning: %s, using standard rcp\n", str);
+}
+
+int
+kerberos(host, bp, locuser, user)
+
+	char **host, *bp, *locuser, *user;
 {
-	char buf[BUFSIZ], *cp = buf;
-
-	errs++;
-	*cp++ = 1;
-	(void) sprintf(cp, fmt, a1, a2, a3, a4, a5);
-	(void) write(rem, buf, strlen(buf));
-	if (iamremote == 0)
-		(void) write(2, buf+1, strlen(buf+1));
+	struct servent *sp;
+
+again:
+	if (use_kerberos) {
+		rem = KSUCCESS;
+		errno = 0;
+		if (dest_realm == NULL)
+			dest_realm = krb_realmofhost(*host);
+
+#ifdef CRYPT
+		if (doencrypt)
+			rem = krcmd_mutual(
+				host, port,
+				user, bp, 0,
+		    		dest_realm,
+				&cred, schedule);
+		else
+#endif
+			rem = krcmd(
+				host, port,
+				user, bp, 0, dest_realm);
+
+		if (rem < 0) {
+			use_kerberos = 0;
+			sp = getservbyname("shell", "tcp");
+			if (sp == NULL) {
+				(void)fprintf(stderr,
+			    	    "rcp: unknown service shell/tcp\n");
+				exit(1);
+			}
+			if (errno == ECONNREFUSED)
+				old_warning(
+				    "remote host doesn't support Kerberos");
+
+			if (errno == ENOENT)
+				old_warning(
+				    "Can't provide Kerberos auth data");
+			port = sp->s_port;
+			goto again;
+		}
+	} else {
+#ifdef CRYPT
+		if (doencrypt) {
+			fprintf(stderr,
+			    "The -x option requires Kerberos authentication\n");
+			exit(1);
+		}
+#endif
+		rem = rcmd(host, sp->s_port, locuser, user, bp, 0);
+	}
+	return(rem);
 }
+#endif /* KERBEROS */