[unix-history] / usr / src / usr.bin / rlogin / rlogin.c

#ifndef lint
static char sccsid[] = "@(#)rlogin.c	4.9 83/02/09";
#endif

#include <sys/types.h>
#include <sys/socket.h>

#include <netinet/in.h>

#include <stdio.h>
#include <sgtty.h>
#include <errno.h>
#include <pwd.h>
#include <signal.h>
#include <netdb.h>

/*
 * rlogin - remote login
 */
char	*index(), *rindex(), *malloc(), *getenv();
struct	passwd *getpwuid();
char	*name;
int	rem;
char	cmdchar = '~';
int	eight;
char	*speeds[] =
    { "0", "50", "75", "110", "134", "150", "200", "300",
      "600", "1200", "1800", "2400", "4800", "9600", "19200", "38400" };
char	term[64] = "network";
extern	int errno;
int	lostpeer();

main(argc, argv)
	int argc;
	char **argv;
{
	char *host, *cp;
	struct sgttyb ttyb;
	struct passwd *pwd;
	struct servent *sp;
	int uid, options = 0;

	host = rindex(argv[0], '/');
	if (host)
		host++;
	else
		host = argv[0];
	argv++, --argc;
	if (!strcmp(host, "rlogin"))
		host = *argv++, --argc;
another:
	if (argc > 0 && !strcmp(*argv, "-d")) {
		argv++, argc--;
		options |= SO_DEBUG;
		goto another;
	}
	if (argc > 0 && !strcmp(*argv, "-l")) {
		argv++, argc--;
		if (argc == 0)
			goto usage;
		name = *argv++; argc--;
		goto another;
	}
	if (argc > 0 && !strncmp(*argv, "-e", 2)) {
		cmdchar = argv[0][2];
		argv++, argc--;
		goto another;
	}
	if (argc > 0 && !strcmp(*argv, "-8")) {
		eight = 1;
		argv++, argc--;
		goto another;
	}
	if (host == 0)
		goto usage;
	if (argc > 0)
		goto usage;
	pwd = getpwuid(getuid());
	if (pwd == 0) {
		fprintf(stderr, "Who are you?\n");
		exit(1);
	}
	sp = getservbyname("login", "tcp");
	if (sp == 0) {
		fprintf(stderr, "rlogin: login/tcp: unknown service\n");
		exit(2);
	}
	cp = getenv("TERM");
	if (cp)
		strcpy(term, cp);
	if (ioctl(0, TIOCGETP, &ttyb)==0) {
		strcat(term, "/");
		strcat(term, speeds[ttyb.sg_ospeed]);
	}
	signal(SIGPIPE, lostpeer);
        rem = rcmd(&host, sp->s_port, pwd->pw_name,
	    name ? name : pwd->pw_name, term, 0);
        if (rem < 0)
                exit(1);
	if (options & SO_DEBUG &&
	    setsockopt(rem, SOL_SOCKET, SO_DEBUG, 0, 0) < 0)
		perror("rlogin: setsockopt (SO_DEBUG)");
	uid = getuid();
	if (setuid(uid) < 0) {
		perror("rlogin: setuid");
		exit(1);
	}
	doit();
	/*NOTREACHED*/
usage:
	fprintf(stderr,
	    "usage: rlogin host [ -ex ] [ -l username ]\n");
	exit(1);
}

#define CRLF "\r\n"

int	child;
int	done();

int	defflags;
struct	ttychars deftc;
struct	ttychars notc = {
	-1,	-1,	-1,	-1,	-1,
	-1,	-1,	-1,	-1,	-1,
	-1,	-1,	-1,	-1
};

doit()
{
	int exit();

	ioctl(0, TIOCGET, (char *)&defflags);
	defflags &= ECHO | CRMOD;
	ioctl(0, TIOCCGET, (char *)&deftc);
	notc.tc_startc = deftc.tc_startc;
	notc.tc_stopc = deftc.tc_stopc;
	signal(SIGINT, exit);
	signal(SIGHUP, exit);
	signal(SIGQUIT, exit);
	child = fork();
	if (child == -1) {
		perror("rlogin: fork");
		done();
	}
	signal(SIGINT, SIG_IGN);
	if (child == 0) {
		reader();
		prf("\007Lost connection.");
		exit(3);
	}
	signal(SIGCHLD, done);
	mode(1);
	writer();
	prf("Disconnected.");
	done();
}

done()
{

	mode(0);
	if (child > 0 && kill(child, SIGKILL) >= 0)
		wait((int *)0);
	exit(0);
}

