![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cisink.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / netiso|
Return to cisink.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / netiso |
1.1 root 1: /*
2: * Copyright (c) 1989, 1990 Regents of the University of California.
3: * All rights reserved.
4: *
5: * %sccs.include.redist.c%
6: */
7: #ifndef lint
8: static char sccsid[] = "%W% (Berkeley) %G%";
9: #endif /* not lint */
10:
11: /*
12: * This is a test program to be a sink for ISO packets.
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;
40:
41: long size, count = 10, forkp, confp, echop, mynamep, verbose = 1, playtag = 0;
42: long records, dgramp = 1;
43:
44: char buf[2048];
45: char your_it[] = "You're it!";
46:
47: char *Servername;
48:
49: main(argc, argv)
50: int argc;
51: char *argv[];
52: {
53: register char **av = argv;
54: register char *cp;
55: struct iso_addr iso_addr();
56:
57: while(--argc > 0) {
58: av++;
59: if(strcmp(*av,"Servername")==0) {
60: av++;
61: Servername = *av;
62: argc--;
63: } else if (strcmp(*av,"host")==0) {
64: av++;
65: laddr.siso_addr = iso_addr(*av);
66: argc--;
67: } else if (strcmp(*av,"count")==0) {
68: av++;
69: sscanf(*av,"%ld",&count);
70: argc--;
71: } else if (strcmp(*av,"port")==0) {
72: av++;
73: sscanf(*av,"%hd",&port);
74: argc--;
75: } else if (strcmp(*av,"size")==0) {
76: av++;
77: sscanf(*av,"%ld",&size);
78: argc--;
79: }
80: }
81: if (Servername) {
82: int tlen = laddr.siso_tlen = strlen(Servername);
83: int len = TSEL(siso) + tlen - (caddr_t) &siso;
84: if (len > sizeof(*siso)) {
85: siso = (struct sockaddr_iso *)malloc(len);
86: *siso = laddr;
87: siso->siso_len = len;
88: }
89: bcopy(Servername, TSEL(siso), tlen);
90: } else {
91: port = htons(port);
92: laddr.siso_tlen = sizeof(port);
93: bcopy((char *)&port, TSEL(siso), sizeof(port));
94: }
95: tisink();
96: }
97: #define BIG 2048
98: #define MIDLIN 512
99: char readbuf[BIG];
100: struct iovec iov[1] = {
101: readbuf,
102: sizeof readbuf,
103: };
104: char name[MIDLIN];
105: union {
106: struct {
107: struct cmsghdr cmhdr;
108: char cmdata[128 - sizeof(struct cmsghdr)];
109: } cm;
110: char data[128];
111: } cbuf;
112: #define control cbuf.data
113: struct msghdr msghdr = {
114: name, sizeof(name),
115: iov, sizeof(iov)/sizeof(iov[1]),
116: control, sizeof control,
117: 0 /* flags */
118: };
119:
120: tisink()
121: {
122: int x, s, pid, on = 1, loop = 0, n, ns;
123: extern int errno;
124: int socktype = (dgramp ? SOCK_DGRAM : SOCK_SEQPACKET);
125: int addrlen = sizeof(faddr);
126:
127: try(socket, (AF_ISO, socktype, 0),"");
128:
129: s = x;
130:
131: try(bind, (s, (struct sockaddr *) siso, siso->siso_len), "");
132:
133: /*try(setsockopt, (s, SOL_SOCKET, SO_DEBUG, &on, sizeof (on)), ""); */
134: if (dgramp) {
135: ns = s;
136: pid = getpid();
137: goto dgram1;
138: }
139:
140: try(listen, (s, 5), "");
141: for(;;) {
142: int child;
143: char childname[50];
144:
145: try (accept, (s, &faddr, &addrlen), "");
146: ns = x;
147: dumpit("connection from:", &faddr, sizeof faddr);
148: if (mynamep) {
149: addrlen = sizeof(faddr);
150: try (getsockname, (ns, &faddr, &addrlen), "");
151: dumpit("connected as:", &faddr, addrlen);
152: }
153: loop++;
154: if(loop > 3) myexit(0);
155: if (forkp) {
156: try(fork, (), "");
157: } else
158: x = 0;
159: pid = getpid();
160: if (x == 0) {
161: long n, count = 0, cn, flags;
162: records = 0;
163: if (confp) {
164: msghdr.msg_iovlen = 0;
165: msghdr.msg_namelen = 0;
166: msghdr.msg_controllen =
167: cbuf.cm.cmhdr.cmsg_len = sizeof (cbuf.cm.cmhdr);
168: cbuf.cm.cmhdr.cmsg_level = SOL_TRANSPORT;
169: cbuf.cm.cmhdr.cmsg_type = TPOPT_CFRM_DATA;
170: n = sendmsg(ns, &msghdr, 0);
171: if (n <= 0) {
172: printf("confirm: errno is %d\n", errno);
173: fflush(stdout);
174: perror("Confirm error");
175: } else {
176: dbprintf("confim ok\n");
177: }
178: sleep(10);
179: }
180: for (;;) {
181: dgram1:
182: msghdr.msg_iovlen = 1;
183: msghdr.msg_controllen = sizeof(control);
184: msghdr.msg_namelen = (dgramp ? (sizeof name) : 0);
185: iov->iov_len = sizeof(readbuf);
186: n = recvmsg(ns, &msghdr, 0);
187: flags = msghdr.msg_flags;
188: count++;
189: dbprintf("recvmsg from pid %d got %d ctl %d flags %x\n",
190: pid, n, (cn = msghdr.msg_controllen), flags);
191: fflush(stdout);
192: if (dgramp && msghdr.msg_namelen && verbose)
193: dumpit("from:\n", name, msghdr.msg_namelen);
194: if (cn && verbose)
195: dumpit("control data:\n", control, cn);
196: if (n <= 0) {
197: fprintf(stderr, "errno is %d\n", errno);
198: perror("recvmsg");
199: /*sleep (10);*/
200: break;
201: } else {
202: if (verbose)
203: dumpit("data:\n", readbuf, n);
204: }
205: if (echop) {
206: n = answerback(flags, n, ns);
207: }
208: if (flags & MSG_EOR)
209: records++;
210: if (playtag && n == sizeof(your_it) && (flags & MSG_EOR)
211: && bcmp(readbuf, your_it, n) == 0) {
212: printf("Answering back!!!!\n");
213: answerback(flags, n, ns);
214: answerback(flags, n, ns);
215: }
216: errno = 0;
217: }
218: }
219: myexit(0);
220: }
221: }
222: answerback(flags, n, ns)
223: {
224: msghdr.msg_controllen = 0;
225: msghdr.msg_iovlen = 1;
226: iov->iov_len = n;
227: n = sendmsg(ns, &msghdr, flags);
228: dbprintf("echoed %d\n", n);
229: return n;
230: }
231:
232: dumpit(what, where, n)
233: char *what; unsigned short *where; int n;
234: {
235: unsigned short *s = where;
236: unsigned short *z = where + (n+1)/2;
237: int count = 0;
238: printf(what);
239: while(s < z) {
240: count++;
241: printf("%x ",*s++);
242: if ((count & 15) == 0)
243: putchar('\n');
244: }
245: if (count & 15)
246: putchar('\n');
247: fflush(stdout);
248: }
249: myexit(n)
250: {
251: fflush(stderr);
252: printf("got %d records\n", records);
253: fflush(stdout);
254: exit(n);
255: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.