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