/*
 * writer: write to remote: 0 -> line.
 * ~.	terminate
 * ~^Z	suspend rlogin process.
 * ~^Y  suspend rlogin process, but leave reader alone.
 */
writer()
{
	char b[600], c;
	register char *p;

top:
	p = b;
	while (read(0, &c, 1) > 0) {
		int local;

		if (eight == 0)
			c &= 0177;
		/*
		 * If we're at the beginning of the line
		 * and recognize a command character, then
		 * we echo locally.  Otherwise, characters
		 * are echo'd remotely.  If the command
		 * character is doubled, this acts as a 
		 * force and local echo is suppressed.
		 */
		if (p == b)
			local = (c == cmdchar);
		if (p == b + 1 && *b == cmdchar)
			local = (c != cmdchar);
		if (!local) {
			if (write(rem, &c, 1) == 0) {
				prf("line gone");
				return;
			}
			if (eight == 0)
				c &= 0177;
		} else {
			if (c == 0177)
				c = deftc.tc_kill;
			if (c == '\r' || c == '\n') {
				char cmdc = b[1];

				if (cmdc == '.' || cmdc == deftc.tc_eofc) {
					write(0, CRLF, sizeof(CRLF));
					return;
				}
				if (cmdc == deftc.tc_suspc ||
				    cmdc == deftc.tc_dsuspc) {
					write(0, CRLF, sizeof(CRLF));
					mode(0);
					signal(SIGCHLD, SIG_IGN);
					kill(cmdc == deftc.tc_suspc ?
					  0 : getpid(), SIGTSTP);
					signal(SIGCHLD, done);
					mode(1);
					goto top;
				}
				*p++ = c;
				write(rem, b, p - b);
				goto top;
			}
			write(1, &c, 1);
		}
		*p++ = c;
		if (c == deftc.tc_erase) {
			p -= 2; 
			if (p < b)
				goto top;
		}
		if (c == deftc.tc_kill || c == 0177 || c == deftc.tc_eofc ||
		    c == '\r' || c == '\n')
			goto top;
	}
}

oob()
{
	int out = 1+1, atmark;
	char waste[BUFSIZ], mark;

	signal(SIGURG, oob);
	ioctl(1, TIOCFLUSH, (char *)&out);
	for (;;) {
		if (ioctl(rem, SIOCATMARK, &atmark) < 0) {
			perror("ioctl");
			break;
		}
		if (atmark)
			break;
		(void) read(rem, waste, sizeof (waste));
	}
	recv(rem, &mark, 1, SOF_OOB);
	if (mark & TIOCPKT_NOSTOP) {
		notc.tc_stopc = -1;
		notc.tc_startc = -1;
		ioctl(0, TIOCCSET, (char *)&notc);
	}
	if (mark & TIOCPKT_DOSTOP) {
		notc.tc_stopc = deftc.tc_stopc;
		notc.tc_startc = deftc.tc_startc;
		ioctl(0, TIOCCSET, (char *)&notc);
	}
}

/*
 * reader: read from remote: line -> 1
 */
reader()
{
	char rb[BUFSIZ];
	register int cnt;

	signal(SIGURG, oob);
	{ int pid = -getpid();
	  ioctl(rem, SIOCSPGRP, (char *)&pid); }
	for (;;) {
		cnt = read(rem, rb, sizeof (rb));
		if (cnt <= 0) {
			if (errno == EINTR)
				continue;
			break;
		}
		write(1, rb, cnt);
	}
}

mode(f)
{
	struct ttychars *tc;
	int flags;

	ioctl(0, TIOCGET, (char *)&flags);
	switch (f) {

	case 0:
		flags &= ~CBREAK;
		flags |= defflags;
		tc = &deftc;
		break;

	case 1:
		flags |= CBREAK;
		flags &= ~defflags;
		tc = &notc;
		break;

	default:
		return;
	}
	ioctl(0, TIOCSET, (char *)&flags);
	ioctl(0, TIOCCSET, (char *)tc);
}

/*VARARGS*/
prf(f, a1, a2, a3)
	char *f;
{
	fprintf(stderr, f, a1, a2, a3);
	fprintf(stderr, CRLF);
}

