[unix-history] / usr / src / lib / libc / net / rcmd.c

/*
 * Copyright (c) 1983 Regents of the University of California.
 * All rights reserved.
 *
 * %sccs.include.redist.c%
 */

#if defined(LIBC_SCCS) && !defined(lint)
static char sccsid[] = "@(#)rcmd.c	5.24 (Berkeley) %G%";
#endif /* LIBC_SCCS and not lint */

#include <sys/param.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <fcntl.h>
#include <netdb.h>
#include <pwd.h>
#include <errno.h>
#include <stdio.h>
#include <ctype.h>
#include <unistd.h>
#include <string.h>

rcmd(ahost, rport, locuser, remuser, cmd, fd2p)
	char **ahost;
	u_short rport;
	const char *locuser, *remuser, *cmd;
	int *fd2p;
{
	int s, timo = 1, pid;
	long oldmask;
	struct sockaddr_in sin, sin2, from;
	char c;
	int lport = IPPORT_RESERVED - 1;
	struct hostent *hp;
	fd_set reads;

	pid = getpid();
	hp = gethostbyname(*ahost);
	if (hp == 0) {
		herror(*ahost);
		return (-1);
	}
	*ahost = hp->h_name;
	oldmask = sigblock(sigmask(SIGURG));
	for (;;) {
		s = rresvport(&lport);
		if (s < 0) {
			if (errno == EAGAIN)
				fprintf(stderr, "socket: All ports in use\n");
			else
				perror("rcmd: socket");
			sigsetmask(oldmask);
			return (-1);
		}
		fcntl(s, F_SETOWN, pid);
		sin.sin_family = hp->h_addrtype;
		bcopy(hp->h_addr_list[0], (caddr_t)&sin.sin_addr, hp->h_length);
		sin.sin_port = rport;
		if (connect(s, (struct sockaddr *)&sin, sizeof(sin)) >= 0)
			break;
		(void) close(s);
		if (errno == EADDRINUSE) {
			lport--;
			continue;
		}
		if (errno == ECONNREFUSED && timo <= 16) {
			sleep(timo);
			timo *= 2;
			continue;
		}
		if (hp->h_addr_list[1] != NULL) {
			int oerrno = errno;

			fprintf(stderr,
			    "connect to address %s: ", inet_ntoa(sin.sin_addr));
			errno = oerrno;
			perror(0);
			hp->h_addr_list++;
			bcopy(hp->h_addr_list[0], (caddr_t)&sin.sin_addr,
			    hp->h_length);
			fprintf(stderr, "Trying %s...\n",
				inet_ntoa(sin.sin_addr));
			continue;
		}
		perror(hp->h_name);
		sigsetmask(oldmask);
		return (-1);
	}
	lport--;
	if (fd2p == 0) {
		write(s, "", 1);
		lport = 0;
	} else {
		char num[8];
		int s2 = rresvport(&lport), s3;
		int len = sizeof (from);

		if (s2 < 0)
			goto bad;
		listen(s2, 1);
		(void) sprintf(num, "%d", lport);
		if (write(s, num, strlen(num)+1) != strlen(num)+1) {
			perror("write: setting up stderr");
			(void) close(s2);
			goto bad;
		}
		FD_ZERO(&reads);
		FD_SET(s, &reads);
		FD_SET(s2, &reads);
		errno = 0;
		if (select(32, &reads, 0, 0, 0) < 1 ||
		    !FD_ISSET(s2, &reads)) {
			if (errno != 0)
				perror("select: setting up stderr");
			else
			    fprintf(stderr,
				"select: protocol failure in circuit setup.\n");
			(void) close(s2);
			goto bad;
		}
		s3 = accept(s2, (struct sockaddr *)&from, &len);
		(void) close(s2);
		if (s3 < 0) {
			perror("accept");
			lport = 0;
			goto bad;
		}
		*fd2p = s3;
		from.sin_port = ntohs((u_short)from.sin_port);
		if (from.sin_family != AF_INET ||
		    from.sin_port >= IPPORT_RESERVED ||
		    from.sin_port < IPPORT_RESERVED / 2) {
			fprintf(stderr,
			    "socket: protocol failure in circuit setup.\n");
			goto bad2;
		}
	}
	(void) write(s, locuser, strlen(locuser)+1);
	(void) write(s, remuser, strlen(remuser)+1);
	(void) write(s, cmd, strlen(cmd)+1);
	if (read(s, &c, 1) != 1) {
		perror(*ahost);
		goto bad2;
	}
	if (c != 0) {
		while (read(s, &c, 1) == 1) {
			(void) write(2, &c, 1);
			if (c == '\n')
				break;
		}
		goto bad2;
	}
	sigsetmask(oldmask);
	return (s);
bad2:
	if (lport)
		(void) close(*fd2p);
bad:
	(void) close(s);
	sigsetmask(oldmask);
	return (-1);
}

