1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
28 /* All Rights Reserved */
29
30 /*
31 * Portions of this source code were derived from Berkeley 4.3 BSD
32 * under license from the Regents of the University of California.
33 */
34
35 /*
36 * xdr_mem.c, XDR implementation using memory buffers.
37 *
38 * If you have some data to be interpreted as external data representation
39 * or to be converted to external data representation in a memory buffer,
40 * then this is the package for you.
41 */
42
43 #include <sys/param.h>
44 #include <sys/types.h>
45 #include <sys/systm.h>
46
47 #include <rpc/types.h>
48 #include <rpc/xdr.h>
49
50 static struct xdr_ops *xdrmem_ops(void);
51
52 /*
53 * The procedure xdrmem_create initializes a stream descriptor for a
54 * memory buffer.
55 */
56 void
xdrmem_create(XDR * xdrs,caddr_t addr,uint_t size,enum xdr_op op)57 xdrmem_create(XDR *xdrs, caddr_t addr, uint_t size, enum xdr_op op)
58 {
59 xdrs->x_op = op;
60 xdrs->x_ops = xdrmem_ops();
61 xdrs->x_private = xdrs->x_base = addr;
62 xdrs->x_handy = size;
63 xdrs->x_public = NULL;
64 }
65
66 /* ARGSUSED */
67 static void
xdrmem_destroy(XDR * xdrs)68 xdrmem_destroy(XDR *xdrs)
69 {
70 }
71
72 static bool_t
xdrmem_getint32(XDR * xdrs,int32_t * int32p)73 xdrmem_getint32(XDR *xdrs, int32_t *int32p)
74 {
75 if ((xdrs->x_handy -= (int)sizeof (int32_t)) < 0)
76 return (FALSE);
77 /* LINTED pointer alignment */
78 *int32p = (int32_t)ntohl((uint32_t)(*((int32_t *)(xdrs->x_private))));
79 xdrs->x_private += sizeof (int32_t);
80 return (TRUE);
81 }
82
83 static bool_t
xdrmem_putint32(XDR * xdrs,int32_t * int32p)84 xdrmem_putint32(XDR *xdrs, int32_t *int32p)
85 {
86 if ((xdrs->x_handy -= (int)sizeof (int32_t)) < 0)
87 return (FALSE);
88 /* LINTED pointer alignment */
89 *(int32_t *)xdrs->x_private = (int32_t)htonl((uint32_t)(*int32p));
90 xdrs->x_private += sizeof (int32_t);
91 return (TRUE);
92 }
93
94 static bool_t
xdrmem_getbytes(XDR * xdrs,caddr_t addr,int len)95 xdrmem_getbytes(XDR *xdrs, caddr_t addr, int len)
96 {
97 if ((xdrs->x_handy -= len) < 0)
98 return (FALSE);
99 bcopy(xdrs->x_private, addr, len);
100 xdrs->x_private += len;
101 return (TRUE);
102 }
103
104 static bool_t
xdrmem_putbytes(XDR * xdrs,caddr_t addr,int len)105 xdrmem_putbytes(XDR *xdrs, caddr_t addr, int len)
106 {
107 if ((xdrs->x_handy -= len) < 0)
108 return (FALSE);
109 bcopy(addr, xdrs->x_private, len);
110 xdrs->x_private += len;
111 return (TRUE);
112 }
113
114 static uint_t
xdrmem_getpos(XDR * xdrs)115 xdrmem_getpos(XDR *xdrs)
116 {
117 return ((uint_t)((uintptr_t)xdrs->x_private - (uintptr_t)xdrs->x_base));
118 }
119
120 static bool_t
xdrmem_setpos(XDR * xdrs,uint_t pos)121 xdrmem_setpos(XDR *xdrs, uint_t pos)
122 {
123 caddr_t newaddr = xdrs->x_base + pos;
124 caddr_t lastaddr = xdrs->x_private + xdrs->x_handy;
125 ptrdiff_t diff;
126
127 if (newaddr > lastaddr)
128 return (FALSE);
129 xdrs->x_private = newaddr;
130 diff = lastaddr - newaddr;
131 xdrs->x_handy = (int)diff;
132 return (TRUE);
133 }
134
135 static rpc_inline_t *
xdrmem_inline(XDR * xdrs,int len)136 xdrmem_inline(XDR *xdrs, int len)
137 {
138 rpc_inline_t *buf = NULL;
139
140 if (xdrs->x_handy >= len) {
141 xdrs->x_handy -= len;
142 /* LINTED pointer alignment */
143 buf = (rpc_inline_t *)xdrs->x_private;
144 xdrs->x_private += len;
145 }
146 return (buf);
147 }
148
149 static bool_t
xdrmem_control(XDR * xdrs,int request,void * info)150 xdrmem_control(XDR *xdrs, int request, void *info)
151 {
152 xdr_bytesrec *xptr;
153 int32_t *int32p;
154 int len;
155
156 switch (request) {
157
158 case XDR_GET_BYTES_AVAIL:
159 xptr = (xdr_bytesrec *)info;
160 xptr->xc_is_last_record = TRUE;
161 xptr->xc_num_avail = xdrs->x_handy;
162 return (TRUE);
163
164 case XDR_PEEK:
165 /*
166 * Return the next 4 byte unit in the XDR stream.
167 */
168 if (xdrs->x_handy < sizeof (int32_t))
169 return (FALSE);
170 int32p = (int32_t *)info;
171 *int32p = (int32_t)ntohl((uint32_t)
172 (*((int32_t *)(xdrs->x_private))));
173 return (TRUE);
174
175 case XDR_SKIPBYTES:
176 /*
177 * Skip the next N bytes in the XDR stream.
178 */
179 int32p = (int32_t *)info;
180 len = RNDUP((int)(*int32p));
181 if ((xdrs->x_handy -= len) < 0)
182 return (FALSE);
183 xdrs->x_private += len;
184 return (TRUE);
185
186 }
187 return (FALSE);
188 }
189
190 static struct xdr_ops *
xdrmem_ops(void)191 xdrmem_ops(void)
192 {
193 static struct xdr_ops ops;
194
195 if (ops.x_getint32 == NULL) {
196 ops.x_getbytes = xdrmem_getbytes;
197 ops.x_putbytes = xdrmem_putbytes;
198 ops.x_getpostn = xdrmem_getpos;
199 ops.x_setpostn = xdrmem_setpos;
200 ops.x_inline = xdrmem_inline;
201 ops.x_destroy = xdrmem_destroy;
202 ops.x_control = xdrmem_control;
203 ops.x_getint32 = xdrmem_getint32;
204 ops.x_putint32 = xdrmem_putint32;
205 }
206 return (&ops);
207 }
208