![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xdr_rec.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / lib / librpc|
Return to xdr_rec.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / lib / librpc |
1.1 root 1: /*
2: * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
3: * unrestricted use provided that this legend is included on all tape
4: * media and as a part of the software program in whole or part. Users
5: * may copy or modify Sun RPC without charge, but are not authorized
6: * to license or distribute it to anyone else except as part of a product or
7: * program developed by the user.
8: *
9: * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
10: * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
11: * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
12: *
13: * Sun RPC is provided with no support and without any obligation on the
14: * part of Sun Microsystems, Inc. to assist in its use, correction,
15: * modification or enhancement.
16: *
17: * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
18: * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
19: * OR ANY PART THEREOF.
20: *
21: * In no event will Sun Microsystems, Inc. be liable for any lost revenue
22: * or profits or other special, indirect and consequential damages, even if
23: * Sun has been advised of the possibility of such damages.
24: *
25: * Sun Microsystems, Inc.
26: * 2550 Garcia Avenue
27: * Mountain View, California 94043
28: */
29: #ifndef lint
30: static char sccsid[] = "@(#)xdr_rec.c 1.5 85/03/14 Copyr 1984 Sun Micro";
31: #endif
32:
33: /*
34: * xdr_rec.c, Implements TCP/IP based XDR streams with a "record marking"
35: * layer above tcp (for rpc's use).
36: *
37: * Copyright (C) 1984, Sun Microsystems, Inc.
38: *
39: * These routines interface XDRSTREAMS to a tcp/ip connection.
40: * There is a record marking layer between the xdr stream
41: * and the tcp transport level. A record is composed on one or more
42: * record fragments. A record fragment is a thirty-two bit header followed
43: * by n bytes of data, where n is contained in the header. The header
44: * is represented as a htonl(u_long). Thegh order bit encodes
45: * whether or not the fragment is the last fragment of the record
46: * (1 => fragment is last, 0 => more fragments to follow.
47: * The other 31 bits encode the byte length of the fragment.
48: */
49:
50: #include <stdio.h>
51: #include "types.h"
52: #include "xdr.h"
53: #include <sys/time.h>
54: #include <netinet/in.h>
55:
56: char *mem_alloc();
57:
58: static u_int fix_buf_size();
59:
60: static bool_t xdrrec_getlong();
61: static bool_t xdrrec_putlong();
62: static bool_t xdrrec_getbytes();
63: static bool_t xdrrec_putbytes();
64: static u_int xdrrec_getpos();
65: static bool_t xdrrec_setpos();
66: static long * xdrrec_inline();
67: static void xdrrec_destroy();
68:
69: static struct xdr_ops xdrrec_ops = {
70: xdrrec_getlong,
71: xdrrec_putlong,
72: xdrrec_getbytes,
73: xdrrec_putbytes,
74: xdrrec_getpos,
75: xdrrec_setpos,
76: xdrrec_inline,
77: xdrrec_destroy
78: };
79:
80: /*
81: * A record is composed of one or more record fragments.
82: * A record fragment is a two-byte header followed by zero to
83: * 2**32-1 bytes. The header is treated as a long unsigned and is
84: * encode/decoded to the network via htonl/ntohl. The low order 31 bits
85: * are a byte count of the fragment. The highest order bit is a boolean:
86: * 1 => this fragment is the last fragment of the record,
87: * 0 => this fragment is followed by more fragment(s).
88: *
89: * The fragment/record machinery is not general; it is constructed to
90: * meet the needs of xdr and rpc based on tcp.
91: */
92:
93: #define LAST_FRAG ((u_long)(1 << 31))
94:
95: typedef struct rec_strm {
96: caddr_t tcp_handle;
97: /*
98: * out-goung bits
99: */
100: int (*writeit)();
101: caddr_t out_base; /* output buffer (points to frag header) */
102: caddr_t out_finger; /* next output position */
103: caddr_t out_boundry; /* data cannot up to this address */
104: u_long *frag_header; /* beginning of curren fragment */
105: bool_t frag_sent; /* true if buffer sent in middle of record */
106: /*
107: * in-coming bits
108: */
109: int (*readit)();
110: u_long in_size; /* fixed size of the input buffer */
111: caddr_t in_base;
112: caddr_t in_finger; /* location of next byte to be had */
113: caddr_t in_boundry; /* can read up to this location */
114: long fbtbc; /* fragment bytes to be consumed */
115: bool_t last_frag;
116: u_int sendsize;
117: u_int recvsize;
118: } RECSTREAM;
119:
120:
121: /*
122: * Create an xdr handle for xdrrec
123: * xdrrec_create fills in xdrs. Sendsize and recvsize are
124: * send and recv buffer sizes (0 => use default).
125: * tcp_handle is an opaque handle that is passed as the first parameter to
126: * the procedures readit and writeit. Readit and writeit are read and
127: * write respectively. They are like the system
128: * calls expect that they take an opaque handle rather than an fd.
129: */
130: void
131: xdrrec_create(xdrs, sendsize, recvsize, tcp_handle, readit, writeit)
132: register XDR *xdrs;
133: u_int sendsize;
134: u_int recvsize;
135: caddr_t tcp_handle;
136: int (*readit)(); /* like read, but pass it a tcp_handle, not sock */
137: int (*writeit)(); /* like write, but pass it a tcp_handle, not sock */
138: {
139: register RECSTREAM *rstrm =
140: (RECSTREAM *)mem_alloc(sizeof(RECSTREAM));
141:
142: if (rstrm == NULL) {
143: fprintf(stderr, "xdrrec_create: out of memory\n");
144: /*
145: * This is bad. Should rework xdrrec_create to
146: * return a handle, and in this case return NULL
147: */
148: return;
149: }
150: xdrs->x_ops = &xdrrec_ops;
151: xdrs->x_private = (caddr_t)rstrm;
152: rstrm->tcp_handle = tcp_handle;
153: rstrm->readit = readit;
154: rstrm->writeit = writeit;
155: sendsize = fix_buf_size(sendsize);
156: if ((rstrm->out_base = rstrm->out_finger = rstrm->out_boundry =
157: mem_alloc(sendsize)) == NULL) {
158: fprintf(stderr, "xdrrec_create: out of memory\n");
159: return;
160: }
161: rstrm->frag_header = (u_long *)rstrm->out_base;
162: rstrm->out_finger += sizeof(u_long);
163: rstrm->out_boundry += sendsize;
164: rstrm->frag_sent = FALSE;
165: rstrm->in_size = recvsize = fix_buf_size(recvsize);
166: if ((rstrm->in_base = rstrm->in_boundry=mem_alloc(recvsize)) == NULL) {
167: fprintf(stderr, "xdrrec_create: out of memory\n");
168: return;
169: }
170: rstrm->in_finger = (rstrm->in_boundry += recvsize);
171: rstrm->fbtbc = 0;
172: rstrm->last_frag = TRUE;
173: rstrm->sendsize = sendsize;
174: rstrm->recvsize = recvsize;
175: }
176:
177:
178: /*
179: * The reoutines defined below are the xdr ops which will go into the
180: * xdr handle filled in by xdrrec_create.
181: */
182:
183: static bool_t
184: xdrrec_getlong(xdrs, lp)
185: XDR *xdrs;
186: long *lp;
187: {
188: register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
189: register long *buflp = (long *)(rstrm->in_finger);
190: long mylong;
191:
192: /* first try the inline, fast case */
193: if ((rstrm->fbtbc >= sizeof(long)) &&
194: (((int)rstrm->in_boundry - (int)buflp) >= sizeof(long))) {
195: *lp = ntohl(*buflp);
196: rstrm->fbtbc -= sizeof(long);
197: rstrm->in_finger += sizeof(long);
198: } else {
199: if (! xdrrec_getbytes(xdrs, (caddr_t)&mylong, sizeof(long)))
200: return (FALSE);
201: *lp = ntohl(mylong);
202: }
203: return (TRUE);
204: }
205:
206: static bool_t
207: xdrrec_putlong(xdrs, lp)
208: XDR *xdrs;
209: long *lp;
210: {
211: register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
212: register long *dest_lp = ((long *)(rstrm->out_finger));
213:
214: if ((rstrm->out_finger += sizeof(long)) > rstrm->out_boundry) {
215: /*
216: * this case should almost never happen so the code is
217: * inefficient
218: */
219: rstrm->out_finger -= sizeof(long);
220: rstrm->frag_sent = TRUE;
221: if (! flush_out(rstrm, FALSE))
222: return (FALSE);
223: dest_lp = ((long *)(rstrm->out_finger));
224: rstrm->out_finger += sizeof(long);
225: }
226: *dest_lp = htonl(*lp);
227: return (TRUE);
228: }
229:
230: static bool_t /* must manage buffers, fragments, and records */
231: xdrrec_getbytes(xdrs, addr, len)
232: XDR *xdrs;
233: register caddr_t addr;
234: register u_int len;
235: {
236: register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
237: register int current;
238:
239: while (len > 0) {
240: current = rstrm->fbtbc;
241: if (current == 0) {
242: if (rstrm->last_frag)
243: return (FALSE);
244: if (! set_input_fragment(rstrm))
245: return (FALSE);
246: continue;
247: }
248: current = (len < current) ? len : current;
249: if (! get_input_bytes(rstrm, addr, current))
250: return (FALSE);
251: addr += current;
252: rstrm->fbtbc -= current;
253: len -= current;
254: }
255: return (TRUE);
256: }
257:
258: static bool_t
259: xdrrec_putbytes(xdrs, addr, len)
260: XDR *xdrs;
261: register caddr_t addr;
262: register u_int len;
263: {
264: register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
265: register int current;
266:
267: while (len > 0) {
268: current = (u_int)rstrm->out_boundry - (u_int)rstrm->out_finger;
269: current = (len < current) ? len : current;
270: bcopy(addr, rstrm->out_finger, current);
271: rstrm->out_finger += current;
272: addr += current;
273: len -= current;
274: if (rstrm->out_finger == rstrm->out_boundry) {
275: rstrm->frag_sent = TRUE;
276: if (! flush_out(rstrm, FALSE))
277: return (FALSE);
278: }
279: }
280: return (TRUE);
281: }
282:
283: static u_int
284: xdrrec_getpos(xdrs)
285: register XDR *xdrs;
286: {
287: register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
288: register u_int pos;
289:
290: pos = lseek((int)rstrm->tcp_handle, 0, 1);
291: if ((int)pos != -1)
292: switch (xdrs->x_op) {
293:
294: case XDR_ENCODE:
295: pos += rstrm->out_finger - rstrm->out_base;
296: break;
297:
298: case XDR_DECODE:
299: pos -= rstrm->in_boundry - rstrm->in_finger;
300: break;
301:
302: default:
303: pos = (u_int) -1;
304: break;
305: }
306: return (pos);
307: }
308:
309: static bool_t
310: xdrrec_setpos(xdrs, pos)
311: register XDR *xdrs;
312: u_int pos;
313: {
314: register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
315: u_int currpos = xdrrec_getpos(xdrs);
316: int delta = currpos - pos;
317: caddr_t newpos;
318:
319: if ((int)currpos != -1)
320: switch (xdrs->x_op) {
321:
322: case XDR_ENCODE:
323: newpos = rstrm->out_finger - delta;
324: if ((newpos > (caddr_t)(rstrm->frag_header)) &&
325: (newpos < rstrm->out_boundry)) {
326: rstrm->out_finger = newpos;
327: return (TRUE);
328: }
329: break;
330:
331: case XDR_DECODE:
332: newpos = rstrm->in_finger - delta;
333: if ((delta < (int)(rstrm->fbtbc)) &&
334: (newpos <= rstrm->in_boundry) &&
335: (newpos >= rstrm->in_base)) {
336: rstrm->in_finger = newpos;
337: rstrm->fbtbc -= delta;
338: return (TRUE);
339: }
340: break;
341: }
342: return (FALSE);
343: }
344:
345: static long *
346: xdrrec_inline(xdrs, len)
347: register XDR *xdrs;
348: int len;
349: {
350: register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
351: long * buf = NULL;
352:
353: switch (xdrs->x_op) {
354:
355: case XDR_ENCODE:
356: if ((rstrm->out_finger + len) <= rstrm->out_boundry) {
357: buf = (long *) rstrm->out_finger;
358: rstrm->out_finger += len;
359: }
360: break;
361:
362: case XDR_DECODE:
363: if ((len <= rstrm->fbtbc) &&
364: ((rstrm->in_finger + len) <= rstrm->in_boundry)) {
365: buf = (long *) rstrm->in_finger;
366: rstrm->fbtbc -= len;
367: rstrm->in_finger += len;
368: }
369: break;
370: }
371: return (buf);
372: }
373:
374: static void
375: xdrrec_destroy(xdrs)
376: register XDR *xdrs;
377: {
378: register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
379:
380: mem_free(rstrm->out_base, rstrm->sendsize);
381: mem_free(rstrm->in_base, rstrm->recvsize);
382: mem_free((caddr_t)rstrm, sizeof(RECSTREAM));
383: }
384:
385:
386: /*
387: * Exported routines to manage xdr records
388: */
389:
390: /*
391: * Before reading (deserializing from the stream, one should always call
392: * this procedure to guarantee proper record alignment.
393: */
394: bool_t
395: xdrrec_skiprecord(xdrs)
396: XDR *xdrs;
397: {
398: register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
399:
400: while (rstrm->fbtbc > 0 || (! rstrm->last_frag)) {
401: if (! skip_input_bytes(rstrm, rstrm->fbtbc))
402: return (FALSE);
403: rstrm->fbtbc = 0;
404: if ((! rstrm->last_frag) && (! set_input_fragment(rstrm)))
405: return (FALSE);
406: }
407: rstrm->last_frag = FALSE;
408: return (TRUE);
409: }
410:
411: /*
412: * Look ahead fuction.
413: * Returns TRUE iff there is no more input in the buffer
414: * after consuming the rest of the current record.
415: */
416: bool_t
417: xdrrec_eof(xdrs)
418: XDR *xdrs;
419: {
420: register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
421:
422: while (rstrm->fbtbc > 0 || (! rstrm->last_frag)) {
423: if (! skip_input_bytes(rstrm, rstrm->fbtbc))
424: return (TRUE);
425: rstrm->fbtbc = 0;
426: if ((! rstrm->last_frag) && (! set_input_fragment(rstrm)))
427: return (TRUE);
428: }
429: if (rstrm->in_finger == rstrm->in_boundry)
430: return (TRUE);
431: return (FALSE);
432: }
433:
434: /*
435: * The client must tell the package when an end-of-record has occurred.
436: * The second paraemters tells whether the record should be flushed to the
437: * (output) tcp stream. (This let's the package support batched or
438: * pipelined procedure calls.) TRUE => immmediate flush to tcp connection.
439: */
440: bool_t
441: xdrrec_endofrecord(xdrs, sendnow)
442: XDR *xdrs;
443: bool_t sendnow;
444: {
445: register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
446: register u_long len; /* fragment length */
447:
448: if (sendnow || rstrm->frag_sent ||
449: ((u_long)rstrm->out_finger + sizeof(u_long) >=
450: (u_long)rstrm->out_boundry)) {
451: rstrm->frag_sent = FALSE;
452: return (flush_out(rstrm, TRUE));
453: }
454: len = (u_long)(rstrm->out_finger) - (u_long)(rstrm->frag_header) -
455: sizeof(u_long);
456: *(rstrm->frag_header) = htonl(len | LAST_FRAG);
457: rstrm->frag_header = (u_long *)rstrm->out_finger;
458: rstrm->out_finger += sizeof(u_long);
459: return (TRUE);
460: }
461:
462:
463: /*
464: * Internal useful routines
465: */
466: static bool_t
467: flush_out(rstrm, eor)
468: register RECSTREAM *rstrm;
469: bool_t eor;
470: {
471: register u_long eormask = (eor == TRUE) ? LAST_FRAG : 0;
472: register u_long len = (u_long)(rstrm->out_finger) -
473: (u_long)(rstrm->frag_header) - sizeof(u_long);
474:
475: *(rstrm->frag_header) = htonl(len | eormask);
476: len = (u_long)(rstrm->out_finger) - (u_long)(rstrm->out_base);
477: if ((*(rstrm->writeit))(rstrm->tcp_handle, rstrm->out_base, (int)len)
478: != (int)len)
479: return (FALSE);
480: rstrm->frag_header = (u_long *)rstrm->out_base;
481: rstrm->out_finger = (caddr_t)rstrm->out_base + sizeof(u_long);
482: return (TRUE);
483: }
484:
485: static bool_t /* knows nothing about records! Only about input buffers */
486: fill_input_buf(rstrm)
487: register RECSTREAM *rstrm;
488: {
489: register caddr_t where = rstrm->in_base;
490: register int len = rstrm->in_size;
491:
492: if (((int)rstrm->in_boundry % 2) != 0) {
493: /* keep stream odd bytes aligned with memory odd bytes */
494: where++;
495: len--;
496: }
497: if ((len = (*(rstrm->readit))(rstrm->tcp_handle, where, len)) == -1)
498: return (FALSE);
499: rstrm->in_finger = where;
500: where += len;
501: rstrm->in_boundry = where;
502: return (TRUE);
503: }
504:
505: static bool_t /* knows nothing about records! Only about input buffers */
506: get_input_bytes(rstrm, addr, len)
507: register RECSTREAM *rstrm;
508: register caddr_t addr;
509: register int len;
510: {
511: register int current;
512:
513: while (len > 0) {
514: current = (int)rstrm->in_boundry - (int)rstrm->in_finger;
515: if (current == 0) {
516: if (! fill_input_buf(rstrm))
517: return (FALSE);
518: continue;
519: }
520: current = (len < current) ? len : current;
521: bcopy(rstrm->in_finger, addr, current);
522: rstrm->in_finger += current;
523: addr += current;
524: len -= current;
525: }
526: return (TRUE);
527: }
528:
529: static bool_t /* next two bytes of the input stream are treated as a header */
530: set_input_fragment(rstrm)
531: register RECSTREAM *rstrm;
532: {
533: u_long header;
534:
535: if (! get_input_bytes(rstrm, (caddr_t)&header, sizeof(header)))
536: return (FALSE);
537: header = ntohl(header);
538: rstrm->last_frag = ((header & LAST_FRAG) == 0) ? FALSE : TRUE;
539: rstrm->fbtbc = header & (~LAST_FRAG);
540: return (TRUE);
541: }
542:
543: static bool_t /* consumes input bytes; knows nothing about records! */
544: skip_input_bytes(rstrm, cnt)
545: register RECSTREAM *rstrm;
546: int cnt;
547: {
548: register int current;
549:
550: while (cnt > 0) {
551: current = (int)rstrm->in_boundry - (int)rstrm->in_finger;
552: if (current == 0) {
553: if (! fill_input_buf(rstrm))
554: return (FALSE);
555: continue;
556: }
557: current = (cnt < current) ? cnt : current;
558: rstrm->in_finger += current;
559: cnt -= current;
560: }
561: return (TRUE);
562: }
563:
564: static u_int
565: fix_buf_size(s)
566: register u_int s;
567: {
568:
569: if (s < 100)
570: return (3998);
571: for (; (s % 4) != 2; --s);
572: return (s);
573: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.