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