lostpeer()
{
	signal(SIGPIPE, SIG_IGN);
	prf("\007Lost connection");
	done();
}
Commit	Line	Data
5567b76f	1	#ifndef lint
4659bf8e	2	static char sccsid[] = "@(#)rlogin.c 4.9 83/02/09";
5567b76f BJ	3	#endif
5567b76f BJ	4
5567b76f BJ	5	#include <sys/types.h>
5567b76f BJ	6	#include <sys/socket.h>
86a16a64	7
c6c678f1	8	#include <netinet/in.h>
86a16a64 SL	9
	10	#include <stdio.h>
	11	#include <sgtty.h>
5567b76f BJ	12	#include <errno.h>
5567b76f BJ	13	#include <pwd.h>
86a16a64 SL	14	#include <signal.h>
86a16a64 SL	15	#include <netdb.h>
5567b76f BJ	16
5567b76f BJ	17	/*
86a16a64	18	* rlogin - remote login
5567b76f BJ	19	*/
	20	char index(), rindex(), malloc(), getenv();
	21	struct passwd *getpwuid();
86a16a64	22	char *name;
5567b76f BJ	23	int rem;
5567b76f BJ	24	char cmdchar = '~';
5567b76f BJ	25	int eight;
	26	char *speeds[] =
	27	{ "0", "50", "75", "110", "134", "150", "200", "300",
	28	"600", "1200", "1800", "2400", "4800", "9600", "19200", "38400" };
86a16a64 SL	29	char term[64] = "network";
	30	extern int errno;
	31	int lostpeer();
	32
5567b76f BJ	33	main(argc, argv)
	34	int argc;
	35	char **argv;
	36	{
86a16a64	37	char host, cp;
5567b76f BJ	38	struct sgttyb ttyb;
5567b76f BJ	39	struct passwd *pwd;
86a16a64	40	struct servent *sp;
b5f23952	41	int uid, options = 0;
5567b76f BJ	42
	43	host = rindex(argv[0], '/');
	44	if (host)
	45	host++;
	46	else
	47	host = argv[0];
	48	argv++, --argc;
	49	if (!strcmp(host, "rlogin"))
	50	host = *argv++, --argc;
	51	another:
4659bf8e	52	if (argc > 0 && !strcmp(*argv, "-d")) {
5567b76f	53	argv++, argc--;
b5f23952	54	options \|= SO_DEBUG;
5567b76f BJ	55	goto another;
5567b76f BJ	56	}
4659bf8e	57	if (argc > 0 && !strcmp(*argv, "-l")) {
5567b76f BJ	58	argv++, argc--;
	59	if (argc == 0)
	60	goto usage;
	61	name = *argv++; argc--;
	62	goto another;
	63	}
4659bf8e	64	if (argc > 0 && !strncmp(*argv, "-e", 2)) {
5567b76f BJ	65	cmdchar = argv[0][2];
	66	argv++, argc--;
	67	goto another;
	68	}
4659bf8e	69	if (argc > 0 && !strcmp(*argv, "-8")) {
5567b76f BJ	70	eight = 1;
	71	argv++, argc--;
	72	goto another;
	73	}
	74	if (host == 0)
	75	goto usage;
	76	if (argc > 0)
	77	goto usage;
	78	pwd = getpwuid(getuid());
	79	if (pwd == 0) {
	80	fprintf(stderr, "Who are you?\n");
	81	exit(1);
	82	}
86a16a64 SL	83	sp = getservbyname("login", "tcp");
	84	if (sp == 0) {
	85	fprintf(stderr, "rlogin: login/tcp: unknown service\n");
	86	exit(2);
	87	}
f91500bc SL	88	cp = getenv("TERM");
	89	if (cp)
	90	strcpy(term, cp);
c64cdfb4	91	if (ioctl(0, TIOCGETP, &ttyb)==0) {
5567b76f BJ	92	strcat(term, "/");
	93	strcat(term, speeds[ttyb.sg_ospeed]);
	94	}
86a16a64 SL	95	signal(SIGPIPE, lostpeer);
86a16a64 SL	96	rem = rcmd(&host, sp->s_port, pwd->pw_name,
5567b76f BJ	97	name ? name : pwd->pw_name, term, 0);
	98	if (rem < 0)
	99	exit(1);
b5f23952 SL	100	if (options & SO_DEBUG &&
	101	setsockopt(rem, SOL_SOCKET, SO_DEBUG, 0, 0) < 0)
	102	perror("rlogin: setsockopt (SO_DEBUG)");
86a16a64 SL	103	uid = getuid();
	104	if (setuid(uid) < 0) {
	105	perror("rlogin: setuid");
	106	exit(1);
	107	}
	108	doit();
	109	/NOTREACHED/
5567b76f BJ	110	usage:
	111	fprintf(stderr,
	112	"usage: rlogin host [ -ex ] [ -l username ]\n");
	113	exit(1);
	114	}
	115
