![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cisrc.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 cisrc.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 source for ISO packets.
13: */
14: #include <sys/types.h>
15: #include <sys/socket.h>
16: #include <sys/uio.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_user.h>
23:
24: #include <stdio.h>
25: #include <errno.h>
26: #include <ctype.h>
27: #include <netdb.h>
28:
29:
30: #define dbprintf if(verbose)printf
31: #define try(a,b,c) {x = (a b);dbprintf("%s%s returns %d\n",c,"a",x);\
32: if (x < 0) {perror("a"); exit(1);}}
33:
34: struct iso_addr eon = {20, 0x47, 0, 6, 3, 0, 0, 0, 25 /*EGP for Berkeley*/};
35: struct sockaddr_iso to_s = { sizeof(to_s), AF_ISO }, *to = &to_s;
36: struct sockaddr_iso old_s = { sizeof(to_s), AF_ISO }, *old = &old_s;
37: fd_set readfds, writefds, exceptfds;
38: long size, count = 10;
39: int verbose = 1, selectp, type = SOCK_SEQPACKET, nobuffs, errno, playtag = 0;
40: int verify = 0, dgramp = 1, debug = 0;
41: short portnumber = 3000;
42: char your_it[] = "You're it!";
43: char *Servername, *conndata, data_msg[2048];
44: char Serverbuf[128];
45: char name[128];
46: struct iovec iov[1] = {data_msg};
47: union {
48: struct {
49: struct cmsghdr cmhdr;
50: char cmdata[128 - sizeof(struct cmsghdr)];
51: } cm;
52: char data[128];
53: } cm;
54: struct msghdr msg = { 0, 0, iov, 1, 0, 0, 0};
55:
56: main(argc, argv)
57: int argc;
58: char *argv[];
59: {
60: register char **av = argv;
61: register char *cp;
62: struct iso_addr iso_addr();
63: u_long len;
64: int handy;
65:
66: while(--argc > 0) {
67: av++;
68: if(strcmp(*av,"Servername")==0) {
69: av++;
70: Servername = *av;
71: argc--;
72: } else if(strcmp(*av,"conndata")==0) {
73: av++;
74: conndata = *av;
75: argc--;
76: } else if(strcmp(*av,"host")==0) {
77: av++;
78: to_s.siso_addr = iso_addr(*av);
79: argc--;
80: } else if(strcmp(*av,"port")==0) {
81: av++;
82: sscanf(*av,"%hd",&portnumber);
83: argc--;
84: } else if(strcmp(*av,"count")==0) {
85: av++;
86: sscanf(*av,"%ld",&count);
87: argc--;
88: } else if(strcmp(*av,"size")==0) {
89: av++;
90: sscanf(*av,"%ld",&size);
91: iov->iov_len = size;
92: } else if (strcmp(*av,"eon") == 0) {
93: unsigned long l, inet_addr();
94:
95: l = inet_addr(*++av); argc--;
96: to_s.siso_addr = eon;
97: bcopy((char *)&l, &to_s.siso_data[15], 4);
98: }
99: }
100: maketoaddr();
101: tisrc();
102: }
103:
104: maketoaddr()
105: {
106: if (Servername) {
107: int tlen = strlen(Servername);
108: int len = tlen + TSEL(to) - (caddr_t) to;
109: if (len < sizeof(*to)) len = sizeof(*to);
110: if (len > to->siso_len) {
111: if (old != &old_s) free(old);
112: old = (struct sockaddr_iso *)malloc(len);
113: *old = *to; /* We dont care if all old tsel is copied*/
114: old->siso_len = len;
115: if (to != &to_s) free(to);
116: to = (struct sockaddr_iso *)malloc(len);
117: }
118: bcopy(Servername, TSEL(old), tlen);
119: } else {
120: old->siso_tlen = sizeof(portnumber);
121: portnumber = htons(portnumber);
122: bcopy((char *)&portnumber, TSEL(old), sizeof(portnumber));
123: }
124: bcopy(old, to, old->siso_len);
125: }
126:
127:
128: tisrc() {
129: int x, s, pid, on = 1, flags = 8, n;
130:
131: if (dgramp) type = SOCK_DGRAM;
132: try(socket, (AF_ISO, type, 0),"");
133: s = x;
134:
135: if (debug)
136: try(setsockopt, (s, SOL_SOCKET, SO_DEBUG, &on, sizeof on), "");
137: if (dgramp == 0) {
138: if (conndata)
139: doconndata(s);
140: try(connect, (s, (struct sockaddr *) to, to->siso_len), "");
141: }
142: if (selectp) {
143: FD_ZERO(&writefds); FD_SET(s, &writefds);
144: select(1, &writefds, 0, 0, 0);
145: }
146: while (count-- > 0) {
147: if (size <= 0 && get_record(&flags) == EOF)
148: exit(0);
149: n = put_record(s, flags);
150: if (n < iov->iov_len) {
151: if (n==-1 && errno == 55) {
152: nobuffs++;
153: count++;
154: continue;
155: }
156: fprintf(stderr, "wrote %d < %d, count %d,",
157: n, iov->iov_len, count);
158: perror("due to");
159: }
160: }
161: if (playtag) {
162: printf("Tag time!\n");
163: iov->iov_base = your_it;
164: iov->iov_len = sizeof your_it;
165: sendmsg(s, &msg, MSG_EOR);
166: sendmsg(s, &msg, MSG_EOR);
167: iov->iov_base = data_msg;
168: iov->iov_len = sizeof data_msg;
169: try(recvmsg, (s, &msg, flags), " playtag ");
170: }
171: if(nobuffs) {
172: printf("looped %d times waiting for bufs\n", nobuffs);
173: }
174: }
175: int localsize;
176: char dupbuf[4096];
177:
178: put_record(s, flags)
179: int s, flags;
180: {
181: int fd, buflen;
182: char *buf;
183: int x, saved_x;
184:
185: msg.msg_flags = flags;
186: if (verbose) {
187: if (msg.msg_controllen) {
188: printf("(CMessage Type is %x) ", cm.cm.cmhdr.cmsg_type);
189: dumpit("CMsg data:\n", &msg.msg_control, msg.msg_controllen);
190: }
191: if (iov->iov_len) {
192: printf("sending: %s %s",
193: (flags & MSG_OOB ? "(OOB Data)" : ""),
194: (flags & MSG_EOR ? "(Record Mark)" : ""));
195: dumpit("data: ", data_msg, localsize);
196: }
197: }
198: if (verify) {
199: buflen = iov->iov_len;
200: bcopy(iov->iov_base, dupbuf, buflen);
201: }
202: if (dgramp) {
203: msg.msg_name = (caddr_t)to;
204: msg.msg_namelen = to->siso_len;
205: }
206: try(sendmsg, (s, &msg, flags), " put_record ");
207: saved_x = x;
208: while (verify && buflen > 0) {
209: iov->iov_len = buflen;
210: iov->iov_base = dupbuf;
211: try(recvmsg, (s, &msg, flags), " put_record ");
212: if (dgramp) {
213: if (msg.msg_namelen)
214: dumpit("from: ", to, msg.msg_namelen);
215: msg.msg_namelen = old->siso_len;
216: }
217: printf("verify got %d\n", x);
218: buflen -= x;
219: }
220: bcopy(old, to, old->siso_len);
221: msg.msg_control = 0;
222: return (saved_x);
223: }
224: dumpit(what, where, n)
225: char *what; unsigned short *where; int n;
226: {
227: unsigned short *s = where;
228: unsigned short *z = where + (n+1)/2;
229: int count = 0;
230: if (verbose == 0)
231: return;
232: printf(what);
233: while(s < z) {
234: count++;
235: printf("%x ",*s++);
236: if ((count & 15) == 0)
237: putchar('\n');
238: }
239: if (count & 15)
240: putchar('\n');
241: fflush(stdout);
242: }
243: int *datasize = &iov->iov_len;
244: char *cp, *cplim;
245:
246: get_control_data(type)
247: {
248:
249: datasize = &msg.msg_controllen;
250: cp = cm.cm.cmdata;
251: cplim = cp + sizeof(cm.cm.cmdata);
252: cm.cm.cmhdr.cmsg_level = SOL_TRANSPORT;
253: cm.cm.cmhdr.cmsg_type = type;
254: msg.msg_control = cm.data;
255: }
256:
257: doconndata(s)
258: {
259: get_control_data(TPOPT_CONN_DATA);
260: *datasize = strlen(conndata) + sizeof(cm.cm.cmhdr);
261: cm.cm.cmhdr.cmsg_len = *datasize;
262: bcopy(conndata, cp, *datasize);
263: put_record(s, 0);
264: }
265:
266: get_altbuf(addrbuf)
267: char *addrbuf;
268: {
269: if (dgramp == 0) {
270: printf("illegal option for stream\n");
271: return 1;
272: }
273: return (scanf("%s", addrbuf) == EOF ? 1 : 0);
274: }
275:
276: get_record(flags)
277: int *flags;
278: {
279: int factor = 1, x = 0, newaddr = 0;
280: char workbuf[10240];
281: char addrbuf[128];
282:
283: *flags = 0;
284: *datasize = 0;
285: datasize = &iov->iov_len;
286: cp = data_msg;
287: cplim = cp + sizeof(data_msg);
288:
289: for(;;) {
290: x = scanf("%s", workbuf);
291: if (x == EOF)
292: break;
293: if (strcmp(workbuf, "disc") == 0)
294: x = get_control_data(TPOPT_DISC_DATA);
295: else if (strcmp(workbuf, "cfrm") == 0)
296: x = get_control_data(TPOPT_CFRM_DATA);
297: else if (strcmp(workbuf, "oob") == 0)
298: *flags |= MSG_OOB;
299: else if (strcmp(workbuf, "eom") == 0)
300: *flags |= MSG_EOR;
301: else if (strcmp(workbuf, "host") == 0) {
302: if (get_altbuf(addrbuf))
303: break;
304: to->siso_addr = iso_addr(addrbuf);
305: newaddr = 1;
306: } else if (strcmp(workbuf, "Servername") == 0) {
307: if (get_altbuf(Serverbuf))
308: break;
309: Servername = Serverbuf;
310: newaddr = 1;
311: } else if (strcmp(workbuf, "port") == 0) {
312: x = scanf("%hd", &portnumber);
313: if (x == EOF)
314: break;
315: Servername = 0;
316: newaddr = 1;
317: } else if (strcmp(workbuf, "factor") == 0) {
318: x = scanf("%d", &factor);
319: if (factor <= 0) factor = 1;
320: if (x == EOF)
321: break;
322: } else {
323: int len = strlen(workbuf);
324: localsize = 0;
325: while ((factor-- > 0) &&
326: ((cp + len) < cplim)) {
327: strcpy(cp, workbuf);
328: cp += len;
329: localsize += len;
330: }
331: *datasize = localsize;
332: if (datasize != &iov->iov_len) {
333: *datasize += sizeof(cm.cm.cmhdr);
334: cm.cm.cmhdr.cmsg_len = *datasize;
335: }
336: break;
337: }
338: }
339: errno = 0;
340: if (newaddr)
341: maketoaddr();
342: return (x);
343: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.