1/*
2 * xdr_array.c, Generic XDR routines implementation.
3 *
4 * Copyright (c) 2010, Oracle America, Inc.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are
8 * met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * * Redistributions in binary form must reproduce the above
13 * copyright notice, this list of conditions and the following
14 * disclaimer in the documentation and/or other materials
15 * provided with the distribution.
16 * * Neither the name of the "Oracle America, Inc." nor the names of its
17 * contributors may be used to endorse or promote products derived
18 * from this software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
24 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
25 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
27 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
29 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
30 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 *
33 * These are the "non-trivial" xdr primitives used to serialize and
34 * de-serialize arrays. See xdr.h for more info on the interface to xdr.
35 */
36
37#include <stdio.h>
38#include <string.h>
39#include <rpc/types.h>
40#include <rpc/xdr.h>
41#include <libintl.h>
42#include <limits.h>
43#include <wchar.h>
44
45#define LASTUNSIGNED ((u_int)0-1)
46
47
48/*
49 * XDR an array of arbitrary elements
50 * *addrp is a pointer to the array, *sizep is the number of elements.
51 * If addrp is NULL (*sizep * elsize) bytes are allocated.
52 * elsize is the size (in bytes) of each element, and elproc is the
53 * xdr procedure to call to handle each element of the array.
54 */
55bool_t
56xdr_array (XDR *xdrs,
57 /* array pointer */
58 caddr_t *addrp,
59 /* number of elements */
60 u_int *sizep,
61 /* max numberof elements */
62 u_int maxsize,
63 /* size in bytes of each element */
64 u_int elsize,
65 /* xdr routine to handle each element */
66 xdrproc_t elproc)
67{
68 u_int i;
69 caddr_t target = *addrp;
70 u_int c; /* the actual element count */
71 bool_t stat = TRUE;
72
73 /* like strings, arrays are really counted arrays */
74 if (!xdr_u_int (xdrs, sizep))
75 {
76 return FALSE;
77 }
78 c = *sizep;
79 /*
80 * XXX: Let the overflow possibly happen with XDR_FREE because mem_free()
81 * doesn't actually use its second argument anyway.
82 */
83 if ((c > maxsize || c > UINT_MAX / elsize) && (xdrs->x_op != XDR_FREE))
84 {
85 return FALSE;
86 }
87
88 /*
89 * if we are deserializing, we may need to allocate an array.
90 * We also save time by checking for a null array if we are freeing.
91 */
92 if (target == NULL)
93 switch (xdrs->x_op)
94 {
95 case XDR_DECODE:
96 if (c == 0)
97 return TRUE;
98 *addrp = target = calloc (c, elsize);
99 if (target == NULL)
100 {
101 (void) __fxprintf (NULL, "%s: %s", __func__, _("out of memory\n"));
102 return FALSE;
103 }
104 break;
105
106 case XDR_FREE:
107 return TRUE;
108 default:
109 break;
110 }
111
112 /*
113 * now we xdr each element of array
114 */
115 for (i = 0; (i < c) && stat; i++)
116 {
117 stat = (*elproc) (xdrs, target, LASTUNSIGNED);
118 target += elsize;
119 }
120
121 /*
122 * the array may need freeing
123 */
124 if (xdrs->x_op == XDR_FREE)
125 {
126 mem_free (*addrp, c * elsize);
127 *addrp = NULL;
128 }
129 return stat;
130}
131#ifdef EXPORT_RPC_SYMBOLS
132libc_hidden_def (xdr_array)
133#else
134libc_hidden_nolink_sunrpc (xdr_array, GLIBC_2_0)
135#endif
136
137/*
138 * xdr_vector():
139 *
140 * XDR a fixed length array. Unlike variable-length arrays,
141 * the storage of fixed length arrays is static and unfreeable.
142 * > basep: base of the array
143 * > size: size of the array
144 * > elemsize: size of each element
145 * > xdr_elem: routine to XDR each element
146 */
147bool_t
148xdr_vector (XDR *xdrs, char *basep, u_int nelem, u_int elemsize,
149 xdrproc_t xdr_elem)
150{
151 u_int i;
152 char *elptr;
153
154 elptr = basep;
155 for (i = 0; i < nelem; i++)
156 {
157 if (!(*xdr_elem) (xdrs, elptr, LASTUNSIGNED))
158 {
159 return FALSE;
160 }
161 elptr += elemsize;
162 }
163 return TRUE;
164}
165libc_hidden_nolink_sunrpc (xdr_vector, GLIBC_2_0)
166