5567b76f	116	#define CRLF "\r\n"
5567b76f	117
86a16a64	118	int child;
5567b76f BJ	119	int done();
5567b76f BJ	120
c64cdfb4 SL	121	int defflags;
	122	struct ttychars deftc;
	123	struct ttychars notc = {
	124	-1, -1, -1, -1, -1,
	125	-1, -1, -1, -1, -1,
	126	-1, -1, -1, -1
	127	};
86a16a64 SL	128
86a16a64 SL	129	doit()
5567b76f	130	{
5567b76f BJ	131	int exit();
5567b76f BJ	132
c64cdfb4 SL	133	ioctl(0, TIOCGET, (char *)&defflags);
	134	defflags &= ECHO \| CRMOD;
	135	ioctl(0, TIOCCGET, (char *)&deftc);
	136	notc.tc_startc = deftc.tc_startc;
	137	notc.tc_stopc = deftc.tc_stopc;
5567b76f BJ	138	signal(SIGINT, exit);
	139	signal(SIGHUP, exit);
	140	signal(SIGQUIT, exit);
86a16a64 SL	141	child = fork();
	142	if (child == -1) {
	143	perror("rlogin: fork");
	144	done();
	145	}
	146	signal(SIGINT, SIG_IGN);
	147	if (child == 0) {
86a16a64	148	reader();
5567b76f BJ	149	prf("\007Lost connection.");
	150	exit(3);
	151	}
	152	signal(SIGCHLD, done);
	153	mode(1);
86a16a64	154	writer();
5567b76f BJ	155	prf("Disconnected.");
	156	done();
	157	}
	158
	159	done()
	160	{
	161
	162	mode(0);
86a16a64 SL	163	if (child > 0 && kill(child, SIGKILL) >= 0)
86a16a64 SL	164	wait((int *)0);
5567b76f BJ	165	exit(0);
	166	}
	167
	168	/*
86a16a64 SL	169	* writer: write to remote: 0 -> line.
	170	* ~. terminate
	171	* ~^Z suspend rlogin process.
b5f23952	172	* ~^Y suspend rlogin process, but leave reader alone.
5567b76f	173	*/
86a16a64	174	writer()
5567b76f	175	{
86a16a64 SL	176	char b[600], c;
86a16a64 SL	177	register char *p;
5567b76f	178
86a16a64 SL	179	top:
	180	p = b;
	181	while (read(0, &c, 1) > 0) {
	182	int local;
5567b76f	183
86a16a64 SL	184	if (eight == 0)
	185	c &= 0177;
	186	/*
	187	* If we're at the beginning of the line
	188	* and recognize a command character, then
	189	* we echo locally. Otherwise, characters
	190	* are echo'd remotely. If the command
	191	* character is doubled, this acts as a
	192	* force and local echo is suppressed.
	193	*/
	194	if (p == b)
	195	local = (c == cmdchar);
	196	if (p == b + 1 && *b == cmdchar)
	197	local = (c != cmdchar);
	198	if (!local) {
	199	if (write(rem, &c, 1) == 0) {
	200	prf("line gone");
	201	return;
	202	}
	203	if (eight == 0)
	204	c &= 0177;
	205	} else {
	206	if (c == 0177)
c64cdfb4	207	c = deftc.tc_kill;
86a16a64	208	if (c == '\r' \|\| c == '\n') {
c64cdfb4	209	char cmdc = b[1];
86a16a64	210
c64cdfb4	211	if (cmdc == '.' \|\| cmdc == deftc.tc_eofc) {
86a16a64 SL	212	write(0, CRLF, sizeof(CRLF));
86a16a64 SL	213	return;
c64cdfb4 SL	214	}
	215	if (cmdc == deftc.tc_suspc \|\|
	216	cmdc == deftc.tc_dsuspc) {
86a16a64 SL	217	write(0, CRLF, sizeof(CRLF));
	218	mode(0);
	219	signal(SIGCHLD, SIG_IGN);
c64cdfb4 SL	220	kill(cmdc == deftc.tc_suspc ?
c64cdfb4 SL	221	0 : getpid(), SIGTSTP);
86a16a64 SL	222	signal(SIGCHLD, done);
	223	mode(1);
	224	goto top;
5567b76f	225	}
86a16a64 SL	226	*p++ = c;
	227	write(rem, b, p - b);
	228	goto top;
5567b76f	229	}
86a16a64	230	write(1, &c, 1);
5567b76f	231	}
86a16a64	232	*p++ = c;
c64cdfb4	233	if (c == deftc.tc_erase) {
86a16a64 SL	234	p -= 2;
	235	if (p < b)
	236	goto top;
5567b76f	237	}
c64cdfb4	238	if (c == deftc.tc_kill \|\| c == 0177 \|\| c == deftc.tc_eofc \|\|
86a16a64 SL	239	c == '\r' \|\| c == '\n')
86a16a64 SL	240	goto top;
5567b76f	241	}
5567b76f BJ	242	}
5567b76f BJ	243
5567b76f BJ	244	oob()
5567b76f BJ	245	{
4659bf8e	246	int out = 1+1, atmark;
86a16a64	247	char waste[BUFSIZ], mark;
5567b76f BJ	248
5567b76f BJ	249	signal(SIGURG, oob);
86a16a64	250	ioctl(1, TIOCFLUSH, (char *)&out);
5567b76f	251	for (;;) {
4659bf8e	252	if (ioctl(rem, SIOCATMARK, &atmark) < 0) {
5567b76f BJ	253	perror("ioctl");
	254	break;
	255	}
4659bf8e	256	if (atmark)
5567b76f	257	break;
86a16a64	258	(void) read(rem, waste, sizeof (waste));
5567b76f	259	}
c6c678f1	260	recv(rem, &mark, 1, SOF_OOB);
5567b76f	261	if (mark & TIOCPKT_NOSTOP) {
c64cdfb4 SL	262	notc.tc_stopc = -1;
	263	notc.tc_startc = -1;
	264	ioctl(0, TIOCCSET, (char *)&notc);
5567b76f BJ	265	}
5567b76f BJ	266	if (mark & TIOCPKT_DOSTOP) {
c64cdfb4 SL	267	notc.tc_stopc = deftc.tc_stopc;
	268	notc.tc_startc = deftc.tc_startc;
	269	ioctl(0, TIOCCSET, (char *)&notc);
5567b76f BJ	270	}
	271	}
	272