rresvport(alport)
	int *alport;
{
	struct sockaddr_in sin;
	int s;

	sin.sin_family = AF_INET;
	sin.sin_addr.s_addr = INADDR_ANY;
	s = socket(AF_INET, SOCK_STREAM, 0);
	if (s < 0)
		return (-1);
	for (;;) {
		sin.sin_port = htons((u_short)*alport);
		if (bind(s, (struct sockaddr *)&sin, sizeof (sin)) >= 0)
			return (s);
		if (errno != EADDRINUSE) {
			(void) close(s);
			return (-1);
		}
		(*alport)--;
		if (*alport == IPPORT_RESERVED/2) {
			(void) close(s);
			errno = EAGAIN;		/* close */
			return (-1);
		}
	}
}

int	_check_rhosts_file = 1;

ruserok(rhost, superuser, ruser, luser)
	const char *rhost, *ruser, *luser;
	int superuser;
{
	FILE *hostf;
	char fhost[MAXHOSTNAMELEN];
	int first = 1;
	register char *sp, *p;
	int baselen = -1;

	sp = (char *)rhost;
	p = fhost;
	while (*sp) {
		if (*sp == '.') {
			if (baselen == -1)
				baselen = sp - rhost;
			*p++ = *sp++;
		} else {
			*p++ = isupper(*sp) ? tolower(*sp++) : *sp++;
		}
	}
	*p = '\0';
	hostf = superuser ? (FILE *)0 : fopen(_PATH_HEQUIV, "r");
again:
	if (hostf) {
		if (!_validuser(hostf, fhost, luser, ruser, baselen)) {
			(void) fclose(hostf);
			return(0);
		}
		(void) fclose(hostf);
	}
	if (first == 1 && (_check_rhosts_file || superuser)) {
		struct stat sbuf;
		struct passwd *pwd;
		char pbuf[MAXPATHLEN];

		first = 0;
		if ((pwd = getpwnam(luser)) == NULL)
			return(-1);
		(void)strcpy(pbuf, pwd->pw_dir);
		(void)strcat(pbuf, "/.rhosts");
		if ((hostf = fopen(pbuf, "r")) == NULL)
			return(-1);
		/*
		 * if owned by someone other than user or root or if
		 * writeable by anyone but the owner, quit
		 */
		if (fstat(fileno(hostf), &sbuf) ||
		    sbuf.st_uid && sbuf.st_uid != pwd->pw_uid ||
		    sbuf.st_mode&022) {
			fclose(hostf);
			return(-1);
		}
		goto again;
	}
	return (-1);
}

/* don't make static, used by lpd(8) */
_validuser(hostf, rhost, luser, ruser, baselen)
	char *rhost, *luser, *ruser;
	FILE *hostf;
	int baselen;
{
	register char *p;
	char *user, ahost[MAXHOSTNAMELEN];
	static int _checkhost();

	while (fgets(ahost, sizeof (ahost), hostf)) {
		p = ahost;
		while (*p != '\n' && *p != ' ' && *p != '\t' && *p != '\0') {
			*p = isupper(*p) ? tolower(*p) : *p;
			p++;
		}
		if (*p == ' ' || *p == '\t') {
			*p++ = '\0';
			while (*p == ' ' || *p == '\t')
				p++;
			user = p;
			while (*p != '\n' && *p != ' ' && *p != '\t' && *p != '\0')
				p++;
		} else
			user = p;
		*p = '\0';
		if (_checkhost(rhost, ahost, baselen) &&
		    !strcmp(ruser, *user ? user : luser)) {
			return (0);
		}
	}
	return (-1);
}

