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

diff --git a/usr/src/bin/rcp/rcp.c b/usr/src/bin/rcp/rcp.c
index 2847b1afa6..0d15b68e41 100644
--- a/usr/src/bin/rcp/rcp.c
+++ b/usr/src/bin/rcp/rcp.c
@@ -1,166 +1,386 @@
+/*
+ * 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
-static char sccsid[] = "@(#)rcp.c	4.11 85/02/16";
-#endif
+char copyright[] =
+"@(#) Copyright (c) 1983, 1990 The Regents of the University of California.\n\
+ All rights reserved.\n";
+#endif /* not lint */
+
+#ifndef lint
+static char sccsid[] = "@(#)rcp.c	5.32 (Berkeley) 2/25/91";
+#endif /* not lint */
 
 /*
  * rcp
  */
 #include <sys/param.h>
 #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>
+#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
 
-int	rem;
-char	*colon(), *index(), *rindex(), *malloc(), *strcpy(), *sprintf();
-int	errs;
-int	lostconn();
-int	iamremote;
+struct passwd *pwd;
+u_short	port;
+uid_t	userid;
+int errs, rem;
+int pflag, iamremote, iamrecursive, targetshouldbedirectory;
 
-int	errno;
-char	*sys_errlist[];
-int	iamremote, targetshouldbedirectory;
-int	iamrecursive;
-struct	passwd *pwd;
-struct	passwd *getpwuid();
+#define	CMDNEEDS	64
+char cmd[CMDNEEDS];		/* must hold "rcp -r -p -d\0" */
 
-/*VARARGS*/
-int	error();
+typedef struct _buf {
+	int	cnt;
+	char	*buf;
+} BUF;
 