86a16a64 SL	273	/*
	274	* reader: read from remote: line -> 1
	275	*/
	276	reader()
5567b76f	277	{
86a16a64 SL	278	char rb[BUFSIZ];
86a16a64 SL	279	register int cnt;
5567b76f	280
86a16a64	281	signal(SIGURG, oob);
5567b76f	282	{ int pid = -getpid();
86a16a64	283	ioctl(rem, SIOCSPGRP, (char *)&pid); }
5567b76f	284	for (;;) {
86a16a64	285	cnt = read(rem, rb, sizeof (rb));
5567b76f	286	if (cnt <= 0) {
86a16a64	287	if (errno == EINTR)
5567b76f	288	continue;
5567b76f BJ	289	break;
5567b76f BJ	290	}
86a16a64	291	write(1, rb, cnt);
5567b76f BJ	292	}
	293	}
	294
5567b76f BJ	295	mode(f)
5567b76f BJ	296	{
c64cdfb4 SL	297	struct ttychars *tc;
c64cdfb4 SL	298	int flags;
86a16a64	299
c64cdfb4 SL	300	ioctl(0, TIOCGET, (char *)&flags);
	301	switch (f) {
	302
	303	case 0:
	304	flags &= ~CBREAK;
	305	flags \|= defflags;
	306	tc = &deftc;
	307	break;
	308
	309	case 1:
	310	flags \|= CBREAK;
	311	flags &= ~defflags;
	312	tc = &notc;
	313	break;
	314
	315	default:
	316	return;
5567b76f	317	}
c64cdfb4 SL	318	ioctl(0, TIOCSET, (char *)&flags);
c64cdfb4 SL	319	ioctl(0, TIOCCSET, (char *)tc);
5567b76f BJ	320	}
5567b76f BJ	321
86a16a64	322	/VARARGS/
5567b76f	323	prf(f, a1, a2, a3)
86a16a64	324	char *f;
5567b76f BJ	325	{
	326	fprintf(stderr, f, a1, a2, a3);
	327	fprintf(stderr, CRLF);
	328	}
	329
86a16a64	330	lostpeer()
5567b76f	331	{
86a16a64 SL	332	signal(SIGPIPE, SIG_IGN);
	333	prf("\007Lost connection");
	334	done();
5567b76f	335	}