2 * xdr_rec.c, Implements TCP/IP based XDR streams with a "record marking"
3 * layer above tcp (for rpc's use).
5 * Copyright (c) 2010, Oracle America, Inc.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions are
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above
14 * copyright notice, this list of conditions and the following
15 * disclaimer in the documentation and/or other materials
16 * provided with the distribution.
17 * * Neither the name of the "Oracle America, Inc." nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
26 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
28 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
30 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
31 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 * These routines interface XDRSTREAMS to a tcp/ip connection.
35 * There is a record marking layer between the xdr stream
36 * and the tcp transport level. A record is composed on one or more
37 * record fragments. A record fragment is a thirty-two bit header followed
38 * by n bytes of data, where n is contained in the header. The header
39 * is represented as a htonl(u_long). The high order bit encodes
40 * whether or not the fragment is the last fragment of the record
41 * (1 => fragment is last, 0 => more fragments to follow.
42 * The other 31 bits encode the byte length of the fragment.
53 # include <libio/iolibio.h>
56 static bool_t xdrrec_getlong (XDR *, long *);
57 static bool_t xdrrec_putlong (XDR *, const long *);
58 static bool_t xdrrec_getbytes (XDR *, caddr_t, u_int);
59 static bool_t xdrrec_putbytes (XDR *, const char *, u_int);
60 static u_int xdrrec_getpos (const XDR *);
61 static bool_t xdrrec_setpos (XDR *, u_int);
62 static int32_t *xdrrec_inline (XDR *, u_int);
63 static void xdrrec_destroy (XDR *);
64 static bool_t xdrrec_getint32 (XDR *, int32_t *);
65 static bool_t xdrrec_putint32 (XDR *, const int32_t *);
67 static const struct xdr_ops xdrrec_ops = {
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).
89 * The fragment/record machinery is not general; it is constructed to
90 * meet the needs of xdr and rpc based on tcp.
93 #define LAST_FRAG (1UL << 31)
95 typedef struct rec_strm
102 int (*writeit) (char *, char *, int);
103 caddr_t out_base; /* output buffer (points to frag header) */
104 caddr_t out_finger; /* next output position */
105 caddr_t out_boundry; /* data cannot up to this address */
106 u_int32_t *frag_header; /* beginning of curren fragment */
107 bool_t frag_sent; /* true if buffer sent in middle of record */
111 int (*readit) (char *, char *, int);
112 u_long in_size; /* fixed size of the input buffer */
114 caddr_t in_finger; /* location of next byte to be had */
115 caddr_t in_boundry; /* can read up to this location */
116 long fbtbc; /* fragment bytes to be consumed */
123 static u_int fix_buf_size (u_int) internal_function;
124 static bool_t skip_input_bytes (RECSTREAM *, long) internal_function;
125 static bool_t flush_out (RECSTREAM *, bool_t) internal_function;
126 static bool_t set_input_fragment (RECSTREAM *) internal_function;
127 static bool_t get_input_bytes (RECSTREAM *, caddr_t, int) internal_function;
130 * Create an xdr handle for xdrrec
131 * xdrrec_create fills in xdrs. Sendsize and recvsize are
132 * send and recv buffer sizes (0 => use default).
133 * tcp_handle is an opaque handle that is passed as the first parameter to
134 * the procedures readit and writeit. Readit and writeit are read and
135 * write respectively. They are like the system
136 * calls expect that they take an opaque handle rather than an fd.
139 xdrrec_create (XDR *xdrs, u_int sendsize,
140 u_int recvsize, caddr_t tcp_handle,
141 int (*readit) (char *, char *, int),
142 int (*writeit) (char *, char *, int))
144 RECSTREAM *rstrm = (RECSTREAM *) mem_alloc (sizeof (RECSTREAM));
148 sendsize = fix_buf_size (sendsize);
149 recvsize = fix_buf_size (recvsize);
150 buf = mem_alloc (sendsize + recvsize + BYTES_PER_XDR_UNIT);
152 if (rstrm == NULL || buf == NULL)
154 (void) __fxprintf (NULL, "%s: %s", __func__, _("out of memory\n"));
155 mem_free (rstrm, sizeof (RECSTREAM));
156 mem_free (buf, sendsize + recvsize + BYTES_PER_XDR_UNIT);
158 * This is bad. Should rework xdrrec_create to
159 * return a handle, and in this case return NULL
164 * adjust sizes and allocate buffer quad byte aligned
166 rstrm->sendsize = sendsize;
167 rstrm->recvsize = recvsize;
168 rstrm->the_buffer = buf;
169 tmp = rstrm->the_buffer;
170 if ((size_t)tmp % BYTES_PER_XDR_UNIT)
171 tmp += BYTES_PER_XDR_UNIT - (size_t)tmp % BYTES_PER_XDR_UNIT;
172 rstrm->out_base = tmp;
173 rstrm->in_base = tmp + sendsize;
177 /* We have to add the cast since the `struct xdr_ops' in `struct XDR'
179 xdrs->x_ops = (struct xdr_ops *) &xdrrec_ops;
180 xdrs->x_private = (caddr_t) rstrm;
181 rstrm->tcp_handle = tcp_handle;
182 rstrm->readit = readit;
183 rstrm->writeit = writeit;
184 rstrm->out_finger = rstrm->out_boundry = rstrm->out_base;
185 rstrm->frag_header = (u_int32_t *) rstrm->out_base;
186 rstrm->out_finger += 4;
187 rstrm->out_boundry += sendsize;
188 rstrm->frag_sent = FALSE;
189 rstrm->in_size = recvsize;
190 rstrm->in_boundry = rstrm->in_base;
191 rstrm->in_finger = (rstrm->in_boundry += recvsize);
193 rstrm->last_frag = TRUE;
195 libc_hidden_nolink (xdrrec_create, GLIBC_2_0)
199 * The routines defined below are the xdr ops which will go into the
200 * xdr handle filled in by xdrrec_create.
204 xdrrec_getlong (XDR *xdrs, long *lp)
206 RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
207 int32_t *buflp = (int32_t *) rstrm->in_finger;
210 /* first try the inline, fast case */
211 if (rstrm->fbtbc >= BYTES_PER_XDR_UNIT &&
212 rstrm->in_boundry - (char *) buflp >= BYTES_PER_XDR_UNIT)
214 *lp = (int32_t) ntohl (*buflp);
215 rstrm->fbtbc -= BYTES_PER_XDR_UNIT;
216 rstrm->in_finger += BYTES_PER_XDR_UNIT;
220 if (!xdrrec_getbytes (xdrs, (caddr_t) & mylong,
223 *lp = (int32_t) ntohl (mylong);
229 xdrrec_putlong (XDR *xdrs, const long *lp)
231 RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
232 int32_t *dest_lp = (int32_t *) rstrm->out_finger;
234 if ((rstrm->out_finger += BYTES_PER_XDR_UNIT) > rstrm->out_boundry)
237 * this case should almost never happen so the code is
240 rstrm->out_finger -= BYTES_PER_XDR_UNIT;
241 rstrm->frag_sent = TRUE;
242 if (!flush_out (rstrm, FALSE))
244 dest_lp = (int32_t *) rstrm->out_finger;
245 rstrm->out_finger += BYTES_PER_XDR_UNIT;
247 *dest_lp = htonl (*lp);
251 static bool_t /* must manage buffers, fragments, and records */
252 xdrrec_getbytes (XDR *xdrs, caddr_t addr, u_int len)
254 RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
259 current = rstrm->fbtbc;
262 if (rstrm->last_frag)
264 if (!set_input_fragment (rstrm))
268 current = (len < current) ? len : current;
269 if (!get_input_bytes (rstrm, addr, current))
272 rstrm->fbtbc -= current;
279 xdrrec_putbytes (XDR *xdrs, const char *addr, u_int len)
281 RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
286 current = rstrm->out_boundry - rstrm->out_finger;
287 current = (len < current) ? len : current;
288 memcpy (rstrm->out_finger, addr, current);
289 rstrm->out_finger += current;
292 if (rstrm->out_finger == rstrm->out_boundry && len > 0)
294 rstrm->frag_sent = TRUE;
295 if (!flush_out (rstrm, FALSE))
303 xdrrec_getpos (const XDR *xdrs)
305 RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
308 pos = __lseek ((int) (long) rstrm->tcp_handle, (long) 0, 1);
314 pos += rstrm->out_finger - rstrm->out_base;
318 pos -= rstrm->in_boundry - rstrm->in_finger;
329 xdrrec_setpos (XDR *xdrs, u_int pos)
331 RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
332 u_int currpos = xdrrec_getpos (xdrs);
333 int delta = currpos - pos;
336 if ((int) currpos != -1)
341 newpos = rstrm->out_finger - delta;
342 if (newpos > (caddr_t) rstrm->frag_header &&
343 newpos < rstrm->out_boundry)
345 rstrm->out_finger = newpos;
351 newpos = rstrm->in_finger - delta;
352 if ((delta < (int) (rstrm->fbtbc)) &&
353 (newpos <= rstrm->in_boundry) &&
354 (newpos >= rstrm->in_base))
356 rstrm->in_finger = newpos;
357 rstrm->fbtbc -= delta;
369 xdrrec_inline (XDR *xdrs, u_int len)
371 RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
378 if ((rstrm->out_finger + len) <= rstrm->out_boundry)
380 buf = (int32_t *) rstrm->out_finger;
381 rstrm->out_finger += len;
386 if ((len <= rstrm->fbtbc) &&
387 ((rstrm->in_finger + len) <= rstrm->in_boundry))
389 buf = (int32_t *) rstrm->in_finger;
391 rstrm->in_finger += len;
402 xdrrec_destroy (XDR *xdrs)
404 RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
406 mem_free (rstrm->the_buffer,
407 rstrm->sendsize + rstrm->recvsize + BYTES_PER_XDR_UNIT);
408 mem_free ((caddr_t) rstrm, sizeof (RECSTREAM));
412 xdrrec_getint32 (XDR *xdrs, int32_t *ip)
414 RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
415 int32_t *bufip = (int32_t *) rstrm->in_finger;
418 /* first try the inline, fast case */
419 if (rstrm->fbtbc >= BYTES_PER_XDR_UNIT &&
420 rstrm->in_boundry - (char *) bufip >= BYTES_PER_XDR_UNIT)
422 *ip = ntohl (*bufip);
423 rstrm->fbtbc -= BYTES_PER_XDR_UNIT;
424 rstrm->in_finger += BYTES_PER_XDR_UNIT;
428 if (!xdrrec_getbytes (xdrs, (caddr_t) &mylong,
431 *ip = ntohl (mylong);
437 xdrrec_putint32 (XDR *xdrs, const int32_t *ip)
439 RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
440 int32_t *dest_ip = (int32_t *) rstrm->out_finger;
442 if ((rstrm->out_finger += BYTES_PER_XDR_UNIT) > rstrm->out_boundry)
445 * this case should almost never happen so the code is
448 rstrm->out_finger -= BYTES_PER_XDR_UNIT;
449 rstrm->frag_sent = TRUE;
450 if (!flush_out (rstrm, FALSE))
452 dest_ip = (int32_t *) rstrm->out_finger;
453 rstrm->out_finger += BYTES_PER_XDR_UNIT;
455 *dest_ip = htonl (*ip);
460 * Exported routines to manage xdr records
464 * Before reading (deserializing from the stream, one should always call
465 * this procedure to guarantee proper record alignment.
468 xdrrec_skiprecord (XDR *xdrs)
470 RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
472 while (rstrm->fbtbc > 0 || (!rstrm->last_frag))
474 if (!skip_input_bytes (rstrm, rstrm->fbtbc))
477 if ((!rstrm->last_frag) && (!set_input_fragment (rstrm)))
480 rstrm->last_frag = FALSE;
483 libc_hidden_nolink (xdrrec_skiprecord, GLIBC_2_0)
486 * Lookahead function.
487 * Returns TRUE iff there is no more input in the buffer
488 * after consuming the rest of the current record.
491 xdrrec_eof (XDR *xdrs)
493 RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
495 while (rstrm->fbtbc > 0 || (!rstrm->last_frag))
497 if (!skip_input_bytes (rstrm, rstrm->fbtbc))
500 if ((!rstrm->last_frag) && (!set_input_fragment (rstrm)))
503 if (rstrm->in_finger == rstrm->in_boundry)
507 libc_hidden_nolink (xdrrec_eof, GLIBC_2_0)
510 * The client must tell the package when an end-of-record has occurred.
511 * The second parameter tells whether the record should be flushed to the
512 * (output) tcp stream. (This lets the package support batched or
513 * pipelined procedure calls.) TRUE => immediate flush to tcp connection.
516 xdrrec_endofrecord (XDR *xdrs, bool_t sendnow)
518 RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
519 u_long len; /* fragment length */
521 if (sendnow || rstrm->frag_sent
522 || rstrm->out_finger + BYTES_PER_XDR_UNIT >= rstrm->out_boundry)
524 rstrm->frag_sent = FALSE;
525 return flush_out (rstrm, TRUE);
527 len = (rstrm->out_finger - (char *) rstrm->frag_header
528 - BYTES_PER_XDR_UNIT);
529 *rstrm->frag_header = htonl ((u_long) len | LAST_FRAG);
530 rstrm->frag_header = (u_int32_t *) rstrm->out_finger;
531 rstrm->out_finger += BYTES_PER_XDR_UNIT;
534 libc_hidden_nolink (xdrrec_endofrecord, GLIBC_2_0)
538 * Internal useful routines
542 flush_out (RECSTREAM *rstrm, bool_t eor)
544 u_long eormask = (eor == TRUE) ? LAST_FRAG : 0;
545 u_long len = (rstrm->out_finger - (char *) rstrm->frag_header
546 - BYTES_PER_XDR_UNIT);
548 *rstrm->frag_header = htonl (len | eormask);
549 len = rstrm->out_finger - rstrm->out_base;
550 if ((*(rstrm->writeit)) (rstrm->tcp_handle, rstrm->out_base, (int) len)
553 rstrm->frag_header = (u_int32_t *) rstrm->out_base;
554 rstrm->out_finger = (caddr_t) rstrm->out_base + BYTES_PER_XDR_UNIT;
558 static bool_t /* knows nothing about records! Only about input buffers */
559 fill_input_buf (RECSTREAM *rstrm)
565 where = rstrm->in_base;
566 i = (size_t) rstrm->in_boundry % BYTES_PER_XDR_UNIT;
568 len = rstrm->in_size - i;
569 if ((len = (*(rstrm->readit)) (rstrm->tcp_handle, where, len)) == -1)
571 rstrm->in_finger = where;
573 rstrm->in_boundry = where;
577 static bool_t /* knows nothing about records! Only about input buffers */
579 get_input_bytes (RECSTREAM *rstrm, caddr_t addr, int len)
585 current = rstrm->in_boundry - rstrm->in_finger;
588 if (!fill_input_buf (rstrm))
592 current = (len < current) ? len : current;
593 memcpy (addr, rstrm->in_finger, current);
594 rstrm->in_finger += current;
601 static bool_t /* next two bytes of the input stream are treated as a header */
603 set_input_fragment (RECSTREAM *rstrm)
607 if (! get_input_bytes (rstrm, (caddr_t)&header, BYTES_PER_XDR_UNIT))
609 header = ntohl (header);
610 rstrm->last_frag = ((header & LAST_FRAG) == 0) ? FALSE : TRUE;
612 * Sanity check. Try not to accept wildly incorrect fragment
613 * sizes. Unfortunately, only a size of zero can be identified as
614 * 'wildely incorrect', and this only, if it is not the last
615 * fragment of a message. Ridiculously large fragment sizes may look
616 * wrong, but we don't have any way to be certain that they aren't
617 * what the client actually intended to send us. Many existing RPC
618 * implementations may sent a fragment of size zero as the last
619 * fragment of a message.
623 rstrm->fbtbc = header & ~LAST_FRAG;
627 static bool_t /* consumes input bytes; knows nothing about records! */
629 skip_input_bytes (RECSTREAM *rstrm, long cnt)
635 current = rstrm->in_boundry - rstrm->in_finger;
638 if (!fill_input_buf (rstrm))
642 current = (cnt < current) ? cnt : current;
643 rstrm->in_finger += current;
651 fix_buf_size (u_int s)