static
_checkhost(rhost, lhost, len)
	char *rhost, *lhost;
	int len;
{
	static char ldomain[MAXHOSTNAMELEN + 1];
	static char *domainp = NULL;
	static int nodomain = 0;
	register char *cp;

	if (len == -1)
		return(!strcmp(rhost, lhost));
	if (strncmp(rhost, lhost, len))
		return(0);
	if (!strcmp(rhost, lhost))
		return(1);
	if (*(lhost + len) != '\0')
		return(0);
	if (nodomain)
		return(0);
	if (!domainp) {
		if (gethostname(ldomain, sizeof(ldomain)) == -1) {
			nodomain = 1;
			return(0);
		}
		ldomain[MAXHOSTNAMELEN] = NULL;
		if ((domainp = index(ldomain, '.')) == (char *)NULL) {
			nodomain = 1;
			return(0);
		}
		for (cp = ++domainp; *cp; ++cp)
			if (isupper(*cp))
				*cp = tolower(*cp);
	}
	return(!strcmp(domainp, rhost + len +1));
}
Commit	Line	Data
586c39b1 DF	1	/*
586c39b1 DF	2	* Copyright (c) 1983 Regents of the University of California.
6b2f9dd0 KB	3	* All rights reserved.
6b2f9dd0 KB	4	*
269a7923	5	* %sccs.include.redist.c%
586c39b1 DF	6	*/
586c39b1 DF	7
2ce81398	8	#if defined(LIBC_SCCS) && !defined(lint)
dcdb79c9	9	static char sccsid[] = "@(#)rcmd.c 5.24 (Berkeley) %G%";
6b2f9dd0	10	#endif /* LIBC_SCCS and not lint */
f0bb4ca8	11
20ac274b	12	#include <sys/param.h>
f0bb4ca8	13	#include <sys/socket.h>
eb88aeb4	14	#include <sys/stat.h>
40d6b022	15	#include <netinet/in.h>
24fac7d8 KB	16	#include <arpa/inet.h>
	17	#include <signal.h>
	18	#include <fcntl.h>
3f5b52bc	19	#include <netdb.h>
24fac7d8	20	#include <pwd.h>
40d6b022	21	#include <errno.h>
24fac7d8	22	#include <stdio.h>
dcdb79c9	23	#include <ctype.h>
24fac7d8 KB	24	#include <unistd.h>
24fac7d8 KB	25	#include <string.h>
f0bb4ca8 BJ	26
	27	rcmd(ahost, rport, locuser, remuser, cmd, fd2p)
	28	char **ahost;
