![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bdt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / xns / xnslib|
Return to bdt.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / xns / xnslib |
1.1 root 1: /*
2: * This file contains routines useful to the applications developer who
3: * must read or write BDT data.
4: */
5:
6: /*
7: $Log: bdt.c,v $
8: * Revision 2.0 85/11/21 07:22:02 jqj
9: * 4.3BSD standard release
10: *
11: * Revision 1.4 85/03/11 16:36:38 jqj
12: * *** empty log message ***
13: *
14: * Revision 1.4 85/03/11 16:36:38 jqj
15: * Public alpha-test version, released 11 March 1985
16: *
17: * Revision 1.3 85/03/11 16:34:19 jqj
18: * Public alpha-test version, released 11 March 1985
19: *
20: * Revision 1.2 85/01/27 07:37:06 jqj
21: * finished but undebugged version
22: *
23: */
24:
25: #ifndef lint
26: static char rcsid[] = "$Header: bdt.c,v 2.0 85/11/21 07:22:02 jqj Exp $";
27: #endif
28:
29: #include <stdio.h>
30: #include <sys/time.h>
31: #include <sys/types.h> /* for socket.h and xn.h */
32: #include <sys/socket.h>
33: #include <sys/uio.h> /* for scatter/gather io */
34: #include <netns/ns.h> /* for XNS addresses and courierconnection.h */
35: #include <netns/idp.h>
36: #include <netns/sp.h> /* for spphdr */
37: #include "courier.h"
38: #include "realcourierconnection.h"
39:
40: #define MAKEVEC(idx, addr, len) our_iovec[idx].iov_base = (caddr_t)addr;\
41: our_iovec[idx].iov_len = len;
42:
43:
44:
45: int
46: BDTwrite(f,buffer,nbytes)
47: /* Call with CourierConnection*, not *(CourierConnection*) */
48: /* Semantics are much like write(), except that it returns -1
49: * if a BDT abort message arrives from receiver.
50: * Returns # of bytes actually written.
51: */
52: register CourierConnection *f;
53: char *buffer;
54: int nbytes;
55: {
56: register int n, w;
57: struct iovec our_iovec[2];
58:
59: MAKEVEC(0, &(f->sphdrOpts), sizeof(f->sphdrOpts));
60: MAKEVEC(1, buffer, SPPMAXDATA);
61:
62: if (f->bdtstate == wantdata) {
63: /* stream=BDT, EOM=FALSE, Attn=FALSE */
64: f->sphdrOpts.sp_dt = SPPSST_BDT;
65: f->sphdrOpts.sp_cc &= ~SP_EM;
66: f->bdtstate = established;
67: }
68: if (BDTabortSeen(f)) {
69: BDTabort(f); /* send end (abort) */
70: f->abortseen = FALSE; /* clear abort */
71: f->bdtstate = bdteomseen;
72: return(-1); /* truncate the stream */
73: }
74: /* ### if nbytes > SPPMAXDATA, do something intelligent? */
75: for(n = nbytes; n > SPPMAXDATA; n -= SPPMAXDATA) {
76: w = writev(f->fd, our_iovec, 2);
77: if(w < SPPMAXDATA)
78: return( w + nbytes - n);
79: our_iovec[1].iov_base += SPPMAXDATA;
80: }
81: our_iovec[1].iov_len = n;
82: w = writev(f->fd, our_iovec, 2);
83: return( w + nbytes - n);
84: }
85:
86:
87: int
88: BDTclosewrite(f)
89: /* call with CourierConnection*, not *(CourierConnection*) */
90: /* End a BDT connection. Returns 0 on success, -1 on failure.
91: */
92: register CourierConnection *f;
93: {
94:
95: f->bdtstate = bdteomseen;
96: if (BDTabortSeen(f)) {
97: BDTabort(f);
98: f->abortseen = FALSE;
99: return(-1);
100: }
101: /* stream=BDT, EOM=TRUE, Attn=FALSE */
102: f->sphdrOpts.sp_dt = SPPSST_BDT;
103: f->sphdrOpts.sp_cc |= SP_EM;
104: /* finally, send normal end in a packet of its own */
105: write(f->fd,(char*)&f->sphdrOpts,sizeof(struct sphdr));
106: return(0);
107: }
108:
109:
110: int
111: BDTread(f, buffer, nbytes)
112: /* Call with CourierConnection*, not *(CourierConnection*) */
113: /* Semantics are much like read(), except that it returns -1 on
114: * more conditions. Returns number of characters actually read,
115: * or 0 on end of message.
116: */
117: register CourierConnection *f;
118: char *buffer;
119: int nbytes;
120: {
121: register int count;
122: struct {
123: struct sphdr hdr;
124: char data[SPPMAXDATA];
125: } packbuf;
126: struct iovec our_iovec[2];
127:
128: switch (f->state) {
129: case closed:
130: case calldone:
131: fprintf(stderr,"BDTread() called while connection state = %s\n",
132: (f->state == closed) ? "closed" : "calldone");
133: exit(1);
134: /* NOTREACHED */
135: case wantversion:
136: count = recv(f->fd, (char*) &packbuf, sizeof(packbuf), MSG_PEEK)
137: - sizeof(struct sphdr);
138: while (count == 0
139: && packbuf.hdr.sp_dt == SPPSST_RPC) {
140: read(f->fd, (char*) &packbuf, sizeof(packbuf));
141: count = recv(f->fd, (char*) &packbuf, sizeof(packbuf),
142: MSG_PEEK)
143: - sizeof(struct sphdr);
144: }
145: if (count == 0)
146: /* streamtype != SPPSST_RPC, so we can't */
147: /* have a version number */
148: break;
149: /* fall out of switch, still wantversion */
150: /* ### N.B. we don't handle count==2 */
151: else if (count != (2*sizeof(Cardinal)))
152: /* must be a REJECT or ABORT message */
153: /* let someone else handle it! */
154: return(-1);
155: else {
156: /* must be a Courier version number */
157: /* read it and throw it away */
158: read(f->fd, (char*) &packbuf, sizeof(packbuf));
159: f->state = inprogress;
160: /* fall into case inprogress */
161: }
162: case inprogress:
163: switch (f->bdtstate) {
164: case wantdata:
165: count = recv(f->fd, (char*) &packbuf, sizeof(packbuf),
166: MSG_PEEK)
167: - sizeof(struct sphdr);
168: if (packbuf.hdr.sp_dt == SPPSST_RPC)
169: return(-1);
170: f->bdtstate = established;
171: /* fall through to case established */
172: case established:
173: break;
174: /* fall out of inner (and outer!) switch */
175: case bdteomseen:
176: return(0);
177: }
178: break;
179: }
180: MAKEVEC(0,&packbuf.hdr,sizeof(struct sphdr));
181: MAKEVEC(1,buffer,nbytes);
182: count = readv(f->fd,our_iovec,2) - sizeof(struct sphdr);
183: /* at this point, we've read a packet that isn't SPPSST_RPC */
184: while (TRUE) {
185: if (packbuf.hdr.sp_dt == SPPSST_END) {
186: (void) sppclosereply(f->fd);
187: f->state = closed;
188: fprintf(stderr,"SPP END received during BDT\n");
189: exit(1);
190: }
191: if (packbuf.hdr.sp_dt != SPPSST_BDT) {
192: fprintf(stderr,
193: "wrong stream type, %d, seen during BDT\n",
194: packbuf.hdr.sp_dt);
195: exit(1);
196: /* NOTREACHED */
197: }
198: if (f->abortseen || (packbuf.hdr.sp_cc & SP_OB)) {
199: f->abortseen = TRUE;
200: return(-1);
201: }
202: if (packbuf.hdr.sp_cc & SP_EM) {
203: f->bdtstate = bdteomseen;
204: /* next read will return 0 */
205: return(count);
206: }
207: if (count > 0)
208: return(count);
209: count = readv(f->fd,our_iovec,2) - sizeof(struct sphdr);
210: }
211: }
212:
213: BDTabort(f)
214: register CourierConnection *f;
215: {
216: static struct handy {
217: struct sphdr hdr;
218: char value;
219: } data;
220: /* stream=BDT, EOM=FALSE, Attn=TRUE */
221: data.hdr.sp_dt = SPPSST_BDT;
222: data.hdr.sp_cc = SP_EM;
223: data.value = 1; /* BDT abort data value */
224: send(f->fd, &data, sizeof(data), MSG_OOB);
225: f->bdtstate = bdteomseen;
226: f->abortseen = TRUE;
227: }
228:
229:
230: BDTabortSeen(f)
231: register CourierConnection *f;
232: {
233: struct {
234: struct sphdr hdr;
235: Unspecified data[MAXWORDS];
236: } packbuf;
237: int fdmask;
238: register int count;
239: static struct timeval timeout = {0,0};
240:
241: fdmask = 1<<(f->fd);
242: /* ### code here for OOB signalling! */
243: while (select(f->fd+1,&fdmask,(int*)NULL,(int*)NULL,&timeout) > 0
244: && (count = recv(f->fd,(char*)&packbuf, sizeof(packbuf),
245: MSG_PEEK) - sizeof(struct sphdr)) > 0) {
246: if (packbuf.hdr.sp_dt == SPPSST_BDT
247: && (packbuf.hdr.sp_dt & SP_OB)
248: && count == 1) {
249: read(f->fd, (char*)&packbuf, sizeof(packbuf));
250: f->abortseen = TRUE;
251: return(TRUE);
252: }
253: else if (count == 0)
254: read(f->fd, (char*)&packbuf, sizeof(packbuf));
255: else return(FALSE);
256: }
257: return(FALSE);
258: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.