Mercurial > illumos > onarm

comparison usr/src/cmd/fs.d/autofs/autod_xdr.c @ 0:c9caec207d52 b86

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial porting based on b86
author Koji Uno <koji.uno@sun.com>
date Tue, 02 Jun 2009 18:56:50 +0900
parents
children 1a15d5aaf794
comparison
equal deleted inserted replaced
-1:000000000000 0:c9caec207d52
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 * autod_xdr.c
23 *
24 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
25 * Use is subject to license terms.
26 */
27
28 #pragma ident "@(#)autod_xdr.c 1.41 07/08/27 SMI"
29
30 /*
31 * This file can not be automatically generated by rpcgen from
32 * autofs_prot.x because of the xdr routines that provide readdir
33 * support, and my own implementation of xdr_autofs_netbuf().
34 */
35
36 #include <sys/vfs.h>
37 #include <sys/sysmacros.h> /* includes roundup() */
38 #include <string.h>
39 #include <rpcsvc/autofs_prot.h>
40 #include <rpc/xdr.h>
41 #include <stdlib.h>
42 #include <strings.h>
43
44 bool_t
45 xdr_autofs_stat(register XDR *xdrs, autofs_stat *objp)
46 {
47 if (!xdr_enum(xdrs, (enum_t *)objp))
48 return (FALSE);
49 return (TRUE);
50 }
51
52 bool_t
53 xdr_autofs_action(register XDR *xdrs, autofs_action *objp)
54 {
55 if (!xdr_enum(xdrs, (enum_t *)objp))
56 return (FALSE);
57 return (TRUE);
58 }
59
60 bool_t
61 xdr_linka(register XDR *xdrs, linka *objp)
62 {
63 if (!xdr_string(xdrs, &objp->dir, AUTOFS_MAXPATHLEN))
64 return (FALSE);
65 if (!xdr_string(xdrs, &objp->link, AUTOFS_MAXPATHLEN))
66 return (FALSE);
67 return (TRUE);
68 }
69
70 bool_t
71 xdr_autofs_netbuf(xdrs, objp)
72 XDR *xdrs;
73 struct netbuf *objp;
74 {
75 bool_t dummy;
76
77 if (!xdr_u_int(xdrs, &objp->maxlen)) {
78 return (FALSE);
79 }
80 dummy = xdr_bytes(xdrs, (char **)&(objp->buf),
81 (uint_t *)&(objp->len), objp->maxlen);
82 return (dummy);
83 }
84
85 bool_t
86 xdr_autofs_args(register XDR *xdrs, autofs_args *objp)
87 {
88 if (!xdr_autofs_netbuf(xdrs, &objp->addr))
89 return (FALSE);
90 if (!xdr_string(xdrs, &objp->path, AUTOFS_MAXPATHLEN))
91 return (FALSE);
92 if (!xdr_string(xdrs, &objp->opts, AUTOFS_MAXOPTSLEN))
93 return (FALSE);
94 if (!xdr_string(xdrs, &objp->map, AUTOFS_MAXPATHLEN))
95 return (FALSE);
96 if (!xdr_string(xdrs, &objp->subdir, AUTOFS_MAXPATHLEN))
97 return (FALSE);
98 if (!xdr_string(xdrs, &objp->key, AUTOFS_MAXCOMPONENTLEN))
99 return (FALSE);
100 if (!xdr_int(xdrs, &objp->mount_to))
101 return (FALSE);
102 if (!xdr_int(xdrs, &objp->rpc_to))
103 return (FALSE);
104 if (!xdr_int(xdrs, &objp->direct))
105 return (FALSE);
106 return (TRUE);
107 }
108
109 bool_t
110 xdr_mounta(register XDR *xdrs, struct mounta *objp)
111 {
112 if (!xdr_string(xdrs, &objp->spec, AUTOFS_MAXPATHLEN))
113 return (FALSE);
114 if (!xdr_string(xdrs, &objp->dir, AUTOFS_MAXPATHLEN))
115 return (FALSE);
116 if (!xdr_int(xdrs, &objp->flags))
117 return (FALSE);
118 if (!xdr_string(xdrs, &objp->fstype, AUTOFS_MAXCOMPONENTLEN))
119 return (FALSE);
120 if (!xdr_pointer(xdrs, (char **)&objp->dataptr, sizeof (autofs_args),
121 (xdrproc_t)xdr_autofs_args))
122 return (FALSE);
123 if (!xdr_int(xdrs, &objp->datalen))
124 return (FALSE);
125 if (!xdr_string(xdrs, &objp->optptr, AUTOFS_MAXOPTSLEN))
126 return (FALSE);
127 if (!xdr_int(xdrs, &objp->optlen))
128 return (FALSE);
129 return (TRUE);
130 }
131
132 bool_t
133 xdr_action_list_entry(register XDR *xdrs, action_list_entry *objp)
134 {
135 if (!xdr_autofs_action(xdrs, &objp->action))
136 return (FALSE);
137 switch (objp->action) {
138 case AUTOFS_MOUNT_RQ:
139 if (!xdr_mounta(xdrs, &objp->action_list_entry_u.mounta))
140 return (FALSE);
141 break;
142 case AUTOFS_LINK_RQ:
143 if (!xdr_linka(xdrs, &objp->action_list_entry_u.linka))
144 return (FALSE);
145 break;
146 }
147 return (TRUE);
148 }
149
150 bool_t
151 xdr_action_list(XDR *xdrs, action_list *objp)
152 {
153 action_list *tmp_action_list;
154 bool_t more_data = TRUE;
155 bool_t first_objp = TRUE;
156
157 if (xdrs->x_op == XDR_DECODE) {
158 while (more_data) {
159 if (!xdr_action_list_entry(xdrs, &objp->action))
160 return (FALSE);
161 if (!xdr_bool(xdrs, &more_data))
162 return (FALSE);
163 if (!more_data) {
164 objp->next = NULL;
165 break;
166 }
167 if (objp->next == NULL) {
168 objp->next = (action_list *)
169 mem_alloc(sizeof (action_list));
170 if (objp->next == NULL)
171 return (FALSE);
172 bzero(objp->next, sizeof (action_list));
173 }
174 objp = objp->next;
175 }
176 } else if (xdrs->x_op == XDR_ENCODE) {
177 while (more_data) {
178 if (!xdr_action_list_entry(xdrs, &objp->action))
179 return (FALSE);
180 objp = objp->next;
181 if (objp == NULL)
182 more_data = FALSE;
183 if (!xdr_bool(xdrs, &more_data))
184 return (FALSE);
185 }
186 } else {
187 while (more_data) {
188 if (!xdr_action_list_entry(xdrs, &objp->action))
189 return (FALSE);
190 tmp_action_list = objp;
191 objp = objp->next;
192 if (objp == NULL)
193 more_data = FALSE;
194 if (!first_objp)
195 mem_free(tmp_action_list, sizeof (action_list));
196 else
197 first_objp = FALSE;
198 }
199 }
200 return (TRUE);
201 }
202
203 bool_t
204 xdr_umntrequest(register XDR *xdrs, umntrequest *objp)
205 {
206 if (!xdr_bool_t(xdrs, &objp->isdirect))
207 return (FALSE);
208 if (!xdr_string(xdrs, &objp->mntresource, AUTOFS_MAXPATHLEN))
209 return (FALSE);
210 if (!xdr_string(xdrs, &objp->mntpnt, AUTOFS_MAXPATHLEN))
211 return (FALSE);
212 if (!xdr_string(xdrs, &objp->fstype, AUTOFS_MAXCOMPONENTLEN))
213 return (FALSE);
214 if (!xdr_string(xdrs, &objp->mntopts, AUTOFS_MAXOPTSLEN))
215 return (FALSE);
216 if (!xdr_pointer(xdrs, (char **)&objp->next, sizeof (umntrequest),
217 (xdrproc_t)xdr_umntrequest))
218 return (FALSE);
219 return (TRUE);
220 }
221
222 bool_t
223 xdr_umntres(register XDR *xdrs, umntres *objp)
224 {
225 if (!xdr_int(xdrs, &objp->status))
226 return (FALSE);
227 return (TRUE);
228 }
229
230 bool_t
231 xdr_autofs_res(xdrs, objp)
232 register XDR *xdrs;
233 autofs_res *objp;
234 {
235 if (!xdr_enum(xdrs, (enum_t *)objp))
236 return (FALSE);
237 return (TRUE);
238 }
239
240 bool_t
241 xdr_autofs_lookupargs(xdrs, objp)
242 register XDR *xdrs;
243 autofs_lookupargs *objp;
244 {
245 if (!xdr_string(xdrs, &objp->map, AUTOFS_MAXPATHLEN))
246 return (FALSE);
247 if (!xdr_string(xdrs, &objp->path, AUTOFS_MAXPATHLEN))
248 return (FALSE);
249 if (!xdr_string(xdrs, &objp->name, AUTOFS_MAXCOMPONENTLEN))
250 return (FALSE);
251 if (!xdr_string(xdrs, &objp->subdir, AUTOFS_MAXPATHLEN))
252 return (FALSE);
253 if (!xdr_string(xdrs, &objp->opts, AUTOFS_MAXOPTSLEN))
254 return (FALSE);
255 if (!xdr_bool_t(xdrs, &objp->isdirect))
256 return (FALSE);
257 if (!xdr_u_int(xdrs, (uint_t *)&objp->uid))
258 return (FALSE);
259 return (TRUE);
260 }
261
262 bool_t
263 xdr_mount_result_type(xdrs, objp)
264 register XDR *xdrs;
265 mount_result_type *objp;
266 {
267 if (!xdr_autofs_stat(xdrs, &objp->status))
268 return (FALSE);
269 switch (objp->status) {
270 case AUTOFS_ACTION:
271 if (!xdr_pointer(xdrs,
272 (char **)&objp->mount_result_type_u.list,
273 sizeof (action_list), (xdrproc_t)xdr_action_list))
274 return (FALSE);
275 break;
276 case AUTOFS_DONE:
277 if (!xdr_int(xdrs, &objp->mount_result_type_u.error))
278 return (FALSE);
279 break;
280 }
281 return (TRUE);
282 }
283
284 bool_t
285 xdr_autofs_mountres(xdrs, objp)
286 register XDR *xdrs;
287 autofs_mountres *objp;
288 {
289 if (!xdr_mount_result_type(xdrs, &objp->mr_type))
290 return (FALSE);
291 if (!xdr_int(xdrs, &objp->mr_verbose))
292 return (FALSE);
293 return (TRUE);
294 }
295 bool_t
296 xdr_lookup_result_type(xdrs, objp)
297 register XDR *xdrs;
298 lookup_result_type *objp;
299 {
300 if (!xdr_autofs_action(xdrs, &objp->action))
301 return (FALSE);
302 switch (objp->action) {
303 case AUTOFS_LINK_RQ:
304 if (!xdr_linka(xdrs, &objp->lookup_result_type_u.lt_linka))
305 return (FALSE);
306 break;
307 }
308 return (TRUE);
309 }
310
311 bool_t
312 xdr_autofs_lookupres(xdrs, objp)
313 register XDR *xdrs;
314 autofs_lookupres *objp;
315 {
316 if (!xdr_autofs_res(xdrs, &objp->lu_res))
317 return (FALSE);
318 if (!xdr_lookup_result_type(xdrs, &objp->lu_type))
319 return (FALSE);
320 if (!xdr_int(xdrs, &objp->lu_verbose))
321 return (FALSE);
322 return (TRUE);
323 }
324
325 /*
326 * ******************************************************
327 * Readdir XDR support
328 * ******************************************************
329 */
330
331 bool_t
332 xdr_autofs_rddirargs(xdrs, objp)
333 register XDR *xdrs;
334 autofs_rddirargs *objp;
335 {
336 if (!xdr_string(xdrs, &objp->rda_map, AUTOFS_MAXPATHLEN))
337 return (FALSE);
338 if (!xdr_u_int(xdrs, &objp->rda_offset))
339 return (FALSE);
340 if (!xdr_u_int(xdrs, &objp->rda_count))
341 return (FALSE);
342 if (!xdr_u_int(xdrs, (uint_t *)&objp->uid))
343 return (FALSE);
344 return (TRUE);
345 }
346
347 /*
348 * Directory read reply:
349 * union (enum autofs_res) {
350 * AUTOFS_OK: entlist;
351 * boolean eof;
352 * default:
353 * }
354 *
355 * Directory entries
356 * struct direct {
357 * off_t d_off; * offset of next entry *
358 * u_long d_fileno; * inode number of entry *
359 * u_short d_reclen; * length of this record *
360 * u_short d_namlen; * length of string in d_name *
361 * char d_name[MAXNAMLEN + 1]; * name no longer than this *
362 * };
363 * are on the wire as:
364 * union entlist (boolean valid) {
365 * TRUE: struct otw_dirent;
366 * u_long nxtoffset;
367 * union entlist;
368 * FALSE:
369 * }
370 * where otw_dirent is:
371 * struct dirent {
372 * u_long de_fid;
373 * string de_name<AUTOFS_MAXPATHLEN>;
374 * }
375 */
376
377 #ifdef nextdp
378 #undef nextdp
379 #endif
380 #define nextdp(dp) ((struct dirent64 *)((char *)(dp) + (dp)->d_reclen))
381
382 /*
383 * ENCODE ONLY
384 */
385 bool_t
386 xdr_autofs_putrddirres(xdrs, rddir, reqsize)
387 XDR *xdrs;
388 struct autofsrddir *rddir;
389 uint_t reqsize; /* requested size */
390 {
391 struct dirent64 *dp;
392 char *name;
393 int size;
394 uint_t namlen;
395 bool_t true = TRUE;
396 bool_t false = FALSE;
397 int entrysz;
398 int tofit;
399 int bufsize;
400 uint_t ino, off;
401
402 bufsize = 1 * BYTES_PER_XDR_UNIT;
403 for (size = rddir->rddir_size, dp = rddir->rddir_entries;
404 size > 0;
405 /* LINTED pointer alignment */
406 size -= dp->d_reclen, dp = nextdp(dp)) {
407 if (dp->d_reclen == 0 /* || DIRSIZ(dp) > dp->d_reclen */) {
408 return (FALSE);
409 }
410 if (dp->d_ino == 0) {
411 continue;
412 }
413 name = dp->d_name;
414 namlen = strlen(name);
415 ino = (uint_t)dp->d_ino;
416 off = (uint_t)dp->d_off;
417 entrysz = (1 + 1 + 1 + 1) * BYTES_PER_XDR_UNIT +
418 roundup(namlen, BYTES_PER_XDR_UNIT);
419 tofit = entrysz + 2 * BYTES_PER_XDR_UNIT;
420 if (bufsize + tofit > reqsize) {
421 rddir->rddir_eof = FALSE;
422 break;
423 }
424 if (!xdr_bool(xdrs, &true) ||
425 !xdr_u_int(xdrs, &ino) ||
426 !xdr_bytes(xdrs, &name, &namlen, AUTOFS_MAXPATHLEN) ||
427 !xdr_u_int(xdrs, &off)) {
428 return (FALSE);
429 }
430 bufsize += entrysz;
431 }
432 if (!xdr_bool(xdrs, &false)) {
433 return (FALSE);
434 }
435 if (!xdr_bool(xdrs, &rddir->rddir_eof)) {
436 return (FALSE);
437 }
438 return (TRUE);
439 }
440
441 #define DIRENT64_RECLEN(namelen) \
442 (((int)(((dirent64_t *)0)->d_name) + 1 + (namelen) + 7) & ~ 7)
443 #define reclen(namlen) DIRENT64_RECLEN((namlen))
444
445 /*
446 * DECODE ONLY
447 */
448 bool_t
449 xdr_autofs_getrddirres(xdrs, rddir)
450 XDR *xdrs;
451 struct autofsrddir *rddir;
452 {
453 struct dirent64 *dp;
454 uint_t namlen;
455 int size;
456 bool_t valid;
457 int offset = -1;
458 uint_t fileid;
459
460 size = rddir->rddir_size;
461 dp = rddir->rddir_entries;
462 for (;;) {
463 if (!xdr_bool(xdrs, &valid)) {
464 return (FALSE);
465 }
466 if (!valid) {
467 break;
468 }
469 if (!xdr_u_int(xdrs, &fileid) ||
470 !xdr_u_int(xdrs, &namlen)) {
471 return (FALSE);
472 }
473 if (reclen(namlen) > size) {
474 rddir->rddir_eof = FALSE;
475 goto bufovflw;
476 }
477 if (!xdr_opaque(xdrs, dp->d_name, namlen)||
478 !xdr_int(xdrs, &offset)) {
479 return (FALSE);
480 }
481 dp->d_ino = fileid;
482 dp->d_reclen = reclen(namlen);
483 dp->d_name[namlen] = '\0';
484 dp->d_off = offset;
485 size -= dp->d_reclen;
486 /* LINTED pointer alignment */
487 dp = nextdp(dp);
488 }
489 if (!xdr_bool(xdrs, &rddir->rddir_eof)) {
490 return (FALSE);
491 }
492 bufovflw:
493 rddir->rddir_size = (char *)dp - (char *)(rddir->rddir_entries);
494 rddir->rddir_offset = offset;
495 return (TRUE);
496 }
497
498 bool_t
499 xdr_autofs_rddirres(register XDR *xdrs, autofs_rddirres *objp)
500 {
501 if (!xdr_enum(xdrs, (enum_t *)&objp->rd_status))
502 return (FALSE);
503 if (objp->rd_status != AUTOFS_OK)
504 return (TRUE);
505 if (xdrs->x_op == XDR_ENCODE)
506 return (xdr_autofs_putrddirres(
507 xdrs, (struct autofsrddir *)&objp->rd_rddir,
508 objp->rd_bufsize));
509 else if (xdrs->x_op == XDR_DECODE)
510 return (xdr_autofs_getrddirres(xdrs,
511 (struct autofsrddir *)&objp->rd_rddir));
512 else return (FALSE);
513 }