9e7d84e3	29	u_short rport;
24fac7d8	30	const char locuser, remuser, *cmd;
f0bb4ca8 BJ	31	int *fd2p;
f0bb4ca8 BJ	32	{
1f83dd8c KB	33	int s, timo = 1, pid;
1f83dd8c KB	34	long oldmask;
f0bb4ca8 BJ	35	struct sockaddr_in sin, sin2, from;
f0bb4ca8 BJ	36	char c;
40d6b022	37	int lport = IPPORT_RESERVED - 1;
3f5b52bc	38	struct hostent *hp;
b53bce26	39	fd_set reads;
f0bb4ca8	40
92423502	41	pid = getpid();
3f5b52bc SL	42	hp = gethostbyname(*ahost);
3f5b52bc SL	43	if (hp == 0) {
b2e55cea	44	herror(*ahost);
f0bb4ca8 BJ	45	return (-1);
f0bb4ca8 BJ	46	}
3f5b52bc	47	*ahost = hp->h_name;
92423502 MK	48	oldmask = sigblock(sigmask(SIGURG));
	49	for (;;) {
	50	s = rresvport(&lport);
	51	if (s < 0) {
	52	if (errno == EAGAIN)
	53	fprintf(stderr, "socket: All ports in use\n");
	54	else
	55	perror("rcmd: socket");
	56	sigsetmask(oldmask);
	57	return (-1);
	58	}
	59	fcntl(s, F_SETOWN, pid);
	60	sin.sin_family = hp->h_addrtype;
	61	bcopy(hp->h_addr_list[0], (caddr_t)&sin.sin_addr, hp->h_length);
	62	sin.sin_port = rport;
24fac7d8	63	if (connect(s, (struct sockaddr *)&sin, sizeof(sin)) >= 0)
92423502	64	break;
ea19968f	65	(void) close(s);
40d6b022	66	if (errno == EADDRINUSE) {
40d6b022	67	lport--;
92423502	68	continue;
40d6b022	69	}
f0bb4ca8	70	if (errno == ECONNREFUSED && timo <= 16) {
f0bb4ca8 BJ	71	sleep(timo);
f0bb4ca8 BJ	72	timo *= 2;
92423502 MK	73	continue;
	74	}
	75	if (hp->h_addr_list[1] != NULL) {
	76	int oerrno = errno;
	77
	78	fprintf(stderr,
	79	"connect to address %s: ", inet_ntoa(sin.sin_addr));
	80	errno = oerrno;
	81	perror(0);
	82	hp->h_addr_list++;
	83	bcopy(hp->h_addr_list[0], (caddr_t)&sin.sin_addr,
	84	hp->h_length);
	85	fprintf(stderr, "Trying %s...\n",
	86	inet_ntoa(sin.sin_addr));
	87	continue;
f0bb4ca8	88	}
40d6b022	89	perror(hp->h_name);
92423502	90	sigsetmask(oldmask);
f0bb4ca8 BJ	91	return (-1);
f0bb4ca8 BJ	92	}
40d6b022	93	lport--;
f0bb4ca8 BJ	94	if (fd2p == 0) {
f0bb4ca8 BJ	95	write(s, "", 1);
c1dfbf19	96	lport = 0;
f0bb4ca8 BJ	97	} else {
f0bb4ca8 BJ	98	char num[8];
c1dfbf19	99	int s2 = rresvport(&lport), s3;
ea19968f	100	int len = sizeof (from);
f0bb4ca8	101
ea19968f RC	102	if (s2 < 0)
ea19968f RC	103	goto bad;
40d6b022	104	listen(s2, 1);
c1dfbf19	105	(void) sprintf(num, "%d", lport);
2c510808 SL	106	if (write(s, num, strlen(num)+1) != strlen(num)+1) {
	107	perror("write: setting up stderr");
	108	(void) close(s2);
	109	goto bad;
	110	}
b53bce26 MK	111	FD_ZERO(&reads);
	112	FD_SET(s, &reads);
	113	FD_SET(s2, &reads);
	114	errno = 0;
	115	if (select(32, &reads, 0, 0, 0) < 1 \|\|
	116	!FD_ISSET(s2, &reads)) {
	117	if (errno != 0)
	118	perror("select: setting up stderr");
	119	else
	120	fprintf(stderr,
	121	"select: protocol failure in circuit setup.\n");
	122	(void) close(s2);
	123	goto bad;
	124	}
24fac7d8	125	s3 = accept(s2, (struct sockaddr *)&from, &len);
ea19968f RC	126	(void) close(s2);
ea19968f RC	127	if (s3 < 0) {
f0bb4ca8	128	perror("accept");
c1dfbf19	129	lport = 0;
f0bb4ca8 BJ	130	goto bad;
f0bb4ca8 BJ	131	}
40d6b022 SL	132	*fd2p = s3;
40d6b022 SL	133	from.sin_port = ntohs((u_short)from.sin_port);
f0bb4ca8	134	if (from.sin_family != AF_INET \|\|
b53bce26 MK	135	from.sin_port >= IPPORT_RESERVED \|\|
b53bce26 MK	136	from.sin_port < IPPORT_RESERVED / 2) {
f0bb4ca8 BJ	137	fprintf(stderr,
f0bb4ca8 BJ	138	"socket: protocol failure in circuit setup.\n");
40d6b022	139	goto bad2;
f0bb4ca8	140	}
f0bb4ca8 BJ	141	}
	142	(void) write(s, locuser, strlen(locuser)+1);
	143	(void) write(s, remuser, strlen(remuser)+1);
	144	(void) write(s, cmd, strlen(cmd)+1);
	145	if (read(s, &c, 1) != 1) {
	146	perror(*ahost);
40d6b022	147	goto bad2;
f0bb4ca8 BJ	148	}
	149	if (c != 0) {
	150	while (read(s, &c, 1) == 1) {
	151	(void) write(2, &c, 1);
	152	if (c == '\n')
	153	break;
	154	}
40d6b022	155	goto bad2;
f0bb4ca8	156	}
92423502	157	sigsetmask(oldmask);
f0bb4ca8	158	return (s);
40d6b022	159	bad2:
c1dfbf19	160	if (lport)
f0bb4ca8	161	(void) close(*fd2p);
40d6b022	162	bad:
f0bb4ca8	163	(void) close(s);
92423502	164	sigsetmask(oldmask);
f0bb4ca8 BJ	165	return (-1);
	166	}
	167
