[unix-history] / usr / src / sys / tests / netiso / tisink.c

/*
 * Copyright (c) 1988, 1990 Regents of the University of California.
 * All rights reserved.
 *
 * %sccs.include.redist.c%
 */
#ifndef lint
static char sccsid[] = "@(#)tisink.c	7.4 (Berkeley) %G%";
#endif /* not lint */

/*
 * This is a test program to be a sink for TP4 connections.
 */
#include <sys/param.h>
#include <sys/uio.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <net/route.h>
#include <net/if.h>
#define  TCPT_NTIMERS 4
#include <netiso/iso.h>
#include <netiso/tp_param.h>
#include <netiso/tp_user.h>

#include <stdio.h>
#include <errno.h>
#include <ctype.h>
#include <netdb.h>


#define dbprintf if(verbose)printf
#define try(a,b,c) {x = (a b); dbprintf("%s%s returns %d\n",c,"a",x);\
		if(x<0) {perror("a"); myexit(0);}}


struct  ifreq ifr;
short port = 3000;
struct  sockaddr_iso faddr, laddr = { sizeof(laddr), AF_ISO };
struct  sockaddr_iso *siso = &laddr;
char **xenvp;

long size, count = 10, forkp, confp, echop, mynamep, verbose = 1, playtag = 0;
long records, intercept = 0, isode_mode;

char buf[2048];
char your_it[] = "You're it!";

char *Servername;

main(argc, argv, envp)
int argc;
char *argv[];
char *envp[];
{
	register char **av = argv;
	register char *cp;
	struct iso_addr iso_addr();

	xenvp = envp;
	while(--argc > 0) {
		av++;
		if(strcmp(*av,"Servername")==0) {
			av++;
			Servername = *av;
			argc--;
		} else if (strcmp(*av,"host")==0) {
			av++;
			laddr.siso_addr = iso_addr(*av);
			argc--;
		} else if (strcmp(*av,"count")==0) {
			av++;
			sscanf(*av,"%ld",&count);
			argc--;
		} else if (strcmp(*av,"port")==0) {
			av++;
			sscanf(*av,"%hd",&port);
			argc--;
		} else if (strcmp(*av,"size")==0) {
			av++;
			sscanf(*av,"%ld",&size);
			argc--;
		} else if (strcmp(*av, "intercept")==0) {
			intercept++;
		}
	}
	if (Servername) {
		int tlen = laddr.siso_tlen = strlen(Servername);
		int len =  TSEL(siso) + tlen - (caddr_t) &siso;
		if (len > sizeof(*siso)) {
			siso = (struct sockaddr_iso *)malloc(len);
			*siso = laddr;
			siso->siso_len = len;
		}
		bcopy(Servername, TSEL(siso), tlen);
	} else {
		port = htons(port);
		laddr.siso_tlen = sizeof(port);
		bcopy((char *)&port, TSEL(siso), sizeof(port));
	}
	tisink();
}
#define BIG 2048
#define MIDLIN 512
char readbuf[BIG];
struct iovec iov[1] = {
	readbuf,
	sizeof readbuf,
};
char name[MIDLIN];
union {
    struct {
	    struct cmsghdr	cmhdr;
	    char		cmdata[128 - sizeof(struct cmsghdr)];
    } cm;
    char data[128];
} cbuf;
#define control cbuf.data
struct msghdr msghdr = {
	name, sizeof(name),
	iov, sizeof(iov)/sizeof(iov[1]),
	control, sizeof control,
	0 /* flags */
};

