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) 1984, Sun Microsystems, 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 Sun Microsystems, 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 INTDEF(xdrrec_create
)
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 INTDEF(xdrrec_skiprecord
)
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
)
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 INTDEF(xdrrec_endofrecord
)
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
)