?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
nightly: use make -de
[unleashed.git] / kernel / fs / autofs / auto_xdr.c
blob3a02a62d781938378509aa791bf9e3fd4221f787
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 (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /*
27 * This file can not be automatically generated by rpcgen from
28 * autofs_prot.x because of the xdr routines that provide readdir
29 * support, its own implementation of xdr_autofs_netbuf(). rpcgen will
30 * also generate xdr routines with recursion which should not be used
31 * in the kernel.
32 */
33
34 #include <sys/param.h>
35 #include <sys/kmem.h>
36 #include <sys/errno.h>
37 #include <sys/proc.h>
38 #include <sys/vfs.h>
39 #include <sys/vnode.h>
40 #include <sys/pathname.h>
41 #include <sys/cred.h>
42 #include <sys/mount.h>
43 #include <sys/cmn_err.h>
44 #include <sys/debug.h>
45 #include <sys/systm.h>
46 #include <rpc/types.h>
47 #include <rpc/xdr.h>
48 #include <rpc/auth.h>
49 #include <rpc/clnt.h>
50 #include <sys/ticotsord.h>
51 #include <sys/dirent.h>
52 #include <sys/sysmacros.h>
53 #include <sys/fs_subr.h>
54 #include <sys/fs/autofs.h>
55
56 bool_t xdr_autofs_netbuf(XDR *, struct netbuf *);
57 bool_t xdr_mounta(XDR *, struct mounta *);
58
59 bool_t
60 xdr_umntrequest(XDR *xdrs, umntrequest *objp)
61 {
62 bool_t more_data;
63
64 ASSERT(xdrs->x_op == XDR_ENCODE);
65
66 for (; objp != NULL; objp = objp->next) {
67 if (!xdr_bool_t(xdrs, &objp->isdirect))
68 return (FALSE);
69 if (!xdr_string(xdrs, &objp->mntresource, AUTOFS_MAXPATHLEN))
70 return (FALSE);
71 if (!xdr_string(xdrs, &objp->mntpnt, AUTOFS_MAXPATHLEN))
72 return (FALSE);
73 if (!xdr_string(xdrs, &objp->fstype, AUTOFS_MAXCOMPONENTLEN))
74 return (FALSE);
75 if (!xdr_string(xdrs, &objp->mntopts, AUTOFS_MAXOPTSLEN))
76 return (FALSE);
77
78 if (objp->next != NULL)
79 more_data = TRUE;
80 else
81 more_data = FALSE;
82
83 if (!xdr_bool(xdrs, &more_data))
84 return (FALSE);
85 }
86 return (TRUE);
87 }
88
89 bool_t
90 xdr_umntres(XDR *xdrs, umntres *objp)
91 {
92 return (xdr_int(xdrs, &objp->status));
93 }
94
95 bool_t
96 xdr_autofs_stat(XDR *xdrs, autofs_stat *objp)
97 {
98 if (!xdr_enum(xdrs, (enum_t *)objp))
99 return (FALSE);
100 return (TRUE);
101 }
102
103 bool_t
104 xdr_autofs_action(XDR *xdrs, autofs_action *objp)
105 {
106 if (!xdr_enum(xdrs, (enum_t *)objp))
107 return (FALSE);
108 return (TRUE);
109 }
110
111 bool_t
112 xdr_linka(XDR *xdrs, linka *objp)
113 {
114 if (!xdr_string(xdrs, &objp->dir, AUTOFS_MAXPATHLEN))
115 return (FALSE);
116 if (!xdr_string(xdrs, &objp->link, AUTOFS_MAXPATHLEN))
117 return (FALSE);
118 return (TRUE);
119 }
120
121 bool_t
122 xdr_autofs_args(XDR *xdrs, autofs_args *objp)
123 {
124 if (!xdr_autofs_netbuf(xdrs, &objp->addr))
125 return (FALSE);
126 if (!xdr_string(xdrs, &objp->path, AUTOFS_MAXPATHLEN))
127 return (FALSE);
128 if (!xdr_string(xdrs, &objp->opts, AUTOFS_MAXOPTSLEN))
129 return (FALSE);
130 if (!xdr_string(xdrs, &objp->map, AUTOFS_MAXPATHLEN))
131 return (FALSE);
132 if (!xdr_string(xdrs, &objp->subdir, AUTOFS_MAXPATHLEN))
133 return (FALSE);
134 if (!xdr_string(xdrs, &objp->key, AUTOFS_MAXCOMPONENTLEN))
135 return (FALSE);
136 if (!xdr_int(xdrs, &objp->mount_to))
137 return (FALSE);
138 if (!xdr_int(xdrs, &objp->rpc_to))
139 return (FALSE);
140 if (!xdr_int(xdrs, &objp->direct))
141 return (FALSE);
142 return (TRUE);
143 }
144
145 bool_t
146 xdr_action_list_entry(XDR *xdrs, action_list_entry *objp)
147 {
148 if (!xdr_autofs_action(xdrs, &objp->action))
149 return (FALSE);
150 switch (objp->action) {
151 case AUTOFS_MOUNT_RQ:
152 if (!xdr_mounta(xdrs, &objp->action_list_entry_u.mounta))
153 return (FALSE);
154 break;
155 case AUTOFS_LINK_RQ:
156 if (!xdr_linka(xdrs, &objp->action_list_entry_u.linka))
157 return (FALSE);
158 break;
159 default:
160 break;
161 }
162 return (TRUE);
163 }
164
165 bool_t
166 xdr_action_list(XDR *xdrs, action_list *objp)
167 {
168 bool_t more_data = TRUE;
169 bool_t status = TRUE;
170 action_list *p, *last;
171
172 ASSERT((xdrs->x_op == XDR_DECODE) || (xdrs->x_op == XDR_FREE));
173
174 more_data = (objp != NULL);
175 p = objp;
176
177 if (xdrs->x_op == XDR_FREE) {
178 while (p != NULL) {
179 if (!xdr_action_list_entry(xdrs, &p->action))
180 cmn_err(CE_WARN, "xdr_action_list: "
181 "action_list_entry free failed %p\n",
182 (void *)&p->action);
183 last = p;
184 p = p->next;
185 kmem_free(last, sizeof (*last));
186 }
187 return (status);
188 }
189
190 while (more_data) {
191 if (!xdr_action_list_entry(xdrs, &p->action)) {
192 status = FALSE;
193 break;
194 }
195
196 if (!xdr_bool(xdrs, &more_data)) {
197 status = FALSE;
198 break;
199 }
200
201 if (more_data) {
202 p->next = kmem_zalloc(sizeof (action_list), KM_SLEEP);
203 p = p->next;
204 if (p == NULL) {
205 status = FALSE;
206 break;
207 }
208 } else
209 p->next = NULL;
210 }
211 return (status);
212 }
213
214 bool_t
215 xdr_autofs_netbuf(XDR *xdrs, struct netbuf *objp)
216 {
217 bool_t dummy;
218
219 if (!xdr_u_int(xdrs, (uint_t *)&objp->maxlen))
220 return (FALSE);
221 dummy = xdr_bytes(xdrs, (char **)&(objp->buf),
222 (uint_t *)&(objp->len), objp->maxlen);
223 return (dummy);
224 }
225
226 bool_t
227 xdr_mounta(XDR *xdrs, struct mounta *objp)
228 {
229 if (!xdr_string(xdrs, &objp->spec, AUTOFS_MAXPATHLEN))
230 return (FALSE);
231 if (!xdr_string(xdrs, &objp->dir, AUTOFS_MAXPATHLEN))
232 return (FALSE);
233 if (!xdr_int(xdrs, &objp->flags))
234 return (FALSE);
235 if (!xdr_string(xdrs, &objp->fstype, AUTOFS_MAXCOMPONENTLEN))
236 return (FALSE);
237 if (!xdr_pointer(xdrs, (char **)&objp->dataptr, sizeof (autofs_args),
238 (xdrproc_t)xdr_autofs_args))
239 return (FALSE);
240 /*
241 * The length is the original user-land length, not the
242 * length of the native kernel autofs_args structure provided
243 * after we decode the xdr buffer. So passing the user's idea of
244 * the length is wrong and we need to stuff the length field with
245 * the length of the native structure.
246 */
247 if (!xdr_int(xdrs, &objp->datalen))
248 return (FALSE);
249 if (xdrs->x_op == XDR_DECODE)
250 objp->datalen = sizeof (struct autofs_args);
251 if (!xdr_string(xdrs, &objp->optptr, AUTOFS_MAXOPTSLEN))
252 return (FALSE);
253 if (!xdr_int(xdrs, &objp->optlen))
254 return (FALSE);
255 ASSERT((xdrs->x_op == XDR_DECODE) || (xdrs->x_op == XDR_FREE));
256 return (TRUE);
257 }
258
259 bool_t
260 xdr_autofs_res(XDR *xdrs, autofs_res *objp)
261 {
262 if (!xdr_enum(xdrs, (enum_t *)objp))
263 return (FALSE);
264 return (TRUE);
265 }
266
267 bool_t
268 xdr_autofs_lookupargs(XDR *xdrs, autofs_lookupargs *objp)
269 {
270 if (!xdr_string(xdrs, &objp->map, AUTOFS_MAXPATHLEN))
271 return (FALSE);
272 if (!xdr_string(xdrs, &objp->path, AUTOFS_MAXPATHLEN))
273 return (FALSE);
274 if (!xdr_string(xdrs, &objp->name, AUTOFS_MAXCOMPONENTLEN))
275 return (FALSE);
276 if (!xdr_string(xdrs, &objp->subdir, AUTOFS_MAXPATHLEN))
277 return (FALSE);
278 if (!xdr_string(xdrs, &objp->opts, AUTOFS_MAXOPTSLEN))
279 return (FALSE);
280 if (!xdr_bool_t(xdrs, &objp->isdirect))
281 return (FALSE);
282 if (!xdr_u_int(xdrs, (uint_t *)&objp->uid))
283 return (FALSE);
284 return (TRUE);
285 }
286
287 bool_t
288 xdr_mount_result_type(XDR *xdrs, mount_result_type *objp)
289 {
290 if (!xdr_autofs_stat(xdrs, &objp->status))
291 return (FALSE);
292 switch (objp->status) {
293 case AUTOFS_ACTION:
294 if (!xdr_pointer(xdrs,
295 (char **)&objp->mount_result_type_u.list,
296 sizeof (action_list), (xdrproc_t)xdr_action_list))
297 return (FALSE);
298 break;
299 case AUTOFS_DONE:
300 if (!xdr_int(xdrs, &objp->mount_result_type_u.error))
301 return (FALSE);
302 break;
303 }
304 return (TRUE);
305 }
306
307 bool_t
308 xdr_autofs_mountres(XDR *xdrs, autofs_mountres *objp)
309 {
310 if (!xdr_mount_result_type(xdrs, &objp->mr_type))
311 return (FALSE);
312 if (!xdr_int(xdrs, &objp->mr_verbose))
313 return (FALSE);
314 return (TRUE);
315 }
316
317 bool_t
318 xdr_lookup_result_type(XDR *xdrs, lookup_result_type *objp)
319 {
320 if (!xdr_autofs_action(xdrs, &objp->action))
321 return (FALSE);
322 switch (objp->action) {
323 case AUTOFS_LINK_RQ:
324 if (!xdr_linka(xdrs, &objp->lookup_result_type_u.lt_linka))
325 return (FALSE);
326 break;
327 default:
328 break;
329 }
330 return (TRUE);
331 }
332
333 bool_t
334 xdr_autofs_lookupres(XDR *xdrs, autofs_lookupres *objp)
335 {
336 if (!xdr_autofs_res(xdrs, &objp->lu_res))
337 return (FALSE);
338 if (!xdr_lookup_result_type(xdrs, &objp->lu_type))
339 return (FALSE);
340 if (!xdr_int(xdrs, &objp->lu_verbose))
341 return (FALSE);
342 return (TRUE);
343 }
344
345 bool_t
346 xdr_autofs_rddirargs(XDR *xdrs, autofs_rddirargs *objp)
347 {
348 if (!xdr_string(xdrs, &objp->rda_map, AUTOFS_MAXPATHLEN))
349 return (FALSE);
350 if (!xdr_u_int(xdrs, &objp->rda_offset))
351 return (FALSE);
352 if (!xdr_u_int(xdrs, &objp->rda_count))
353 return (FALSE);
354 if (!xdr_u_int(xdrs, (uint_t *)&objp->uid))
355 return (FALSE);
356 return (TRUE);
357 }
358
359 /*
360 * Directory read reply:
361 * union (enum autofs_res) {
362 * AUTOFS_OK: entlist;
363 * boolean eof;
364 * default:
365 * }
366 *
367 * Directory entries
368 * struct direct {
369 * off_t d_off; * offset of next entry *
370 * u_long d_fileno; * inode number of entry *
371 * ushort_t d_reclen; * length of this record *
372 * ushort_t d_namlen; * length of string in d_name *
373 * char d_name[MAXNAMLEN + 1]; * name no longer than this *
374 * };
375 * are on the wire as:
376 * union entlist (boolean valid) {
377 * TRUE: struct otw_dirent;
378 * uint_t nxtoffset;
379 * union entlist;
380 * FALSE:
381 * }
382 * where otw_dirent is:
383 * struct dirent {
384 * uint_t de_fid;
385 * string de_name<AUTOFS_MAXPATHLEN>;
386 * }
387 */
388
389 #ifdef nextdp
390 #undef nextdp
391 #endif
392 #define nextdp(dp) ((struct dirent64 *)((char *)(dp) + (dp)->d_reclen))
393
394 /*
395 * ENCODE ONLY
396 */
397 bool_t
398 xdr_autofs_putrddirres(XDR *xdrs, struct autofsrddir *rddir, uint_t reqsize)
399 {
400 struct dirent64 *dp;
401 char *name;
402 int size;
403 uint_t namlen;
404 bool_t t = TRUE;
405 bool_t f = FALSE;
406 int entrysz;
407 int tofit;
408 int bufsize;
409 uint_t ino, off;
410
411 bufsize = 1 * BYTES_PER_XDR_UNIT;
412 for (size = rddir->rddir_size, dp = rddir->rddir_entries;
413 size > 0;
414 /* LINTED pointer alignment */
415 size -= dp->d_reclen, dp = nextdp(dp)) {
416 if (dp->d_reclen == 0 /* || DIRSIZ(dp) > dp->d_reclen */)
417 return (FALSE);
418 if (dp->d_ino == 0)
419 continue;
420 name = dp->d_name;
421 namlen = (uint_t)strlen(name);
422 ino = (uint_t)dp->d_ino;
423 off = (uint_t)dp->d_off;
424 entrysz = (1 + 1 + 1 + 1) * BYTES_PER_XDR_UNIT +
425 roundup(namlen, BYTES_PER_XDR_UNIT);
426 tofit = entrysz + 2 * BYTES_PER_XDR_UNIT;
427 if (bufsize + tofit > reqsize) {
428 rddir->rddir_eof = FALSE;
429 break;
430 }
431 if (!xdr_bool(xdrs, &t) ||
432 !xdr_u_int(xdrs, &ino) ||
433 !xdr_bytes(xdrs, &name, &namlen, AUTOFS_MAXPATHLEN) ||
434 !xdr_u_int(xdrs, &off)) {
435 return (FALSE);
436 }
437 bufsize += entrysz;
438 }
439 if (!xdr_bool(xdrs, &f))
440 return (FALSE);
441 if (!xdr_bool(xdrs, &rddir->rddir_eof))
442 return (FALSE);
443 return (TRUE);
444 }
445
446
447 /*
448 * DECODE ONLY
449 */
450 bool_t
451 xdr_autofs_getrddirres(XDR *xdrs, struct autofsrddir *rddir)
452 {
453 struct dirent64 *dp;
454 uint_t namlen;
455 int size;
456 bool_t valid;
457 uint_t offset;
458 uint_t fileid;
459
460 offset = (uint_t)-1;
461
462 size = rddir->rddir_size;
463 dp = rddir->rddir_entries;
464 for (;;) {
465 if (!xdr_bool(xdrs, &valid))
466 return (FALSE);
467 if (!valid)
468 break;
469 if (!xdr_u_int(xdrs, &fileid) ||
470 !xdr_u_int(xdrs, &namlen))
471 return (FALSE);
472 if (DIRENT64_RECLEN(namlen) > size) {
473 rddir->rddir_eof = FALSE;
474 goto bufovflw;
475 }
476 if (!xdr_opaque(xdrs, dp->d_name, namlen)||
477 !xdr_u_int(xdrs, &offset))
478 return (FALSE);
479 dp->d_ino = fileid;
480 dp->d_reclen = (ushort_t)DIRENT64_RECLEN(namlen);
481 bzero(&dp->d_name[namlen],
482 DIRENT64_NAMELEN(dp->d_reclen) - namlen);
483 dp->d_off = offset;
484 size -= dp->d_reclen;
485 /* LINTED pointer alignment */
486 dp = nextdp(dp);
487 }
488 if (!xdr_bool(xdrs, &rddir->rddir_eof))
489 return (FALSE);
490 bufovflw:
491 rddir->rddir_size = (uint_t)((char *)dp - (char *)rddir->rddir_entries);
492 rddir->rddir_offset = offset;
493 return (TRUE);
494 }
495
496 bool_t
497 xdr_autofs_rddirres(XDR *xdrs, autofs_rddirres *objp)
498 {
499 if (!xdr_enum(xdrs, (enum_t *)&objp->rd_status))
500 return (FALSE);
501 if (objp->rd_status != AUTOFS_OK)
502 return (TRUE);
503 if (xdrs->x_op == XDR_ENCODE)
504 return (xdr_autofs_putrddirres(xdrs,
505 (struct autofsrddir *)&objp->rd_rddir, objp->rd_bufsize));
506 else if (xdrs->x_op == XDR_DECODE)
507 return (xdr_autofs_getrddirres(xdrs,
508 (struct autofsrddir *)&objp->rd_rddir));
509 return (FALSE);
510 }
Unleashed OS