-#define	ga()	 	(void) write(rem, "", 1)
+void lostconn();
 
 main(argc, argv)
 	int argc;
 	char **argv;
 {
-	char *targ, *host, *src;
-	char *suser, *tuser;
-	int i;
-	char buf[BUFSIZ], cmd[16];
-	
-	setpwent();
-	pwd = getpwuid(getuid());
-	endpwent();
-	if (pwd == 0) {
-		fprintf(stderr, "who are you?\n");
-		exit(1);
+	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;
+
+		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");
 	}
-	argc--, argv++;
-	if (argc > 0 && !strcmp(*argv, "-r")) {
-		iamrecursive++;
-		argc--, argv++;
+#else
+	sp = getservbyname(shell = "shell", "tcp");
+#endif
+	if (sp == NULL) {
+		(void)fprintf(stderr, "rcp: %s/tcp: unknown service\n", shell);
+		exit(1);
 	}
-	if (argc > 0 && !strcmp(*argv, "-d")) {
-		targetshouldbedirectory = 1;
-		argc--, argv++;
+	port = sp->s_port;
+
+	if (!(pwd = getpwuid(userid = getuid()))) {
+		(void)fprintf(stderr, "rcp: unknown user %d.\n", (int)userid);
+		exit(1);
 	}
-	if (argc > 0 && !strcmp(*argv, "-f")) {
-		argc--, argv++; iamremote = 1;
-		(void) response();
-		(void) setuid(getuid());
+
+	if (fflag) {
+		/* follow "protocol", send data */
+		(void)response();
+		(void)setuid(userid);
 		source(argc, argv);
 		exit(errs);
 	}
-	if (argc > 0 && !strcmp(*argv, "-t")) {
-		argc--, argv++; iamremote = 1;
-		(void) setuid(getuid());
+
+	if (tflag) {
+		/* receive data */
+		(void)setuid(userid);
 		sink(argc, argv);
 		exit(errs);
 	}
-	rem = -1;
+
+	if (argc < 2)
+		usage();
 	if (argc > 2)
 		targetshouldbedirectory = 1;
-	(void) sprintf(cmd, "rcp%s%s",
-	    iamrecursive ? " -r" : "", targetshouldbedirectory ? " -d" : "");
-	signal(SIGPIPE, lostconn);
-	targ = colon(argv[argc - 1]);
-	if (targ) {
-		*targ++ = 0;
-		if (*targ == 0)
-			targ = ".";
-		tuser = rindex(argv[argc - 1], '.');
-		if (tuser) {
-			*tuser++ = 0;
-			if (!okname(tuser))
-				exit(1);
-		} else
-			tuser = pwd->pw_name;
-		for (i = 0; i < argc - 1; i++) {
-			src = colon(argv[i]);
-			if (src) {
-				*src++ = 0;
-				if (*src == 0)
-					src = ".";
-				suser = rindex(argv[i], '.');
-				if (suser) {
-					*suser++ = 0;
-					if (!okname(suser))
-						continue;
-		(void) sprintf(buf, "rsh %s -l %s -n %s %s '%s.%s:%s'",
-					    argv[i], suser, cmd, src,
-					    argv[argc - 1], tuser, targ);
-				} else
-		(void) sprintf(buf, "rsh %s -n %s %s '%s.%s:%s'",
-					    argv[i], cmd, src,
-					    argv[argc - 1], tuser, targ);
-				(void) susystem(buf);
-			} else {
-				if (rem == -1) {
-					(void) sprintf(buf, "%s -t %s",
-					    cmd, targ);
-					host = argv[argc - 1];
-					rem = rcmd(&host, IPPORT_CMDSERVER,
-					    pwd->pw_name, tuser,
-					    buf, 0);
-					if (rem < 0)
-						exit(1);
-					if (response() < 0)
-						exit(1);
-				}
-				source(1, argv+i);
-			}
-		}
-	} else {
+
+	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
+
+	(void)signal(SIGPIPE, lostconn);
+
+	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]);
-		for (i = 0; i < argc - 1; i++) {
-			src = colon(argv[i]);
-			if (src == 0) {
-				(void) sprintf(buf, "/bin/cp%s %s %s",
-				    iamrecursive ? " -r" : "",
-				    argv[i], argv[argc - 1]);
-				(void) susystem(buf);
-			} else {
-				*src++ = 0;
-				if (*src == 0)
-					src = ".";
-				suser = rindex(argv[i], '.');
-				if (suser) {
-					*suser++ = 0;
-					if (!okname(suser))
-						continue;
-				} else
+	}
+	exit(errs);
+}
+
+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;
+	}
+
+	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;
-				(void) sprintf(buf, "%s -f %s", cmd, src);
-				host = argv[i];
-				rem = rcmd(&host, IPPORT_CMDSERVER,
-				    pwd->pw_name, suser,
-				    buf, 0);
+				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,
+					    bp, 0);
 				if (rem < 0)
 					exit(1);
-				sink(1, argv+argc-1);
-				(void) close(rem);
-				rem = -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)
@@ -168,29 +388,26 @@ verifydir(cp)
 {
 	struct stat stb;
 
-	if (stat(cp, &stb) < 0)
-		goto bad;
-	if ((stb.st_mode & S_IFMT) == S_IFDIR)
-		return;
-	errno = ENOTDIR;
-bad:
-	error("rcp: %s: %s.\n", cp, sys_errlist[errno]);
+	if (stat(cp, &stb) >= 0) {
+		if ((stb.st_mode & S_IFMT) == S_IFDIR)
+			return;
+		errno = ENOTDIR;
+	}
+	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)
@@ -205,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) {
-		setuid(getuid());
-		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);
@@ -230,25 +446,27 @@ susystem(s)
 		;
 	if (w == -1)
 		status = -1;
-	signal(SIGINT, istat);
-	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;
-	char buf[BUFSIZ];
-	int x, sizerr, f;
+	static BUF buffer;
+	BUF *bp;
 	off_t i;
