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#if defined(LIBC_SCCS) && !defined(lint)
30/*static char *sccsid = "from: @(#)xdr_rec.c 1.21 87/08/11 Copyr 1984 Sun Micro";*/
31/*static char *sccsid = "from: @(#)xdr_rec.c 2.2 88/08/01 4.0 RPCSRC";*/
| 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#if defined(LIBC_SCCS) && !defined(lint)
30/*static char *sccsid = "from: @(#)xdr_rec.c 1.21 87/08/11 Copyr 1984 Sun Micro";*/
31/*static char *sccsid = "from: @(#)xdr_rec.c 2.2 88/08/01 4.0 RPCSRC";*/
|
54#include <rpc/types.h>
55#include <rpc/xdr.h>
56#include <netinet/in.h>
57
58static u_int fix_buf_size();
59static bool_t flush_out();
60static bool_t get_input_bytes();
61static bool_t set_input_fragment();
62static bool_t skip_input_bytes();
63
64static bool_t xdrrec_getlong();
65static bool_t xdrrec_putlong();
66static bool_t xdrrec_getbytes();
67static bool_t xdrrec_putbytes();
68static u_int xdrrec_getpos();
69static bool_t xdrrec_setpos();
70static long * xdrrec_inline();
71static void xdrrec_destroy();
72
73static struct xdr_ops xdrrec_ops = {
74 xdrrec_getlong,
75 xdrrec_putlong,
76 xdrrec_getbytes,
77 xdrrec_putbytes,
78 xdrrec_getpos,
79 xdrrec_setpos,
80 xdrrec_inline,
81 xdrrec_destroy
82};
83
84/*
85 * A record is composed of one or more record fragments.
86 * A record fragment is a two-byte header followed by zero to
87 * 2**32-1 bytes. The header is treated as a long unsigned and is
88 * encode/decoded to the network via htonl/ntohl. The low order 31 bits
89 * are a byte count of the fragment. The highest order bit is a boolean:
90 * 1 => this fragment is the last fragment of the record,
91 * 0 => this fragment is followed by more fragment(s).
92 *
93 * The fragment/record machinery is not general; it is constructed to
94 * meet the needs of xdr and rpc based on tcp.
95 */
96
97#define LAST_FRAG ((u_long)(1 << 31))
98
99typedef struct rec_strm {
100 caddr_t tcp_handle;
101 caddr_t the_buffer;
102 /*
103 * out-goung bits
104 */
105 int (*writeit)();
106 caddr_t out_base; /* output buffer (points to frag header) */
107 caddr_t out_finger; /* next output position */
108 caddr_t out_boundry; /* data cannot up to this address */
109 u_long *frag_header; /* beginning of curren fragment */
110 bool_t frag_sent; /* true if buffer sent in middle of record */
111 /*
112 * in-coming bits
113 */
114 int (*readit)();
115 u_long in_size; /* fixed size of the input buffer */
116 caddr_t in_base;
117 caddr_t in_finger; /* location of next byte to be had */
118 caddr_t in_boundry; /* can read up to this location */
119 long fbtbc; /* fragment bytes to be consumed */
120 bool_t last_frag;
121 u_int sendsize;
122 u_int recvsize;
123} RECSTREAM;
124
125
126/*
127 * Create an xdr handle for xdrrec
128 * xdrrec_create fills in xdrs. Sendsize and recvsize are
129 * send and recv buffer sizes (0 => use default).
130 * tcp_handle is an opaque handle that is passed as the first parameter to
131 * the procedures readit and writeit. Readit and writeit are read and
132 * write respectively. They are like the system
133 * calls expect that they take an opaque handle rather than an fd.
134 */
135void
136xdrrec_create(xdrs, sendsize, recvsize, tcp_handle, readit, writeit)
137 register XDR *xdrs;
138 register u_int sendsize;
139 register u_int recvsize;
140 caddr_t tcp_handle;
141 int (*readit)(); /* like read, but pass it a tcp_handle, not sock */
142 int (*writeit)(); /* like write, but pass it a tcp_handle, not sock */
143{
144 register RECSTREAM *rstrm =
145 (RECSTREAM *)mem_alloc(sizeof(RECSTREAM));
146
147 if (rstrm == NULL) {
148 (void)fprintf(stderr, "xdrrec_create: out of memory\n");
149 /*
150 * This is bad. Should rework xdrrec_create to
151 * return a handle, and in this case return NULL
152 */
153 return;
154 }
155 /*
156 * adjust sizes and allocate buffer quad byte aligned
157 */
158 rstrm->sendsize = sendsize = fix_buf_size(sendsize);
159 rstrm->recvsize = recvsize = fix_buf_size(recvsize);
160 rstrm->the_buffer = mem_alloc(sendsize + recvsize + BYTES_PER_XDR_UNIT);
161 if (rstrm->the_buffer == NULL) {
162 (void)fprintf(stderr, "xdrrec_create: out of memory\n");
163 return;
164 }
165 for (rstrm->out_base = rstrm->the_buffer;
166 (u_int)rstrm->out_base % BYTES_PER_XDR_UNIT != 0;
167 rstrm->out_base++);
168 rstrm->in_base = rstrm->out_base + sendsize;
169 /*
170 * now the rest ...
171 */
172 xdrs->x_ops = &xdrrec_ops;
173 xdrs->x_private = (caddr_t)rstrm;
174 rstrm->tcp_handle = tcp_handle;
175 rstrm->readit = readit;
176 rstrm->writeit = writeit;
177 rstrm->out_finger = rstrm->out_boundry = rstrm->out_base;
178 rstrm->frag_header = (u_long *)rstrm->out_base;
179 rstrm->out_finger += sizeof(u_long);
180 rstrm->out_boundry += sendsize;
181 rstrm->frag_sent = FALSE;
182 rstrm->in_size = recvsize;
183 rstrm->in_boundry = rstrm->in_base;
184 rstrm->in_finger = (rstrm->in_boundry += recvsize);
185 rstrm->fbtbc = 0;
186 rstrm->last_frag = TRUE;
187}
188
189
190/*
191 * The reoutines defined below are the xdr ops which will go into the
192 * xdr handle filled in by xdrrec_create.
193 */
194
195static bool_t
196xdrrec_getlong(xdrs, lp)
197 XDR *xdrs;
198 long *lp;
199{
200 register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
201 register long *buflp = (long *)(rstrm->in_finger);
202 long mylong;
203
204 /* first try the inline, fast case */
205 if ((rstrm->fbtbc >= sizeof(long)) &&
206 (((int)rstrm->in_boundry - (int)buflp) >= sizeof(long))) {
207 *lp = (long)ntohl((u_long)(*buflp));
208 rstrm->fbtbc -= sizeof(long);
209 rstrm->in_finger += sizeof(long);
210 } else {
211 if (! xdrrec_getbytes(xdrs, (caddr_t)&mylong, sizeof(long)))
212 return (FALSE);
213 *lp = (long)ntohl((u_long)mylong);
214 }
215 return (TRUE);
216}
217
218static bool_t
219xdrrec_putlong(xdrs, lp)
220 XDR *xdrs;
221 long *lp;
222{
223 register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
224 register long *dest_lp = ((long *)(rstrm->out_finger));
225
226 if ((rstrm->out_finger += sizeof(long)) > rstrm->out_boundry) {
227 /*
228 * this case should almost never happen so the code is
229 * inefficient
230 */
231 rstrm->out_finger -= sizeof(long);
232 rstrm->frag_sent = TRUE;
233 if (! flush_out(rstrm, FALSE))
234 return (FALSE);
235 dest_lp = ((long *)(rstrm->out_finger));
236 rstrm->out_finger += sizeof(long);
237 }
238 *dest_lp = (long)htonl((u_long)(*lp));
239 return (TRUE);
240}
241
242static bool_t /* must manage buffers, fragments, and records */
243xdrrec_getbytes(xdrs, addr, len)
244 XDR *xdrs;
245 register caddr_t addr;
246 register u_int len;
247{
248 register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
249 register int current;
250
251 while (len > 0) {
252 current = rstrm->fbtbc;
253 if (current == 0) {
254 if (rstrm->last_frag)
255 return (FALSE);
256 if (! set_input_fragment(rstrm))
257 return (FALSE);
258 continue;
259 }
260 current = (len < current) ? len : current;
261 if (! get_input_bytes(rstrm, addr, current))
262 return (FALSE);
263 addr += current;
264 rstrm->fbtbc -= current;
265 len -= current;
266 }
267 return (TRUE);
268}
269
270static bool_t
271xdrrec_putbytes(xdrs, addr, len)
272 XDR *xdrs;
273 register caddr_t addr;
274 register u_int len;
275{
276 register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
277 register int current;
278
279 while (len > 0) {
280 current = (u_int)rstrm->out_boundry - (u_int)rstrm->out_finger;
281 current = (len < current) ? len : current;
282 bcopy(addr, rstrm->out_finger, current);
283 rstrm->out_finger += current;
284 addr += current;
285 len -= current;
286 if (rstrm->out_finger == rstrm->out_boundry) {
287 rstrm->frag_sent = TRUE;
288 if (! flush_out(rstrm, FALSE))
289 return (FALSE);
290 }
291 }
292 return (TRUE);
293}
294
295static u_int
296xdrrec_getpos(xdrs)
297 register XDR *xdrs;
298{
299 register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
300 register long pos;
301
302 pos = lseek((int)rstrm->tcp_handle, (long) 0, 1);
303 if (pos != -1)
304 switch (xdrs->x_op) {
305
306 case XDR_ENCODE:
307 pos += rstrm->out_finger - rstrm->out_base;
308 break;
309
310 case XDR_DECODE:
311 pos -= rstrm->in_boundry - rstrm->in_finger;
312 break;
313
314 default:
315 pos = (u_int) -1;
316 break;
317 }
318 return ((u_int) pos);
319}
320
321static bool_t
322xdrrec_setpos(xdrs, pos)
323 register XDR *xdrs;
324 u_int pos;
325{
326 register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
327 u_int currpos = xdrrec_getpos(xdrs);
328 int delta = currpos - pos;
329 caddr_t newpos;
330
331 if ((int)currpos != -1)
332 switch (xdrs->x_op) {
333
334 case XDR_ENCODE:
335 newpos = rstrm->out_finger - delta;
336 if ((newpos > (caddr_t)(rstrm->frag_header)) &&
337 (newpos < rstrm->out_boundry)) {
338 rstrm->out_finger = newpos;
339 return (TRUE);
340 }
341 break;
342
343 case XDR_DECODE:
344 newpos = rstrm->in_finger - delta;
345 if ((delta < (int)(rstrm->fbtbc)) &&
346 (newpos <= rstrm->in_boundry) &&
347 (newpos >= rstrm->in_base)) {
348 rstrm->in_finger = newpos;
349 rstrm->fbtbc -= delta;
350 return (TRUE);
351 }
352 break;
353 }
354 return (FALSE);
355}
356
357static long *
358xdrrec_inline(xdrs, len)
359 register XDR *xdrs;
360 int len;
361{
362 register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
363 long * buf = NULL;
364
365 switch (xdrs->x_op) {
366
367 case XDR_ENCODE:
368 if ((rstrm->out_finger + len) <= rstrm->out_boundry) {
369 buf = (long *) rstrm->out_finger;
370 rstrm->out_finger += len;
371 }
372 break;
373
374 case XDR_DECODE:
375 if ((len <= rstrm->fbtbc) &&
376 ((rstrm->in_finger + len) <= rstrm->in_boundry)) {
377 buf = (long *) rstrm->in_finger;
378 rstrm->fbtbc -= len;
379 rstrm->in_finger += len;
380 }
381 break;
382 }
383 return (buf);
384}
385
386static void
387xdrrec_destroy(xdrs)
388 register XDR *xdrs;
389{
390 register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
391
392 mem_free(rstrm->the_buffer,
393 rstrm->sendsize + rstrm->recvsize + BYTES_PER_XDR_UNIT);
394 mem_free((caddr_t)rstrm, sizeof(RECSTREAM));
395}
396
397
398/*
399 * Exported routines to manage xdr records
400 */
401
402/*
403 * Before reading (deserializing from the stream, one should always call
404 * this procedure to guarantee proper record alignment.
405 */
406bool_t
407xdrrec_skiprecord(xdrs)
408 XDR *xdrs;
409{
410 register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
411
412 while (rstrm->fbtbc > 0 || (! rstrm->last_frag)) {
413 if (! skip_input_bytes(rstrm, rstrm->fbtbc))
414 return (FALSE);
415 rstrm->fbtbc = 0;
416 if ((! rstrm->last_frag) && (! set_input_fragment(rstrm)))
417 return (FALSE);
418 }
419 rstrm->last_frag = FALSE;
420 return (TRUE);
421}
422
423/*
424 * Look ahead fuction.
425 * Returns TRUE iff there is no more input in the buffer
426 * after consuming the rest of the current record.
427 */
428bool_t
429xdrrec_eof(xdrs)
430 XDR *xdrs;
431{
432 register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
433
434 while (rstrm->fbtbc > 0 || (! rstrm->last_frag)) {
435 if (! skip_input_bytes(rstrm, rstrm->fbtbc))
436 return (TRUE);
437 rstrm->fbtbc = 0;
438 if ((! rstrm->last_frag) && (! set_input_fragment(rstrm)))
439 return (TRUE);
440 }
441 if (rstrm->in_finger == rstrm->in_boundry)
442 return (TRUE);
443 return (FALSE);
444}
445
446/*
447 * The client must tell the package when an end-of-record has occurred.
448 * The second paraemters tells whether the record should be flushed to the
449 * (output) tcp stream. (This let's the package support batched or
450 * pipelined procedure calls.) TRUE => immmediate flush to tcp connection.
451 */
452bool_t
453xdrrec_endofrecord(xdrs, sendnow)
454 XDR *xdrs;
455 bool_t sendnow;
456{
457 register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
458 register u_long len; /* fragment length */
459
460 if (sendnow || rstrm->frag_sent ||
461 ((u_long)rstrm->out_finger + sizeof(u_long) >=
462 (u_long)rstrm->out_boundry)) {
463 rstrm->frag_sent = FALSE;
464 return (flush_out(rstrm, TRUE));
465 }
466 len = (u_long)(rstrm->out_finger) - (u_long)(rstrm->frag_header) -
467 sizeof(u_long);
468 *(rstrm->frag_header) = htonl((u_long)len | LAST_FRAG);
469 rstrm->frag_header = (u_long *)rstrm->out_finger;
470 rstrm->out_finger += sizeof(u_long);
471 return (TRUE);
472}
473
474
475/*
476 * Internal useful routines
477 */
478static bool_t
479flush_out(rstrm, eor)
480 register RECSTREAM *rstrm;
481 bool_t eor;
482{
483 register u_long eormask = (eor == TRUE) ? LAST_FRAG : 0;
484 register u_long len = (u_long)(rstrm->out_finger) -
485 (u_long)(rstrm->frag_header) - sizeof(u_long);
486
487 *(rstrm->frag_header) = htonl(len | eormask);
488 len = (u_long)(rstrm->out_finger) - (u_long)(rstrm->out_base);
489 if ((*(rstrm->writeit))(rstrm->tcp_handle, rstrm->out_base, (int)len)
490 != (int)len)
491 return (FALSE);
492 rstrm->frag_header = (u_long *)rstrm->out_base;
493 rstrm->out_finger = (caddr_t)rstrm->out_base + sizeof(u_long);
494 return (TRUE);
495}
496
497static bool_t /* knows nothing about records! Only about input buffers */
498fill_input_buf(rstrm)
499 register RECSTREAM *rstrm;
500{
501 register caddr_t where;
502 u_int i;
503 register int len;
504
505 where = rstrm->in_base;
506 i = (u_int)rstrm->in_boundry % BYTES_PER_XDR_UNIT;
507 where += i;
508 len = rstrm->in_size - i;
509 if ((len = (*(rstrm->readit))(rstrm->tcp_handle, where, len)) == -1)
510 return (FALSE);
511 rstrm->in_finger = where;
512 where += len;
513 rstrm->in_boundry = where;
514 return (TRUE);
515}
516
517static bool_t /* knows nothing about records! Only about input buffers */
518get_input_bytes(rstrm, addr, len)
519 register RECSTREAM *rstrm;
520 register caddr_t addr;
521 register int len;
522{
523 register int current;
524
525 while (len > 0) {
526 current = (int)rstrm->in_boundry - (int)rstrm->in_finger;
527 if (current == 0) {
528 if (! fill_input_buf(rstrm))
529 return (FALSE);
530 continue;
531 }
532 current = (len < current) ? len : current;
533 bcopy(rstrm->in_finger, addr, current);
534 rstrm->in_finger += current;
535 addr += current;
536 len -= current;
537 }
538 return (TRUE);
539}
540
541static bool_t /* next two bytes of the input stream are treated as a header */
542set_input_fragment(rstrm)
543 register RECSTREAM *rstrm;
544{
545 u_long header;
546
547 if (! get_input_bytes(rstrm, (caddr_t)&header, sizeof(header)))
548 return (FALSE);
549 header = (long)ntohl(header);
550 rstrm->last_frag = ((header & LAST_FRAG) == 0) ? FALSE : TRUE;
551 rstrm->fbtbc = header & (~LAST_FRAG);
552 return (TRUE);
553}
554
555static bool_t /* consumes input bytes; knows nothing about records! */
556skip_input_bytes(rstrm, cnt)
557 register RECSTREAM *rstrm;
558 long cnt;
559{
560 register int current;
561
562 while (cnt > 0) {
563 current = (int)rstrm->in_boundry - (int)rstrm->in_finger;
564 if (current == 0) {
565 if (! fill_input_buf(rstrm))
566 return (FALSE);
567 continue;
568 }
569 current = (cnt < current) ? cnt : current;
570 rstrm->in_finger += current;
571 cnt -= current;
572 }
573 return (TRUE);
574}
575
576static u_int
577fix_buf_size(s)
578 register u_int s;
579{
580
581 if (s < 100)
582 s = 4000;
583 return (RNDUP(s));
584}
| 55#include <rpc/types.h>
56#include <rpc/xdr.h>
57#include <netinet/in.h>
58
59static u_int fix_buf_size();
60static bool_t flush_out();
61static bool_t get_input_bytes();
62static bool_t set_input_fragment();
63static bool_t skip_input_bytes();
64
65static bool_t xdrrec_getlong();
66static bool_t xdrrec_putlong();
67static bool_t xdrrec_getbytes();
68static bool_t xdrrec_putbytes();
69static u_int xdrrec_getpos();
70static bool_t xdrrec_setpos();
71static long * xdrrec_inline();
72static void xdrrec_destroy();
73
74static struct xdr_ops xdrrec_ops = {
75 xdrrec_getlong,
76 xdrrec_putlong,
77 xdrrec_getbytes,
78 xdrrec_putbytes,
79 xdrrec_getpos,
80 xdrrec_setpos,
81 xdrrec_inline,
82 xdrrec_destroy
83};
84
85/*
86 * A record is composed of one or more record fragments.
87 * A record fragment is a two-byte header followed by zero to
88 * 2**32-1 bytes. The header is treated as a long unsigned and is
89 * encode/decoded to the network via htonl/ntohl. The low order 31 bits
90 * are a byte count of the fragment. The highest order bit is a boolean:
91 * 1 => this fragment is the last fragment of the record,
92 * 0 => this fragment is followed by more fragment(s).
93 *
94 * The fragment/record machinery is not general; it is constructed to
95 * meet the needs of xdr and rpc based on tcp.
96 */
97
98#define LAST_FRAG ((u_long)(1 << 31))
99
100typedef struct rec_strm {
101 caddr_t tcp_handle;
102 caddr_t the_buffer;
103 /*
104 * out-goung bits
105 */
106 int (*writeit)();
107 caddr_t out_base; /* output buffer (points to frag header) */
108 caddr_t out_finger; /* next output position */
109 caddr_t out_boundry; /* data cannot up to this address */
110 u_long *frag_header; /* beginning of curren fragment */
111 bool_t frag_sent; /* true if buffer sent in middle of record */
112 /*
113 * in-coming bits
114 */
115 int (*readit)();
116 u_long in_size; /* fixed size of the input buffer */
117 caddr_t in_base;
118 caddr_t in_finger; /* location of next byte to be had */
119 caddr_t in_boundry; /* can read up to this location */
120 long fbtbc; /* fragment bytes to be consumed */
121 bool_t last_frag;
122 u_int sendsize;
123 u_int recvsize;
124} RECSTREAM;
125
126
127/*
128 * Create an xdr handle for xdrrec
129 * xdrrec_create fills in xdrs. Sendsize and recvsize are
130 * send and recv buffer sizes (0 => use default).
131 * tcp_handle is an opaque handle that is passed as the first parameter to
132 * the procedures readit and writeit. Readit and writeit are read and
133 * write respectively. They are like the system
134 * calls expect that they take an opaque handle rather than an fd.
135 */
136void
137xdrrec_create(xdrs, sendsize, recvsize, tcp_handle, readit, writeit)
138 register XDR *xdrs;
139 register u_int sendsize;
140 register u_int recvsize;
141 caddr_t tcp_handle;
142 int (*readit)(); /* like read, but pass it a tcp_handle, not sock */
143 int (*writeit)(); /* like write, but pass it a tcp_handle, not sock */
144{
145 register RECSTREAM *rstrm =
146 (RECSTREAM *)mem_alloc(sizeof(RECSTREAM));
147
148 if (rstrm == NULL) {
149 (void)fprintf(stderr, "xdrrec_create: out of memory\n");
150 /*
151 * This is bad. Should rework xdrrec_create to
152 * return a handle, and in this case return NULL
153 */
154 return;
155 }
156 /*
157 * adjust sizes and allocate buffer quad byte aligned
158 */
159 rstrm->sendsize = sendsize = fix_buf_size(sendsize);
160 rstrm->recvsize = recvsize = fix_buf_size(recvsize);
161 rstrm->the_buffer = mem_alloc(sendsize + recvsize + BYTES_PER_XDR_UNIT);
162 if (rstrm->the_buffer == NULL) {
163 (void)fprintf(stderr, "xdrrec_create: out of memory\n");
164 return;
165 }
166 for (rstrm->out_base = rstrm->the_buffer;
167 (u_int)rstrm->out_base % BYTES_PER_XDR_UNIT != 0;
168 rstrm->out_base++);
169 rstrm->in_base = rstrm->out_base + sendsize;
170 /*
171 * now the rest ...
172 */
173 xdrs->x_ops = &xdrrec_ops;
174 xdrs->x_private = (caddr_t)rstrm;
175 rstrm->tcp_handle = tcp_handle;
176 rstrm->readit = readit;
177 rstrm->writeit = writeit;
178 rstrm->out_finger = rstrm->out_boundry = rstrm->out_base;
179 rstrm->frag_header = (u_long *)rstrm->out_base;
180 rstrm->out_finger += sizeof(u_long);
181 rstrm->out_boundry += sendsize;
182 rstrm->frag_sent = FALSE;
183 rstrm->in_size = recvsize;
184 rstrm->in_boundry = rstrm->in_base;
185 rstrm->in_finger = (rstrm->in_boundry += recvsize);
186 rstrm->fbtbc = 0;
187 rstrm->last_frag = TRUE;
188}
189
190
191/*
192 * The reoutines defined below are the xdr ops which will go into the
193 * xdr handle filled in by xdrrec_create.
194 */
195
196static bool_t
197xdrrec_getlong(xdrs, lp)
198 XDR *xdrs;
199 long *lp;
200{
201 register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
202 register long *buflp = (long *)(rstrm->in_finger);
203 long mylong;
204
205 /* first try the inline, fast case */
206 if ((rstrm->fbtbc >= sizeof(long)) &&
207 (((int)rstrm->in_boundry - (int)buflp) >= sizeof(long))) {
208 *lp = (long)ntohl((u_long)(*buflp));
209 rstrm->fbtbc -= sizeof(long);
210 rstrm->in_finger += sizeof(long);
211 } else {
212 if (! xdrrec_getbytes(xdrs, (caddr_t)&mylong, sizeof(long)))
213 return (FALSE);
214 *lp = (long)ntohl((u_long)mylong);
215 }
216 return (TRUE);
217}
218
219static bool_t
220xdrrec_putlong(xdrs, lp)
221 XDR *xdrs;
222 long *lp;
223{
224 register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
225 register long *dest_lp = ((long *)(rstrm->out_finger));
226
227 if ((rstrm->out_finger += sizeof(long)) > rstrm->out_boundry) {
228 /*
229 * this case should almost never happen so the code is
230 * inefficient
231 */
232 rstrm->out_finger -= sizeof(long);
233 rstrm->frag_sent = TRUE;
234 if (! flush_out(rstrm, FALSE))
235 return (FALSE);
236 dest_lp = ((long *)(rstrm->out_finger));
237 rstrm->out_finger += sizeof(long);
238 }
239 *dest_lp = (long)htonl((u_long)(*lp));
240 return (TRUE);
241}
242
243static bool_t /* must manage buffers, fragments, and records */
244xdrrec_getbytes(xdrs, addr, len)
245 XDR *xdrs;
246 register caddr_t addr;
247 register u_int len;
248{
249 register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
250 register int current;
251
252 while (len > 0) {
253 current = rstrm->fbtbc;
254 if (current == 0) {
255 if (rstrm->last_frag)
256 return (FALSE);
257 if (! set_input_fragment(rstrm))
258 return (FALSE);
259 continue;
260 }
261 current = (len < current) ? len : current;
262 if (! get_input_bytes(rstrm, addr, current))
263 return (FALSE);
264 addr += current;
265 rstrm->fbtbc -= current;
266 len -= current;
267 }
268 return (TRUE);
269}
270
271static bool_t
272xdrrec_putbytes(xdrs, addr, len)
273 XDR *xdrs;
274 register caddr_t addr;
275 register u_int len;
276{
277 register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
278 register int current;
279
280 while (len > 0) {
281 current = (u_int)rstrm->out_boundry - (u_int)rstrm->out_finger;
282 current = (len < current) ? len : current;
283 bcopy(addr, rstrm->out_finger, current);
284 rstrm->out_finger += current;
285 addr += current;
286 len -= current;
287 if (rstrm->out_finger == rstrm->out_boundry) {
288 rstrm->frag_sent = TRUE;
289 if (! flush_out(rstrm, FALSE))
290 return (FALSE);
291 }
292 }
293 return (TRUE);
294}
295
296static u_int
297xdrrec_getpos(xdrs)
298 register XDR *xdrs;
299{
300 register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
301 register long pos;
302
303 pos = lseek((int)rstrm->tcp_handle, (long) 0, 1);
304 if (pos != -1)
305 switch (xdrs->x_op) {
306
307 case XDR_ENCODE:
308 pos += rstrm->out_finger - rstrm->out_base;
309 break;
310
311 case XDR_DECODE:
312 pos -= rstrm->in_boundry - rstrm->in_finger;
313 break;
314
315 default:
316 pos = (u_int) -1;
317 break;
318 }
319 return ((u_int) pos);
320}
321
322static bool_t
323xdrrec_setpos(xdrs, pos)
324 register XDR *xdrs;
325 u_int pos;
326{
327 register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
328 u_int currpos = xdrrec_getpos(xdrs);
329 int delta = currpos - pos;
330 caddr_t newpos;
331
332 if ((int)currpos != -1)
333 switch (xdrs->x_op) {
334
335 case XDR_ENCODE:
336 newpos = rstrm->out_finger - delta;
337 if ((newpos > (caddr_t)(rstrm->frag_header)) &&
338 (newpos < rstrm->out_boundry)) {
339 rstrm->out_finger = newpos;
340 return (TRUE);
341 }
342 break;
343
344 case XDR_DECODE:
345 newpos = rstrm->in_finger - delta;
346 if ((delta < (int)(rstrm->fbtbc)) &&
347 (newpos <= rstrm->in_boundry) &&
348 (newpos >= rstrm->in_base)) {
349 rstrm->in_finger = newpos;
350 rstrm->fbtbc -= delta;
351 return (TRUE);
352 }
353 break;
354 }
355 return (FALSE);
356}
357
358static long *
359xdrrec_inline(xdrs, len)
360 register XDR *xdrs;
361 int len;
362{
363 register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
364 long * buf = NULL;
365
366 switch (xdrs->x_op) {
367
368 case XDR_ENCODE:
369 if ((rstrm->out_finger + len) <= rstrm->out_boundry) {
370 buf = (long *) rstrm->out_finger;
371 rstrm->out_finger += len;
372 }
373 break;
374
375 case XDR_DECODE:
376 if ((len <= rstrm->fbtbc) &&
377 ((rstrm->in_finger + len) <= rstrm->in_boundry)) {
378 buf = (long *) rstrm->in_finger;
379 rstrm->fbtbc -= len;
380 rstrm->in_finger += len;
381 }
382 break;
383 }
384 return (buf);
385}
386
387static void
388xdrrec_destroy(xdrs)
389 register XDR *xdrs;
390{
391 register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
392
393 mem_free(rstrm->the_buffer,
394 rstrm->sendsize + rstrm->recvsize + BYTES_PER_XDR_UNIT);
395 mem_free((caddr_t)rstrm, sizeof(RECSTREAM));
396}
397
398
399/*
400 * Exported routines to manage xdr records
401 */
402
403/*
404 * Before reading (deserializing from the stream, one should always call
405 * this procedure to guarantee proper record alignment.
406 */
407bool_t
408xdrrec_skiprecord(xdrs)
409 XDR *xdrs;
410{
411 register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
412
413 while (rstrm->fbtbc > 0 || (! rstrm->last_frag)) {
414 if (! skip_input_bytes(rstrm, rstrm->fbtbc))
415 return (FALSE);
416 rstrm->fbtbc = 0;
417 if ((! rstrm->last_frag) && (! set_input_fragment(rstrm)))
418 return (FALSE);
419 }
420 rstrm->last_frag = FALSE;
421 return (TRUE);
422}
423
424/*
425 * Look ahead fuction.
426 * Returns TRUE iff there is no more input in the buffer
427 * after consuming the rest of the current record.
428 */
429bool_t
430xdrrec_eof(xdrs)
431 XDR *xdrs;
432{
433 register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
434
435 while (rstrm->fbtbc > 0 || (! rstrm->last_frag)) {
436 if (! skip_input_bytes(rstrm, rstrm->fbtbc))
437 return (TRUE);
438 rstrm->fbtbc = 0;
439 if ((! rstrm->last_frag) && (! set_input_fragment(rstrm)))
440 return (TRUE);
441 }
442 if (rstrm->in_finger == rstrm->in_boundry)
443 return (TRUE);
444 return (FALSE);
445}
446
447/*
448 * The client must tell the package when an end-of-record has occurred.
449 * The second paraemters tells whether the record should be flushed to the
450 * (output) tcp stream. (This let's the package support batched or
451 * pipelined procedure calls.) TRUE => immmediate flush to tcp connection.
452 */
453bool_t
454xdrrec_endofrecord(xdrs, sendnow)
455 XDR *xdrs;
456 bool_t sendnow;
457{
458 register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
459 register u_long len; /* fragment length */
460
461 if (sendnow || rstrm->frag_sent ||
462 ((u_long)rstrm->out_finger + sizeof(u_long) >=
463 (u_long)rstrm->out_boundry)) {
464 rstrm->frag_sent = FALSE;
465 return (flush_out(rstrm, TRUE));
466 }
467 len = (u_long)(rstrm->out_finger) - (u_long)(rstrm->frag_header) -
468 sizeof(u_long);
469 *(rstrm->frag_header) = htonl((u_long)len | LAST_FRAG);
470 rstrm->frag_header = (u_long *)rstrm->out_finger;
471 rstrm->out_finger += sizeof(u_long);
472 return (TRUE);
473}
474
475
476/*
477 * Internal useful routines
478 */
479static bool_t
480flush_out(rstrm, eor)
481 register RECSTREAM *rstrm;
482 bool_t eor;
483{
484 register u_long eormask = (eor == TRUE) ? LAST_FRAG : 0;
485 register u_long len = (u_long)(rstrm->out_finger) -
486 (u_long)(rstrm->frag_header) - sizeof(u_long);
487
488 *(rstrm->frag_header) = htonl(len | eormask);
489 len = (u_long)(rstrm->out_finger) - (u_long)(rstrm->out_base);
490 if ((*(rstrm->writeit))(rstrm->tcp_handle, rstrm->out_base, (int)len)
491 != (int)len)
492 return (FALSE);
493 rstrm->frag_header = (u_long *)rstrm->out_base;
494 rstrm->out_finger = (caddr_t)rstrm->out_base + sizeof(u_long);
495 return (TRUE);
496}
497
498static bool_t /* knows nothing about records! Only about input buffers */
499fill_input_buf(rstrm)
500 register RECSTREAM *rstrm;
501{
502 register caddr_t where;
503 u_int i;
504 register int len;
505
506 where = rstrm->in_base;
507 i = (u_int)rstrm->in_boundry % BYTES_PER_XDR_UNIT;
508 where += i;
509 len = rstrm->in_size - i;
510 if ((len = (*(rstrm->readit))(rstrm->tcp_handle, where, len)) == -1)
511 return (FALSE);
512 rstrm->in_finger = where;
513 where += len;
514 rstrm->in_boundry = where;
515 return (TRUE);
516}
517
518static bool_t /* knows nothing about records! Only about input buffers */
519get_input_bytes(rstrm, addr, len)
520 register RECSTREAM *rstrm;
521 register caddr_t addr;
522 register int len;
523{
524 register int current;
525
526 while (len > 0) {
527 current = (int)rstrm->in_boundry - (int)rstrm->in_finger;
528 if (current == 0) {
529 if (! fill_input_buf(rstrm))
530 return (FALSE);
531 continue;
532 }
533 current = (len < current) ? len : current;
534 bcopy(rstrm->in_finger, addr, current);
535 rstrm->in_finger += current;
536 addr += current;
537 len -= current;
538 }
539 return (TRUE);
540}
541
542static bool_t /* next two bytes of the input stream are treated as a header */
543set_input_fragment(rstrm)
544 register RECSTREAM *rstrm;
545{
546 u_long header;
547
548 if (! get_input_bytes(rstrm, (caddr_t)&header, sizeof(header)))
549 return (FALSE);
550 header = (long)ntohl(header);
551 rstrm->last_frag = ((header & LAST_FRAG) == 0) ? FALSE : TRUE;
552 rstrm->fbtbc = header & (~LAST_FRAG);
553 return (TRUE);
554}
555
556static bool_t /* consumes input bytes; knows nothing about records! */
557skip_input_bytes(rstrm, cnt)
558 register RECSTREAM *rstrm;
559 long cnt;
560{
561 register int current;
562
563 while (cnt > 0) {
564 current = (int)rstrm->in_boundry - (int)rstrm->in_finger;
565 if (current == 0) {
566 if (! fill_input_buf(rstrm))
567 return (FALSE);
568 continue;
569 }
570 current = (cnt < current) ? cnt : current;
571 rstrm->in_finger += current;
572 cnt -= current;
573 }
574 return (TRUE);
575}
576
577static u_int
578fix_buf_size(s)
579 register u_int s;
580{
581
582 if (s < 100)
583 s = 4000;
584 return (RNDUP(s));
585}
|