c1dfbf19 SL	168	rresvport(alport)
c1dfbf19 SL	169	int *alport;
f0bb4ca8 BJ	170	{
f0bb4ca8 BJ	171	struct sockaddr_in sin;
f0bb4ca8 BJ	172	int s;
f0bb4ca8 BJ	173
40d6b022	174	sin.sin_family = AF_INET;
9a89481f MK	175	sin.sin_addr.s_addr = INADDR_ANY;
9a89481f MK	176	s = socket(AF_INET, SOCK_STREAM, 0);
40d6b022 SL	177	if (s < 0)
40d6b022 SL	178	return (-1);
f0bb4ca8	179	for (;;) {
40d6b022	180	sin.sin_port = htons((u_short)*alport);
24fac7d8	181	if (bind(s, (struct sockaddr *)&sin, sizeof (sin)) >= 0)
f0bb4ca8	182	return (s);
9a89481f	183	if (errno != EADDRINUSE) {
ea19968f	184	(void) close(s);
f0bb4ca8 BJ	185	return (-1);
f0bb4ca8 BJ	186	}
40d6b022 SL	187	(*alport)--;
40d6b022 SL	188	if (*alport == IPPORT_RESERVED/2) {
ea19968f	189	(void) close(s);
0575dce2	190	errno = EAGAIN; /* close */
f0bb4ca8 BJ	191	return (-1);
	192	}
	193	}
	194	}
	195
bec8d58c KB	196	int _check_rhosts_file = 1;
bec8d58c KB	197
ff3164c8	198	ruserok(rhost, superuser, ruser, luser)
24fac7d8	199	const char rhost, ruser, *luser;
ff3164c8	200	int superuser;
f0bb4ca8 BJ	201	{
f0bb4ca8 BJ	202	FILE *hostf;
20ac274b	203	char fhost[MAXHOSTNAMELEN];
f0bb4ca8	204	int first = 1;
20ac274b JB	205	register char sp, p;
20ac274b JB	206	int baselen = -1;
f0bb4ca8	207
24fac7d8	208	sp = (char *)rhost;
20ac274b JB	209	p = fhost;
	210	while (*sp) {
	211	if (*sp == '.') {
	212	if (baselen == -1)
	213	baselen = sp - rhost;
	214	p++ = sp++;
	215	} else {
	216	p++ = isupper(sp) ? tolower(sp++) : sp++;
	217	}
	218	}
	219	*p = '\0';
29eb0a7d	220	hostf = superuser ? (FILE *)0 : fopen(_PATH_HEQUIV, "r");
f0bb4ca8 BJ	221	again:
f0bb4ca8 BJ	222	if (hostf) {
9e7d84e3 JB	223	if (!_validuser(hostf, fhost, luser, ruser, baselen)) {
	224	(void) fclose(hostf);
	225	return(0);
f0bb4ca8 BJ	226	}
	227	(void) fclose(hostf);
	228	}
bec8d58c	229	if (first == 1 && (_check_rhosts_file \|\| superuser)) {
eb88aeb4 JB	230	struct stat sbuf;
	231	struct passwd *pwd;
	232	char pbuf[MAXPATHLEN];
	233
f0bb4ca8	234	first = 0;
eb88aeb4 JB	235	if ((pwd = getpwnam(luser)) == NULL)
	236	return(-1);
	237	(void)strcpy(pbuf, pwd->pw_dir);
	238	(void)strcat(pbuf, "/.rhosts");
	239	if ((hostf = fopen(pbuf, "r")) == NULL)
	240	return(-1);
bec8d58c KB	241	/*
	242	* if owned by someone other than user or root or if
	243	* writeable by anyone but the owner, quit
	244	*/
	245	if (fstat(fileno(hostf), &sbuf) \|\|
	246	sbuf.st_uid && sbuf.st_uid != pwd->pw_uid \|\|
	247	sbuf.st_mode&022) {
eb88aeb4 JB	248	fclose(hostf);
	249	return(-1);
	250	}
f0bb4ca8 BJ	251	goto again;
	252	}
	253	return (-1);
f0bb4ca8	254	}
20ac274b	255
b53bce26	256	/* don't make static, used by lpd(8) */
9e7d84e3	257	_validuser(hostf, rhost, luser, ruser, baselen)
bec8d58c KB	258	char rhost, luser, *ruser;
	259	FILE *hostf;
	260	int baselen;
