![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xi_src.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / tests / netccitt|
Return to xi_src.c CVS log | Up to [Net/2] / Net2 / tests / netccitt |
1.1 root 1: /*-
2: * Copyright (c) 1988, 1991 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: * 3. All advertising materials mentioning features or use of this software
14: * must display the following acknowledgement:
15: * This product includes software developed by the University of
16: * California, Berkeley and its contributors.
17: * 4. Neither the name of the University nor the names of its contributors
18: * may be used to endorse or promote products derived from this software
19: * without specific prior written permission.
20: *
21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31: * SUCH DAMAGE.
32: */
33:
34: #ifndef lint
35: char copyright[] =
36: "@(#) Copyright (c) 1988, 1991 The Regents of the University of California.\n\
37: All rights reserved.\n";
38: #endif /* not lint */
39:
40: #ifndef lint
41: static char sccsid[] = "@(#)xi_src.c 7.5 (Berkeley) 5/7/91";
42: #endif /* not lint */
43:
44: /*
45: * This is a test program to be a source for X.25 connections.
46: */
47: #include <sys/types.h>
48: #include <sys/socket.h>
49: #include <sys/uio.h>
50: #include <sys/ioctl.h>
51: #include <net/route.h>
52: #include <net/if.h>
53: #include <netccitt/x25.h>
54:
55: #include <stdio.h>
56: #include <errno.h>
57: #include <ctype.h>
58: #include <netdb.h>
59:
60:
61: #define dbprintf if(verbose)printf
62: #define try(a,b,c) {x = (a b);dbprintf("%s%s returns %d\n",c,"a",x);\
63: if (x < 0) {perror("a"); exit(1);}}
64:
65: fd_set readfds, writefds, exceptfds;
66: long size, count = 10;
67: int verbose = 1, selectp, type = SOCK_STREAM, nobuffs, errno, playtag = 0;
68: int verify = 0, mqdata;
69: short portnumber = 3000;
70: struct sockaddr_x25 to;
71: char your_it[] = "You're it!";
72: char *port, *conndata, data_msg[2048];
73: struct iovec iov[1] = {data_msg};
74: union {
75: struct {
76: struct cmsghdr cmhdr;
77: char cmdata[128 - sizeof (struct cmsghdr)];
78: } cm;
79: char data[128];
80: } cm;
81: struct msghdr msg = { 0, 0, iov, 1, 0, 0, 0};
82:
83: main(argc, argv)
84: int argc;
85: char *argv[];
86: {
87: register char **av = argv;
88: register char *cp;
89: u_long len;
90: int handy;
91:
92: while(--argc > 0) {
93: av++;
94: if (strcmp(*av,"dest")==0) {
95: av++;
96: ccitt_addr(*av, &to);
97: argc--;
98: } else if (strcmp(*av,"count")==0) {
99: av++;
100: sscanf(*av,"%ld",&count);
101: argc--;
102: } else if (strcmp(*av,"size")==0) {
103: av++;
104: sscanf(*av,"%ld",&size);
105: }
106: }
107: xisrc();
108: }
109:
110: xisrc() {
111: int x, s, pid, on = 1, flags = 8, n;
112:
113: try(socket, (AF_CCITT, type, 0),"");
114: s = x;
115:
116: /*try(setsockopt, (s, SOL_SOCKET, SO_DEBUG, &on, sizeof (on)), "");*/
117:
118: to.x25_opts.op_flags |= X25_MQBIT;
119: try(connect, (s, (struct sockaddr *) &to, to.x25_len), "");
120:
121: if (selectp) {
122: FD_ZERO(&writefds); FD_SET(s, &writefds);
123: select(1, &writefds, 0, 0, 0);
124: }
125: while (count-- > 0) {
126: if (size <= 0 && get_record(&flags) == EOF)
127: exit(0);
128: n = put_record(s, flags);
129: if (n < iov->iov_len) {
130: if (n==-1 && errno == 55) {
131: nobuffs++;
132: count++;
133: continue;
134: }
135: fprintf(stderr, "wrote %d < %d, count %d,",
136: n, iov->iov_len, count);
137: perror("due to");
138: }
139: }
140: if (playtag) {
141: printf("Tag time!\n");
142: iov->iov_base = your_it;
143: iov->iov_len = sizeof your_it;
144: sendmsg(s, &msg, MSG_EOR);
145: sendmsg(s, &msg, MSG_EOR);
146: iov->iov_base = data_msg;
147: iov->iov_len = sizeof data_msg;
148: try(recvmsg, (s, &msg, flags), " playtag ");
149: }
150: if (nobuffs) {
151: printf("looped %d times waiting for bufs\n", nobuffs);
152: }
153: }
154: int localsize;
155: char dupbuf[4096];
156:
157: put_record(s, flags)
158: int s, flags;
159: {
160: int fd, buflen;
161: char *buf;
162: int x, saved_x;
163:
164: msg.msg_flags = flags;
165: if (verbose) {
166: unsigned short *zp, *zlim;
167: if (msg.msg_controllen) {
168: zp = (unsigned short *)&(cm.cm.cmhdr.cmsg_len);
169: printf("(CMessage Type is %x) ", cm.cm.cmhdr.cmsg_type);
170: printf("CMsg data: ");
171: x = msg.msg_controllen;
172: zlim = zp + ((x + 1) / 2);
173: while (zp < zlim) printf("%x ", *zp++);
174: putchar ('\n');
175: }
176: if (iov->iov_len) {
177: printf("sending: %s %s",
178: (flags & MSG_OOB ? "(OOB Data)" : ""),
179: (flags & MSG_EOR ? "(Record Mark)" : ""));
180: x = localsize;
181: zp = (unsigned short *)data_msg;
182: zlim = zp + ((x + 1) / 2);
183: while (zp < zlim) printf("%x ", *zp++);
184: putchar ('\n');
185: }
186: }
187: if (verify) {
188: buflen = iov->iov_len;
189: bcopy(iov->iov_base, dupbuf, buflen);
190: }
191: try(sendmsg, (s, &msg, flags), " put_record ");
192: saved_x = x;
193: while (verify && buflen > 0) {
194: iov->iov_len = buflen;
195: iov->iov_base = dupbuf;
196: try(recvmsg, (s, &msg, flags), " put_record ");
197: printf("verify got %d\n", x);
198: buflen -= x;
199: }
200: msg.msg_control = 0;
201: return (saved_x);
202: }
203: int *datasize = &iov->iov_len;
204: char *cp, *cplim;
205:
206: get_control_data(type, level)
207: {
208:
209: datasize = (int *)&msg.msg_controllen;
210: cp = cm.cm.cmdata;
211: cplim = cp + sizeof(cm.cm.cmdata);
212: cm.cm.cmhdr.cmsg_level = level;
213: cm.cm.cmhdr.cmsg_type = type;
214: msg.msg_control = cm.data;
215: }
216:
217:
218:
219: get_record(flags)
220: int *flags;
221: {
222: int factor = 1, x = 0;
223: char workbuf[10240];
224: static repeatcount, repeatsize;
225:
226: if (repeatcount > 0) {
227: repeatcount--;
228: return;
229: }
230: *flags = 0;
231: *datasize = 0;
232: datasize = &iov->iov_len;
233: cp = data_msg + 1;
234: cplim = data_msg + sizeof(data_msg);
235:
236: *data_msg = 0;
237: for(;;) {
238: x = scanf("%s", workbuf);
239: if (x == EOF)
240: break;
241: if (strcmp(workbuf, "oob") == 0)
242: *flags |= MSG_OOB;
243: else if (strcmp(workbuf, "qbit") == 0)
244: *data_msg |= 0x80;
245: else if (strcmp(workbuf, "mbit") == 0)
246: *data_msg |= 0x40;
247: else if (strcmp(workbuf, "eom") == 0)
248: *flags |= MSG_EOR;
249: else if (strcmp(workbuf, "factor") == 0) {
250: x = scanf("%d", &factor);
251: if (factor <= 0) factor = 1;
252: if (x == EOF)
253: break;
254: } else if (strcmp(workbuf, "repeat") == 0) {
255: x = scanf("%d", &repeatcount);
256: if (repeatcount <= 0) repeatcount = 1;
257: if (x == EOF)
258: break;
259: } else {
260: int len = strlen(workbuf);
261: localsize = 1;
262: while ((factor-- > 0) &&
263: ((cp + len) < cplim)) {
264: strcpy(cp, workbuf);
265: cp += len;
266: localsize += len;
267: }
268: *datasize = localsize;
269: if (datasize != &iov->iov_len) {
270: *datasize += sizeof(cm.cm.cmhdr);
271: repeatsize = cm.cm.cmhdr.cmsg_len = *datasize;
272: }
273: break;
274: }
275: }
276: errno = 0;
277: return (x);
278: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.