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