9e7d84e3	261	{
9e7d84e3	262	register char *p;
24fac7d8 KB	263	char *user, ahost[MAXHOSTNAMELEN];
24fac7d8 KB	264	static int _checkhost();
9e7d84e3 JB	265
	266	while (fgets(ahost, sizeof (ahost), hostf)) {
	267	p = ahost;
	268	while (p != '\n' && p != ' ' && p != '\t' && p != '\0') {
	269	p = isupper(p) ? tolower(p) : p;
	270	p++;
	271	}
	272	if (p == ' ' \|\| p == '\t') {
	273	*p++ = '\0';
	274	while (p == ' ' \|\| p == '\t')
	275	p++;
	276	user = p;
	277	while (p != '\n' && p != ' ' && p != '\t' && p != '\0')
	278	p++;
	279	} else
	280	user = p;
	281	*p = '\0';
	282	if (_checkhost(rhost, ahost, baselen) &&
	283	!strcmp(ruser, *user ? user : luser)) {
	284	return (0);
	285	}
	286	}
	287	return (-1);
	288	}
	289
bec8d58c	290	static
20ac274b	291	_checkhost(rhost, lhost, len)
bec8d58c KB	292	char rhost, lhost;
bec8d58c KB	293	int len;
20ac274b	294	{
426aec69	295	static char ldomain[MAXHOSTNAMELEN + 1];
20ac274b	296	static char *domainp = NULL;
1359ea69	297	static int nodomain = 0;
20ac274b JB	298	register char *cp;
	299
	300	if (len == -1)
	301	return(!strcmp(rhost, lhost));
	302	if (strncmp(rhost, lhost, len))
	303	return(0);
	304	if (!strcmp(rhost, lhost))
	305	return(1);
	306	if (*(lhost + len) != '\0')
	307	return(0);
1359ea69 KB	308	if (nodomain)
1359ea69 KB	309	return(0);
20ac274b JB	310	if (!domainp) {
20ac274b JB	311	if (gethostname(ldomain, sizeof(ldomain)) == -1) {
66d34eeb	312	nodomain = 1;
20ac274b JB	313	return(0);
	314	}
	315	ldomain[MAXHOSTNAMELEN] = NULL;
1359ea69 KB	316	if ((domainp = index(ldomain, '.')) == (char *)NULL) {
1359ea69 KB	317	nodomain = 1;
49528010	318	return(0);
9e7d84e3	319	}
1359ea69 KB	320	for (cp = ++domainp; *cp; ++cp)
	321	if (isupper(*cp))
	322	cp = tolower(cp);
20ac274b	323	}
20ac274b JB	324	return(!strcmp(domainp, rhost + len +1));
20ac274b JB	325	}