+	int x, readerr, f, amt;
+	char *last, *name, buf[BUFSIZ];
+	BUF *allocbuf();
 
 	for (x = 0; x < argc; x++) {
 		name = argv[x];
-		if (access(name, 4) < 0 || (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)
@@ -260,14 +478,13 @@ source(argc, argv)
 
 		case S_IFDIR:
 			if (iamrecursive) {
-				(void) close(f);
-				rsource(name, (int)stb.st_mode);
+				(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;
 		}
@@ -276,45 +493,58 @@ notreg:
 			last = name;
 		else
 			last++;
-		(void) sprintf(buf, "C%04o %D %s\n",
-		    stb.st_mode&07777, stb.st_size, last);
-		(void) write(rem, buf, strlen(buf));
+		if (pflag) {
+			/*
+			 * Make it compatible with possible future
+			 * versions expecting microseconds.
+			 */
+			(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);
+				continue;
+			}
+		}
+		(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;
 		}
-		sizerr = 0;
-		for (i = 0; i < stb.st_size; i += BUFSIZ) {
-			int amt = BUFSIZ;
+		if ((bp = allocbuf(&buffer, f, BUFSIZ)) == 0) {
+			(void)close(f);
+			continue;
+		}
+		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, buf, amt) != amt)
-				sizerr = 1;
-			(void) write(rem, 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, mode)
+rsource(name, statp)
 	char *name;
-	int mode;
+	struct stat *statp;
 {
-	DIR *d = opendir(name);
-	char *last;
-	struct direct *dp;
-	char buf[BUFSIZ];
-	char *bufv[1];
-
-	if (d == 0) {
-		error("%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, '/');
@@ -322,66 +552,78 @@ rsource(name, mode)
 		last = name;
 	else
 		last++;
-	(void) sprintf(buf, "D%04o %d %s\n", mode&07777, 0, last);
-	(void) write(rem, buf, strlen(buf));
+	if (pflag) {
+		(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(dirp);
+			return;
+		}
+	}
+	(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) {
-
-	case 0:
-		return (0);
 
+	cp = rbuf;
+	switch(resp) {
+	case 0:				/* ok */
+		return(0);
 	default:
 		*cp++ = resp;
-		/* fall into... */
-	case 1:
-	case 2:
+		/* 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);
 }
 
@@ -389,52 +631,85 @@ sink(argc, argv)
 	int argc;
 	char **argv;
 {
-	char *targ;
-	char cmdbuf[BUFSIZ], nambuf[BUFSIZ], buf[BUFSIZ], *cp;
-	int of, mode, wrerr, exists, first;
-	off_t i, size;
-	char *whopp;
-	struct stat stb; int targisdir = 0;
-#define	SCREWUP(str)	{ whopp = str; goto screwup; }
-	int mask = umask(0);
-	char *myargv[1];
-
-	umask(mask);
-	if (argc > 1) {
+	register char *cp;
+	static BUF buffer;
+	struct stat stb;
+	struct timeval tv[2];
+	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);
+	if (argc != 1) {
 		error("rcp: ambiguous target\n");
 		exit(1);
 	}
 	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++;
+			getnum(mtime.tv_sec);
+			if (*cp++ != ' ')
+				SCREWUP("mtime.sec not delimited");
+			getnum(mtime.tv_usec);
+			if (*cp++ != ' ')
+				SCREWUP("mtime.usec not delimited");
+			getnum(atime.tv_sec);
+			if (*cp++ != ' ')
+				SCREWUP("atime.sec not delimited");
+			getnum(atime.tv_usec);
+			if (*cp++ != '\0')
+				SCREWUP("atime.usec not delimited");
+			(void)write(rem, "", 1);
+			continue;
+		}
 		if (*cp != 'C' && *cp != 'D') {
 			/*
 			 * Check for the case "rcp remote:foo\* local:bar".
@@ -449,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');
@@ -459,116 +733,252 @@ sink(argc, argv)
 		if (*cp++ != ' ')
 			SCREWUP("mode not delimited");
 		size = 0;
-		while (*cp >= '0' && *cp <= '9')
+		while (isdigit(*cp))
 			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 (exists && access(nambuf, 2) < 0)
-			goto bad2;
-		{ char *slash = rindex(nambuf, '/'), *dir;
-		  if (slash == 0) {
-			slash = "/";
-			dir = ".";
-		  } else {
-			*slash = 0;
-			dir = nambuf;
-			if (*dir == '\0')
-				dir = "/";
-		  }
-		  if (exists == 0 && access(dir, 2) < 0)
-			goto bad;
-		  *slash = '/';
-		  if (cmdbuf[0] == 'D') {
-			if (stat(nambuf, &stb) == 0) {
+			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;
 				}
-			} else if (makedir(nambuf, mode) < 0)
+				if (pflag)
+					(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(np, tv) < 0)
+				    error("rcp: can't set times on %s: %s\n",
+					np, strerror(errno));
+			}
 			continue;
-		  }
-		  if ((of = creat(nambuf, mode)) < 0) {
-	bad:
-			*slash = '/';
-	bad2:
-			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 == 0) {
-			(void) chown(nambuf, pwd->pw_uid, -1);
-			(void) chmod(nambuf, mode &~ mask);
+		if (exists && pflag)
+			(void)fchmod(ofd, mode);
+		(void)write(rem, "", 1);
+		if ((bp = allocbuf(&buffer, ofd, BUFSIZ)) == 0) {
+			(void)close(ofd);
+			continue;
 		}
-		ga();
-		wrerr = 0;
+		cp = bp->buf;
+		count = 0;
+		wrerr = NO;
 		for (i = 0; i < size; i += BUFSIZ) {
-			int amt = BUFSIZ;
-			char *cp = buf;
-
+			amt = BUFSIZ;
 			if (i + amt > size)
 				amt = size - i;
+			count += amt;
 			do {
-				int j = read(rem, cp, amt);
-
-				if (j <= 0)
+				j = read(rem, cp, amt);
+				if (j <= 0) {
+					error("rcp: %s\n",
+					    j ? strerror(errno) :
+					    "dropped connection");
 					exit(1);
+				}
 				amt -= j;
 				cp += j;
 			} while (amt > 0);
-			amt = BUFSIZ;
-			if (i + amt > size)
-				amt = size - i;
-			if (wrerr == 0 && write(of, buf, amt) != amt)
-				wrerr++;
+			if (count == bp->cnt) {
+				if (wrerr == NO &&
+				    write(ofd, bp->buf, count) != count)
+					wrerr = YES;
+				count = 0;
+				cp = bp->buf;
+			}
+		}
+		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(np, tv) < 0) {
+				error("rcp: can't set times on %s: %s\n",
+				    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;
 		}
-		(void) close(of);
-		(void) response();
-		if (wrerr)
-			error("rcp: %s: %s\n", cp, sys_errlist[errno]);
-		else
-			ga();
 	}
 screwup:
-	error("rcp: protocol screwup: %s\n", whopp);
+	error("rcp: protocol screwup: %s\n", why);
 	exit(1);
 }
 
-/*VARARGS*/
-error(fmt, a1, a2, a3, a4, a5)
+BUF *
+allocbuf(bp, fd, blksize)
+	BUF *bp;
+	int fd, blksize;
+{
+	struct stat stb;
+	size_t size;
+
+	if (fstat(fd, &stb) < 0) {
+		error("rcp: fstat: %s\n", strerror(errno));
+		return(0);
+	}
+	size = roundup(stb.st_blksize, blksize);
+	if (size == 0)
+		size = blksize;
+	if (bp->cnt < size) {
+		if (bp->buf != 0)
+			free(bp->buf);
+		bp->buf = malloc(size);
+		if (!bp->buf) {
+			error("rcp: malloc: out of memory\n");
+			return(0);
+		}
+	}
+	bp->cnt = size;
+	return(bp);
+}
+
+/* VARARGS1 */
+error(fmt, a1, a2, a3)
 	char *fmt;
-	int a1, a2, a3, a4, a5;
+	int a1, a2, a3;
 {
-	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));
+	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);
 }
 
-makedir(name, mode)
-	register char *name;
-	register int mode;
+nospace()
 {
-	register int _errno;
+	(void)fprintf(stderr, "rcp: out of memory.\n");
+	exit(1);
+}
 
-	if (mkdir(name, mode) < 0 || chown(name, getuid(), -1) < 0) {
-		_errno = errno;
-		rmdir(name);
-		errno = _errno;
-		return (-1);
-	}
 
-	return (0);
+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;
+{
+	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 */