tisink()
{
	int x, s, pid, on = 1, loop = 0, n;
	extern int errno;

	try(socket, (AF_ISO, SOCK_SEQPACKET, 0),"");

	s = x;

	try(bind, (s, (struct sockaddr *) siso, siso->siso_len), "");

	/*try(setsockopt, (s, SOL_SOCKET, SO_DEBUG, &on, sizeof (on)), ""); */

	try(listen, (s, 5), "");
	if (intercept) {
	    try(setsockopt,
		(s, SOL_TRANSPORT, TPOPT_INTERCEPT, &on, sizeof(on)), "");
	}
	for(;;) {
		int child, ns;
		int addrlen = sizeof(faddr);
		char childname[50];

		try (accept, (s, &faddr, &addrlen), "");
		ns = x;
		dumpit("connection from:", &faddr, sizeof faddr);
		if (mynamep || intercept) {
			addrlen = sizeof(faddr);
			try (getsockname, (ns, &faddr, &addrlen), "");
			dumpit("connected as:", &faddr, addrlen);
		}
		loop++;
		if (loop > 3) myexit(0);
		if (forkp) {
			try(fork, (), "");
		} else
			x = 0;
		if (x == 0)  {
		    long n, count = 0, cn, flags;
		    records = 0;
		    if (confp) {
			msghdr.msg_iovlen = 0;
			msghdr.msg_namelen = 0;
			msghdr.msg_controllen = 
			    cbuf.cm.cmhdr.cmsg_len = sizeof (cbuf.cm.cmhdr);
			cbuf.cm.cmhdr.cmsg_level = SOL_TRANSPORT;
			cbuf.cm.cmhdr.cmsg_type = TPOPT_CFRM_DATA;
			n = sendmsg(ns, &msghdr, 0);
			if (n <= 0) {
				printf("confirm: errno is %d\n", errno);
				fflush(stdout);
				perror("Confirm error");
			} else {
				dbprintf("confim ok\n");
			}
			sleep(10);
		    }
#ifdef ISODE_MODE
		    if (isode_mode) {
			static char fdbuf[10];
			static char *nargv[4] =
			    {"/usr/sbin/isod.tsap", fdbuf, "", 0};
			sprintf(fdbuf, "Z%d", ns);
			old_isod_main(3, nargv, xenvp);
		    } else
#endif
		    for (;;) {
			msghdr.msg_iovlen = 1;
			msghdr.msg_controllen = sizeof(control);
			iov->iov_len = sizeof(readbuf);
			n = recvmsg(ns, &msghdr, 0);
			flags = msghdr.msg_flags;
			count++;
			dbprintf("recvmsg from child %d got %d ctl %d flags %x\n",
				    getpid(), n, (cn = msghdr.msg_controllen),
					flags);
			fflush(stdout);
			if (cn && verbose)
				dumpit("control data:\n", control, cn);
			if (n < 0) {
				fprintf(stderr, "errno is %d\n", errno);
				perror("recvmsg");
				/*sleep (10);*/
				break;
			} else {
				if (verbose)
					dumpit("data:\n", readbuf, n);
			}
			if (echop) {
				n = answerback(flags, n, ns);
			}
			if (flags & MSG_EOR)
				records++;
			if (playtag && n == sizeof(your_it) && (flags & MSG_EOR)
			    && bcmp(readbuf, your_it, n) == 0) {
				printf("Answering back!!!!\n");
				answerback(flags, n, ns);
				answerback(flags, n, ns);
			}
			errno = 0;
		    }
		}
		myexit(0);
	}
}
answerback(flags, n, ns)
{
	msghdr.msg_controllen = 0;
	msghdr.msg_iovlen = 1;
	iov->iov_len = n;
	n = sendmsg(ns, &msghdr, flags);
	dbprintf("echoed %d\n", n);
	return n;
}

dumpit(what, where, n)
char *what; unsigned short *where; int n;
{
	unsigned short *s = where;
	unsigned short *z = where + (n+1)/2;
	int count = 0;
	printf(what);
	while(s < z) {
		count++;
		printf("%x ",*s++);
		if ((count & 15) == 0)
			putchar('\n');
	}
	if (count & 15)
		putchar('\n');
	fflush(stdout);
}
myexit(n)
{
	fflush(stderr);
	printf("got %d records\n", records);
	fflush(stdout);
	exit(n);
}
Commit	Line	Data
b160707d KS	1	/*
	2	* Copyright (c) 1988, 1990 Regents of the University of California.
	3	* All rights reserved.
	4	*
	5	* %sccs.include.redist.c%
	6	*/
	7	#ifndef lint
d21b31b2	8	static char sccsid[] = "@(#)tisink.c 7.4 (Berkeley) %G%";
b160707d KS	9	#endif /* not lint */
	10
	11	/*
	12	* This is a test program to be a sink for TP4 connections.
	13	*/
	14	#include <sys/param.h>
	15	#include <sys/uio.h>
	16	#include <sys/socket.h>
	17	#include <sys/ioctl.h>
	18	#include <net/route.h>
	19	#include <net/if.h>
	20	#define TCPT_NTIMERS 4
	21	#include <netiso/iso.h>
	22	#include <netiso/tp_param.h>
	23	#include <netiso/tp_user.h>
	24
	25	#include <stdio.h>
	26	#include <errno.h>
	27	#include <ctype.h>
	28	#include <netdb.h>
	29
	30
	31	#define dbprintf if(verbose)printf
	32	#define try(a,b,c) {x = (a b); dbprintf("%s%s returns %d\n",c,"a",x);\
	33	if(x<0) {perror("a"); myexit(0);}}
	34
	35
	36	struct ifreq ifr;
	37	short port = 3000;
	38	struct sockaddr_iso faddr, laddr = { sizeof(laddr), AF_ISO };
	39	struct sockaddr_iso *siso = &laddr;
