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";*/
|
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}
|