1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2008 Isilon Inc http://www.isilon.com/
5 * Authors: Doug Rabson <[email protected]>
6 * Developed with Red Inc: Alfred Perlstein <[email protected]>
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 */
29
30 #include <sys/cdefs.h>
31 #include <sys/param.h>
32 #include <sys/systm.h>
33 #include <sys/malloc.h>
34 #include <sys/mbuf.h>
35
36 #include <rpc/types.h>
37 #include <rpc/xdr.h>
38
39 static void xdrmbuf_destroy(XDR *);
40 static bool_t xdrmbuf_getlong(XDR *, long *);
41 static bool_t xdrmbuf_putlong(XDR *, const long *);
42 static bool_t xdrmbuf_getbytes(XDR *, char *, u_int);
43 static bool_t xdrmbuf_putbytes(XDR *, const char *, u_int);
44 /* XXX: w/64-bit pointers, u_int not enough! */
45 static u_int xdrmbuf_getpos(XDR *);
46 static bool_t xdrmbuf_setpos(XDR *, u_int);
47 static int32_t *xdrmbuf_inline(XDR *, u_int);
48
49 static const struct xdr_ops xdrmbuf_ops = {
50 xdrmbuf_getlong,
51 xdrmbuf_putlong,
52 xdrmbuf_getbytes,
53 xdrmbuf_putbytes,
54 xdrmbuf_getpos,
55 xdrmbuf_setpos,
56 xdrmbuf_inline,
57 xdrmbuf_destroy
58 };
59
60 /*
61 * The procedure xdrmbuf_create initializes a stream descriptor for a
62 * mbuf.
63 */
64 void
xdrmbuf_create(XDR * xdrs,struct mbuf * m,enum xdr_op op)65 xdrmbuf_create(XDR *xdrs, struct mbuf *m, enum xdr_op op)
66 {
67
68 KASSERT(m != NULL, ("xdrmbuf_create with NULL mbuf chain"));
69 xdrs->x_op = op;
70 xdrs->x_ops = &xdrmbuf_ops;
71 xdrs->x_base = (char *) m;
72 if (op == XDR_ENCODE) {
73 m = m_last(m);
74 xdrs->x_private = m;
75 xdrs->x_handy = m->m_len;
76 } else {
77 xdrs->x_private = m;
78 xdrs->x_handy = 0;
79 }
80 }
81
82 void
xdrmbuf_append(XDR * xdrs,struct mbuf * madd)83 xdrmbuf_append(XDR *xdrs, struct mbuf *madd)
84 {
85 struct mbuf *m;
86
87 KASSERT(xdrs->x_ops == &xdrmbuf_ops && xdrs->x_op == XDR_ENCODE,
88 ("xdrmbuf_append: invalid XDR stream"));
89
90 if (m_length(madd, NULL) == 0) {
91 m_freem(madd);
92 return;
93 }
94
95 m = (struct mbuf *) xdrs->x_private;
96 m->m_next = madd;
97
98 m = m_last(madd);
99 xdrs->x_private = m;
100 xdrs->x_handy = m->m_len;
101 }
102
103 struct mbuf *
xdrmbuf_getall(XDR * xdrs)104 xdrmbuf_getall(XDR *xdrs)
105 {
106 struct mbuf *m0, *m;
107
108 KASSERT(xdrs->x_ops == &xdrmbuf_ops && xdrs->x_op == XDR_DECODE,
109 ("xdrmbuf_append: invalid XDR stream"));
110
111 m0 = (struct mbuf *) xdrs->x_base;
112 m = (struct mbuf *) xdrs->x_private;
113 if (m0 != m) {
114 while (m0->m_next != m)
115 m0 = m0->m_next;
116 m0->m_next = NULL;
117 xdrs->x_private = NULL;
118 } else {
119 xdrs->x_base = NULL;
120 xdrs->x_private = NULL;
121 }
122
123 if (m)
124 m_adj(m, xdrs->x_handy);
125 else
126 m = m_get(M_WAITOK, MT_DATA);
127 return (m);
128 }
129
130 static void
xdrmbuf_destroy(XDR * xdrs)131 xdrmbuf_destroy(XDR *xdrs)
132 {
133
134 if (xdrs->x_op == XDR_DECODE && xdrs->x_base) {
135 m_freem((struct mbuf *) xdrs->x_base);
136 xdrs->x_base = NULL;
137 xdrs->x_private = NULL;
138 }
139 }
140
141 static bool_t
xdrmbuf_getlong(XDR * xdrs,long * lp)142 xdrmbuf_getlong(XDR *xdrs, long *lp)
143 {
144 int32_t *p;
145 int32_t t;
146
147 p = xdrmbuf_inline(xdrs, sizeof(int32_t));
148 if (p) {
149 t = *p;
150 } else {
151 xdrmbuf_getbytes(xdrs, (char *) &t, sizeof(int32_t));
152 }
153
154 *lp = ntohl(t);
155 return (TRUE);
156 }
157
158 static bool_t
xdrmbuf_putlong(XDR * xdrs,const long * lp)159 xdrmbuf_putlong(XDR *xdrs, const long *lp)
160 {
161 int32_t *p;
162 int32_t t = htonl(*lp);
163
164 p = xdrmbuf_inline(xdrs, sizeof(int32_t));
165 if (p) {
166 *p = t;
167 return (TRUE);
168 } else {
169 return (xdrmbuf_putbytes(xdrs, (char *) &t, sizeof(int32_t)));
170 }
171 }
172
173 static bool_t
xdrmbuf_getbytes(XDR * xdrs,char * addr,u_int len)174 xdrmbuf_getbytes(XDR *xdrs, char *addr, u_int len)
175 {
176 struct mbuf *m = (struct mbuf *) xdrs->x_private;
177 size_t sz;
178
179 while (len > 0) {
180 /*
181 * Make sure we haven't hit the end.
182 */
183 if (!m) {
184 return (FALSE);
185 }
186
187 /*
188 * See how much we can get from this mbuf.
189 */
190 sz = m->m_len - xdrs->x_handy;
191 if (sz > len)
192 sz = len;
193 bcopy(mtod(m, const char *) + xdrs->x_handy, addr, sz);
194
195 addr += sz;
196 xdrs->x_handy += sz;
197 len -= sz;
198
199 if (xdrs->x_handy == m->m_len) {
200 m = m->m_next;
201 xdrs->x_private = (void *) m;
202 xdrs->x_handy = 0;
203 }
204 }
205
206 return (TRUE);
207 }
208
209 static bool_t
xdrmbuf_putbytes(XDR * xdrs,const char * addr,u_int len)210 xdrmbuf_putbytes(XDR *xdrs, const char *addr, u_int len)
211 {
212 struct mbuf *m = (struct mbuf *) xdrs->x_private;
213 struct mbuf *n;
214 size_t sz;
215
216 while (len > 0) {
217 sz = M_TRAILINGSPACE(m) + (m->m_len - xdrs->x_handy);
218 if (sz > len)
219 sz = len;
220 bcopy(addr, mtod(m, char *) + xdrs->x_handy, sz);
221 addr += sz;
222 xdrs->x_handy += sz;
223 if (xdrs->x_handy > m->m_len)
224 m->m_len = xdrs->x_handy;
225 len -= sz;
226
227 if (xdrs->x_handy == m->m_len && M_TRAILINGSPACE(m) == 0) {
228 if (!m->m_next) {
229 if (m->m_flags & M_EXT)
230 n = m_getcl(M_WAITOK, m->m_type, 0);
231 else
232 n = m_get(M_WAITOK, m->m_type);
233 m->m_next = n;
234 }
235 m = m->m_next;
236 xdrs->x_private = (void *) m;
237 xdrs->x_handy = 0;
238 }
239 }
240
241 return (TRUE);
242 }
243
244 static u_int
xdrmbuf_getpos(XDR * xdrs)245 xdrmbuf_getpos(XDR *xdrs)
246 {
247 struct mbuf *m0 = (struct mbuf *) xdrs->x_base;
248 struct mbuf *m = (struct mbuf *) xdrs->x_private;
249 u_int pos = 0;
250
251 while (m0 && m0 != m) {
252 pos += m0->m_len;
253 m0 = m0->m_next;
254 }
255 KASSERT(m0, ("Corrupted mbuf chain"));
256
257 return (pos + xdrs->x_handy);
258 }
259
260 static bool_t
xdrmbuf_setpos(XDR * xdrs,u_int pos)261 xdrmbuf_setpos(XDR *xdrs, u_int pos)
262 {
263 struct mbuf *m = (struct mbuf *) xdrs->x_base;
264
265 while (m && pos > m->m_len) {
266 pos -= m->m_len;
267 m = m->m_next;
268 }
269 KASSERT(m, ("Corrupted mbuf chain"));
270
271 xdrs->x_private = (void *) m;
272 xdrs->x_handy = pos;
273
274 return (TRUE);
275 }
276
277 static int32_t *
xdrmbuf_inline(XDR * xdrs,u_int len)278 xdrmbuf_inline(XDR *xdrs, u_int len)
279 {
280 struct mbuf *m = (struct mbuf *) xdrs->x_private;
281 size_t available;
282 char *p;
283
284 if (!m)
285 return (0);
286 if (xdrs->x_op == XDR_ENCODE) {
287 available = M_TRAILINGSPACE(m) + (m->m_len - xdrs->x_handy);
288 } else {
289 available = m->m_len - xdrs->x_handy;
290 }
291
292 if (available >= len) {
293 p = mtod(m, char *) + xdrs->x_handy;
294 if (((uintptr_t) p) & (sizeof(int32_t) - 1))
295 return (0);
296 xdrs->x_handy += len;
297 if (xdrs->x_handy > m->m_len)
298 m->m_len = xdrs->x_handy;
299 return ((int32_t *) p);
300 }
301
302 return (0);
303 }
304