d21b31b2	40	char **xenvp;
b160707d KS	41
b160707d KS	42	long size, count = 10, forkp, confp, echop, mynamep, verbose = 1, playtag = 0;
d21b31b2	43	long records, intercept = 0, isode_mode;
b160707d KS	44
	45	char buf[2048];
	46	char your_it[] = "You're it!";
	47
	48	char *Servername;
	49
d21b31b2	50	main(argc, argv, envp)
b160707d KS	51	int argc;
b160707d KS	52	char *argv[];
d21b31b2	53	char *envp[];
b160707d KS	54	{
	55	register char **av = argv;
	56	register char *cp;
	57	struct iso_addr iso_addr();
	58
d21b31b2	59	xenvp = envp;
b160707d KS	60	while(--argc > 0) {
	61	av++;
	62	if(strcmp(*av,"Servername")==0) {
	63	av++;
	64	Servername = *av;
	65	argc--;
	66	} else if (strcmp(*av,"host")==0) {
	67	av++;
	68	laddr.siso_addr = iso_addr(*av);
	69	argc--;
	70	} else if (strcmp(*av,"count")==0) {
	71	av++;
	72	sscanf(*av,"%ld",&count);
	73	argc--;
	74	} else if (strcmp(*av,"port")==0) {
	75	av++;
	76	sscanf(*av,"%hd",&port);
	77	argc--;
	78	} else if (strcmp(*av,"size")==0) {
	79	av++;
	80	sscanf(*av,"%ld",&size);
	81	argc--;
896d6177 KS	82	} else if (strcmp(*av, "intercept")==0) {
896d6177 KS	83	intercept++;
b160707d KS	84	}
	85	}
	86	if (Servername) {
	87	int tlen = laddr.siso_tlen = strlen(Servername);
	88	int len = TSEL(siso) + tlen - (caddr_t) &siso;
	89	if (len > sizeof(*siso)) {
	90	siso = (struct sockaddr_iso *)malloc(len);
	91	*siso = laddr;
	92	siso->siso_len = len;
	93	}
	94	bcopy(Servername, TSEL(siso), tlen);
	95	} else {
	96	port = htons(port);
	97	laddr.siso_tlen = sizeof(port);
	98	bcopy((char *)&port, TSEL(siso), sizeof(port));
	99	}
	100	tisink();
	101	}
	102	#define BIG 2048
	103	#define MIDLIN 512
	104	char readbuf[BIG];
	105	struct iovec iov[1] = {
	106	readbuf,
	107	sizeof readbuf,
	108	};
	109	char name[MIDLIN];
	110	union {
	111	struct {
	112	struct cmsghdr cmhdr;
	113	char cmdata[128 - sizeof(struct cmsghdr)];
	114	} cm;
	115	char data[128];
	116	} cbuf;
	117	#define control cbuf.data
	118	struct msghdr msghdr = {
	119	name, sizeof(name),
	120	iov, sizeof(iov)/sizeof(iov[1]),
	121	control, sizeof control,
	122	0 /* flags */
	123	};
	124
	125	tisink()
	126	{
	127	int x, s, pid, on = 1, loop = 0, n;
	128	extern int errno;
	129
	130	try(socket, (AF_ISO, SOCK_SEQPACKET, 0),"");
	131
	132	s = x;
	133
	134	try(bind, (s, (struct sockaddr *) siso, siso->siso_len), "");
	135
	136	/try(setsockopt, (s, SOL_SOCKET, SO_DEBUG, &on, sizeof (on)), ""); /
	137
	138	try(listen, (s, 5), "");
63f88aec KS	139	if (intercept) {
	140	try(setsockopt,
	141	(s, SOL_TRANSPORT, TPOPT_INTERCEPT, &on, sizeof(on)), "");
	142	}
b160707d KS	143	for(;;) {
	144	int child, ns;
	145	int addrlen = sizeof(faddr);
	146	char childname[50];
	147
	148	try (accept, (s, &faddr, &addrlen), "");
	149	ns = x;
	150	dumpit("connection from:", &faddr, sizeof faddr);
896d6177	151	if (mynamep \|\| intercept) {
b160707d KS	152	addrlen = sizeof(faddr);
	153	try (getsockname, (ns, &faddr, &addrlen), "");
	154	dumpit("connected as:", &faddr, addrlen);
	155	}
	156	loop++;
	157	if (loop > 3) myexit(0);
	158	if (forkp) {
	159	try(fork, (), "");
	160	} else
	161	x = 0;
	162	if (x == 0) {
	163	long n, count = 0, cn, flags;
	164	records = 0;
	165	if (confp) {
	166	msghdr.msg_iovlen = 0;
	167	msghdr.msg_namelen = 0;
	168	msghdr.msg_controllen =
	169	cbuf.cm.cmhdr.cmsg_len = sizeof (cbuf.cm.cmhdr);
	170	cbuf.cm.cmhdr.cmsg_level = SOL_TRANSPORT;
	171	cbuf.cm.cmhdr.cmsg_type = TPOPT_CFRM_DATA;
	172	n = sendmsg(ns, &msghdr, 0);
	173	if (n <= 0) {
	174	printf("confirm: errno is %d\n", errno);
	175	fflush(stdout);
	176	perror("Confirm error");
	177	} else {
	178	dbprintf("confim ok\n");
	179	}
	180	sleep(10);
	181	}
d21b31b2 KS	182	#ifdef ISODE_MODE
	183	if (isode_mode) {
	184	static char fdbuf[10];
	185	static char *nargv[4] =
	186	{"/usr/sbin/isod.tsap", fdbuf, "", 0};
	187	sprintf(fdbuf, "Z%d", ns);
	188	old_isod_main(3, nargv, xenvp);
	189	} else
	190	#endif
b160707d KS	191	for (;;) {
	192	msghdr.msg_iovlen = 1;
	193	msghdr.msg_controllen = sizeof(control);
	194	iov->iov_len = sizeof(readbuf);
	195	n = recvmsg(ns, &msghdr, 0);
	196	flags = msghdr.msg_flags;
	197	count++;
	198	dbprintf("recvmsg from child %d got %d ctl %d flags %x\n",
	199	getpid(), n, (cn = msghdr.msg_controllen),
	200	flags);
	201	fflush(stdout);
	202	if (cn && verbose)
	203	dumpit("control data:\n", control, cn);
	204	if (n < 0) {
	205	fprintf(stderr, "errno is %d\n", errno);
	206	perror("recvmsg");
	207	/sleep (10);/
	208	break;
	209	} else {
	210	if (verbose)
	211	dumpit("data:\n", readbuf, n);
	212	}
	213	if (echop) {
	214	n = answerback(flags, n, ns);
	215	}
	216	if (flags & MSG_EOR)
	217	records++;
	218	if (playtag && n == sizeof(your_it) && (flags & MSG_EOR)
	219	&& bcmp(readbuf, your_it, n) == 0) {
	220	printf("Answering back!!!!\n");
	221	answerback(flags, n, ns);
	222	answerback(flags, n, ns);
	223	}
	224	errno = 0;
	225	}
	226	}
	227	myexit(0);
	228	}
	229	}
	230	answerback(flags, n, ns)
	231	{
	232	msghdr.msg_controllen = 0;
	233	msghdr.msg_iovlen = 1;
	234	iov->iov_len = n;
	235	n = sendmsg(ns, &msghdr, flags);
	236	dbprintf("echoed %d\n", n);
	237	return n;
	238	}
	239
	240	dumpit(what, where, n)
	241	char what; unsigned short where; int n;
	242	{
	243	unsigned short *s = where;
	244	unsigned short *z = where + (n+1)/2;
	245	int count = 0;
	246	printf(what);
	247	while(s < z) {
	248	count++;
	249	printf("%x ",*s++);
	250	if ((count & 15) == 0)
	251	putchar('\n');
	252	}
	253	if (count & 15)
	254	putchar('\n');
255	fflush(stdout);
256	}
257	myexit(n)
258	{
259	fflush(stderr);
260	printf("got %d records\n", records);
261	fflush(stdout);
262	exit(n);
263	}