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_parse.c
23  *
24  *	Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
25  *	Use is subject to license terms.
26  *      Copyright 2015 Nexenta Systems, Inc. All rights reserved.
27  */
28 
29 #include <stdio.h>
30 #include <ctype.h>
31 #include <string.h>
32 #include <syslog.h>
33 #include <sys/types.h>
34 #include <sys/stat.h>
35 #include <sys/param.h>
36 #include <errno.h>
37 #include <pwd.h>
38 #include <netinet/in.h>
39 #include <netdb.h>
40 #include <sys/tiuser.h>
41 #include <locale.h>
42 #include <stdlib.h>
43 #include <unistd.h>
44 #include <thread.h>
45 #include <rpc/rpc.h>
46 #include <rpcsvc/mount.h>
47 #include <fcntl.h>
48 #include <limits.h>
49 #include "automount.h"
50 
51 /*
52  * This structure is used to determine the hierarchical
53  * relationship between directories
54  */
55 typedef struct _hiernode {
56 	char dirname[MAXFILENAMELEN+1];
57 	struct _hiernode *subdir;
58 	struct _hiernode *leveldir;
59 	struct mapent *mapent;
60 } hiernode;
61 
62 void free_mapent(struct mapent *);
63 
64 static int mapline_to_mapent(struct mapent **, struct mapline *, char *, char *,
65 				char *, char *, uint_t);
66 static int hierarchical_sort(struct mapent *, hiernode **, char *, char *);
67 static int push_options(hiernode *, char *, char *, int);
68 static int set_mapent_opts(struct mapent *, char *, char *, char *);
69 static void get_opts(char *, char *, char *, bool_t *);
70 static int fstype_opts(struct mapent *, char *, char *, char *);
71 static int modify_mapents(struct mapent **, char *, char *, char *, hiernode *,
72 			char *, uint_t, bool_t);
73 static int set_and_fake_mapent_mntlevel(hiernode *, char *, char *, char *,
74 				struct mapent **, uint_t, char *, bool_t);
75 static int mark_level1_root(hiernode *, char *);
76 static int mark_and_fake_level1_noroot(hiernode *, char *, char *, char *,
77 				    struct mapent **, uint_t i, char *);
78 static int convert_mapent_to_automount(struct mapent *, char *, char *);
79 static int automount_opts(char **, char *);
80 static int parse_fsinfo(char *, struct mapent *);
81 static int parse_nfs(char *, struct mapent *, char *, char *, char **, char **,
82 				int);
83 static int parse_special(struct mapent *, char *, char *, char **, char **,
84 				int);
85 static int get_dir_from_path(char *, char **, int);
86 static int alloc_hiernode(hiernode **, char *);
87 static void free_hiernode(hiernode *);
88 static void trace_mapents(char *, struct mapent *);
89 static void trace_hierarchy(hiernode *, int);
90 static struct mapent *do_mapent_hosts(char *, char *, uint_t);
91 static void freeex_ent(struct exportnode *);
92 static void freeex(struct exportnode *);
93 static void dump_mapent_err(struct mapent *, char *, char *);
94 
95 #define	PARSE_OK	0
96 #define	PARSE_ERROR	-1
97 #define	MAX_FSLEN	32
98 
99 /*
100  * mapentry error type defininitions
101  */
102 #define	MAPENT_NOERR	0
103 #define	MAPENT_UATFS	1
104 
105 /*
106  * parse_entry(char *key, char *mapname, char *mapopts, struct mapline *ml,
107  *			char *subdir, uint_t isdirect, bool_t mount_access)
108  * Parses the data in ml to build a mapentry list containing the information
109  * for the mounts/lookups to be performed. Builds an intermediate mapentry list
110  * by processing ml, hierarchically sorts (builds a tree of) the list according
111  * to mountpoint. Then pushes options down the hierarchy, and fills in the mount
112  * file system. Finally, modifies the intermediate list depending on how far
113  * in the hierarchy the current request is (uses subdir). Deals with special
114  * case of /net map parsing.
115  * Returns a pointer to the head of the mapentry list.
116  */
117 struct mapent *
parse_entry(char * key,char * mapname,char * mapopts,struct mapline * ml,char * subdir,uint_t isdirect,bool_t mount_access)118 parse_entry(char *key, char *mapname, char *mapopts, struct mapline *ml,
119 			char *subdir, uint_t isdirect, bool_t mount_access)
120 {
121 	char *p;
122 	char defaultopts[AUTOFS_MAXOPTSLEN];
123 
124 	struct mapent *mapents = NULL;
125 	hiernode *rootnode = NULL;
126 	char *lp = ml->linebuf;
127 
128 	if (trace > 1)
129 		trace_prt(1, "  mapline: %s\n", ml->linebuf);
130 
131 	/*
132 	 * Assure the key is only one token long.
133 	 * This prevents options from sneaking in through the
134 	 * command line or corruption of /etc/mnttab.
135 	 */
136 	for (p = key; *p != '\0'; p++) {
137 		if (isspace(*p)) {
138 			syslog(LOG_ERR,
139 			"parse_entry: bad key in map %s: %s", mapname, key);
140 			return ((struct mapent *)NULL);
141 		}
142 	}
143 
144 	/*
145 	 * select the appropriate parser, and build the mapentry list
146 	 */
147 	if (strcmp(lp, "-hosts") == 0) {
148 		/*
149 		 * the /net parser - uses do_mapent_hosts to build mapents.
150 		 * The mapopts are considered default for every entry, so we
151 		 * don't push options down hierarchies.
152 		 */
153 		mapents = do_mapent_hosts(mapopts, key, isdirect);
154 		if (mapents == NULL)		/* nothing to free */
155 			return (mapents);
156 
157 		if (trace > 3)
158 			trace_mapents("do_mapent_hosts:(return)", mapents);
159 
160 		if (hierarchical_sort(mapents, &rootnode, key, mapname)
161 		    != PARSE_OK)
162 			goto parse_error;
163 	} else {
164 		/*
165 		 * all other parsing
166 		 */
167 		if (mapline_to_mapent(&mapents, ml, key, mapname,
168 		    mapopts, defaultopts, isdirect) != PARSE_OK)
169 			goto parse_error;
170 
171 		if (mapents == NULL)
172 			return (mapents);
173 
174 		if (hierarchical_sort(mapents, &rootnode, key, mapname)
175 		    != PARSE_OK)
176 			goto parse_error;
177 
178 		if (push_options(rootnode, defaultopts, mapopts,
179 		    MAPENT_NOERR) != PARSE_OK)
180 			goto parse_error;
181 
182 		if (trace > 3) {
183 			trace_prt(1, "\n\tpush_options (return)\n");
184 			trace_prt(0, "\tdefault options=%s\n", defaultopts);
185 			trace_hierarchy(rootnode, 0);
186 		};
187 
188 		if (parse_fsinfo(mapname, mapents) != PARSE_OK)
189 			goto parse_error;
190 	}
191 
192 	/*
193 	 * Modify the mapentry list. We *must* do this only after
194 	 * the mapentry list is completely built (since we need to
195 	 * have parse_fsinfo called first).
196 	 */
197 	if (modify_mapents(&mapents, mapname, mapopts, subdir,
198 	    rootnode, key, isdirect, mount_access) != PARSE_OK)
199 		goto parse_error;
200 
201 	/*
202 	 * XXX: its dangerous to use rootnode after modify mapents as
203 	 * it may be pointing to mapents that have been freed
204 	 */
205 	if (rootnode != NULL)
206 		free_hiernode(rootnode);
207 
208 	return (mapents);
209 
210 parse_error:
211 	syslog(LOG_ERR, "parse_entry: mapentry parse error: map=%s key=%s",
212 	    mapname, key);
213 	free_mapent(mapents);
214 	if (rootnode != NULL)
215 		free_hiernode(rootnode);
216 	return ((struct mapent *)NULL);
217 }
218 
219 
220 /*
221  * mapline_to_mapent(struct mapent **mapents, struct mapline *ml,
222  *		char *key, char *mapname, char *mapopts, char *defaultopts,
223  *              uint_t isdirect)
224  * Parses the mapline information in ml word by word to build an intermediate
225  * mapentry list, which is passed back to the caller. The mapentries may have
226  * holes (example no options), as they are completed only later. The logic is
227  * awkward, but needed to provide the supported flexibility in the map entries.
228  * (especially the first line). Note that the key is the full pathname of the
229  * directory to be mounted in a direct map, and ml is the mapentry beyond key.
230  * Returns PARSE_OK or an appropriate error value.
231  */
232 static int
mapline_to_mapent(struct mapent ** mapents,struct mapline * ml,char * key,char * mapname,char * mapopts,char * defaultopts,uint_t isdirect)233 mapline_to_mapent(struct mapent **mapents, struct mapline *ml, char *key,
234 		char *mapname, char *mapopts, char *defaultopts,
235 		uint_t isdirect)
236 {
237 	struct mapent *me = NULL;
238 	struct mapent *mp;
239 	char w[MAXPATHLEN];
240 	char wq[MAXPATHLEN];
241 	char w1[MAXPATHLEN];
242 	int implied;
243 
244 	char *lp = ml->linebuf;
245 	char *lq = ml->lineqbuf;
246 
247 	/* do any macro expansions that are required to complete ml */
248 	if (macro_expand(key, lp, lq, LINESZ)) {
249 		syslog(LOG_ERR,
250 		"mapline_to_mapent: map %s: line too long (max %d chars)",
251 		    mapname, LINESZ - 1);
252 		return (PARSE_ERROR);
253 	}
254 	if (trace > 3 && (strcmp(ml->linebuf, lp) != 0))
255 		trace_prt(1,
256 		    "  mapline_to_mapent: (expanded) mapline (%s,%s)\n",
257 		    ml->linebuf, ml->lineqbuf);
258 
259 	/* init the head of mapentry list to null */
260 	*mapents = NULL;
261 
262 	/*
263 	 * Get the first word - its either a '-' if default options provided,
264 	 * a '/', if the mountroot is implicitly provided, or a mount filesystem
265 	 * if the mountroot is implicit. Note that if the first word begins with
266 	 * a '-' then the second must be read and it must be a mountpoint or a
267 	 * mount filesystem. Use mapopts if no default opts are provided.
268 	 */
269 	if (getword(w, wq, &lp, &lq, ' ', sizeof (w)) == -1)
270 		return (PARSE_ERROR);
271 	if (*w == '-') {
272 		strcpy(defaultopts, w);
273 		if (getword(w, wq, &lp, &lq, ' ', sizeof (w)) == -1)
274 			return (PARSE_ERROR);
275 	} else
276 		strcpy(defaultopts, mapopts);
277 
278 	/*
279 	 * implied is true if there is no '/'
280 	 * We need the same code path if we have an smbfs mount.
281 	 */
282 	implied = (*w != '/') || (strstr(defaultopts, "fstype=smbfs") != NULL);
283 	while (*w == '/' || implied) {
284 		mp = me;
285 		if ((me = (struct mapent *)malloc(sizeof (*me))) == NULL)
286 			goto alloc_failed;
287 		(void) memset((char *)me, 0, sizeof (*me));
288 		if (*mapents == NULL)	/* special case of head */
289 			*mapents = me;
290 		else
291 			mp->map_next = me;
292 
293 		/*
294 		 * direct maps get an empty string as root - to be filled
295 		 * by the entire path later. Indirect maps get /key as the
296 		 * map root. Note that xfn maps don't care about the root
297 		 * - they override it in getmapent_fn().
298 		 */
299 		if (isdirect) {
300 			*w1 = '\0';
301 		} else {
302 			strcpy(w1, "/");
303 			strcat(w1, key);
304 		}
305 		if ((me->map_root = strdup(w1)) == NULL)
306 			goto alloc_failed;
307 
308 		/* mntpnt is empty for the mount root */
309 		if (strcmp(w, "/") == 0 || implied)
310 			me->map_mntpnt = strdup("");
311 		else
312 			me->map_mntpnt = strdup(w);
313 		if (me->map_mntpnt == NULL)
314 			goto alloc_failed;
315 
316 		/*
317 		 * If implied, the word must be a mount filesystem,
318 		 * and its already read in; also turn off implied - its
319 		 * not applicable except for the mount root. Else,
320 		 * read another (or two) words depending on if there's
321 		 * an option.
322 		 */
323 		if (implied)   /* must be a mount filesystem */
324 			implied = 0;
325 		else {
326 			if (getword(w, wq, &lp, &lq, ' ', sizeof (w)) == -1)
327 				return (PARSE_ERROR);
328 			if (w[0] == '-') {
329 				/* mount options */
330 				if ((me->map_mntopts = strdup(w)) == NULL)
331 					goto alloc_failed;
332 				if (getword(w, wq, &lp, &lq, ' ',
333 				    sizeof (w)) == -1)
334 					return (PARSE_ERROR);
335 			}
336 		}
337 
338 		/*
339 		 * must be a mount filesystem or a set of filesystems at
340 		 * this point.
341 		 */
342 		if (w[0] == '\0' || w[0] == '-') {
343 			syslog(LOG_ERR,
344 			"mapline_to_mapent: bad location=%s map=%s key=%s",
345 			    w, mapname, key);
346 			return (PARSE_ERROR);
347 		}
348 
349 		/*
350 		 * map_fsw and map_fswq hold information which will be
351 		 * used to determine filesystem information at a later
352 		 * point. This is required since we can only find out
353 		 * about the mount file system after the directories
354 		 * are hierarchically sorted and options have been pushed
355 		 * down the hierarchies.
356 		 */
357 		if (((me->map_fsw = strdup(w)) == NULL) ||
358 		    ((me->map_fswq = strdup(wq)) == NULL))
359 			goto alloc_failed;
360 
361 		/*
362 		 * the next word, if any, is either another mount point or a
363 		 * mount filesystem if more than one server is listed.
364 		 */
365 		if (getword(w, wq, &lp, &lq, ' ', sizeof (w)) == -1)
366 			return (PARSE_ERROR);
367 		while (*w && *w != '/') {	/* more than 1 server listed */
368 			int len;
369 			char *fsw, *fswq;
370 			len = strlen(me->map_fsw) + strlen(w) + 4;
371 			if ((fsw = (char *)malloc(len)) == NULL)
372 				goto alloc_failed;
373 			sprintf(fsw, "%s   %s", me->map_fsw, w);
374 			free(me->map_fsw);
375 			me->map_fsw = fsw;
376 			len = strlen(me->map_fswq) + strlen(wq) + 4;
377 			if ((fswq = (char *)malloc(len)) == NULL)
378 				goto alloc_failed;
379 			sprintf(fswq, "%s   %s", me->map_fswq, wq);
380 			free(me->map_fswq);
381 			me->map_fswq = fswq;
382 			if (getword(w, wq, &lp, &lq, ' ', sizeof (w)) == -1)
383 				return (PARSE_ERROR);
384 		}
385 
386 		/* initialize flags */
387 		me->map_mntlevel = -1;
388 		me->map_modified = FALSE;
389 		me->map_faked = FALSE;
390 		me->map_err = MAPENT_NOERR;
391 
392 		me->map_next = NULL;
393 	}
394 
395 	if (*mapents == NULL || w[0] != '\0') {	/* sanity check */
396 		if (verbose) {
397 			if (*mapents == NULL)
398 				syslog(LOG_ERR,
399 				"mapline_to_mapent: parsed with null mapents");
400 			else
401 				syslog(LOG_ERR,
402 				"mapline_to_mapent: parsed nononempty w=%s", w);
403 		}
404 		return (PARSE_ERROR);
405 	}
406 
407 	if (trace > 3)
408 		trace_mapents("mapline_to_mapent:", *mapents);
409 
410 	return (PARSE_OK);
411 
412 alloc_failed:
413 	syslog(LOG_ERR, "mapline_to_mapent: Memory allocation failed");
414 	return (ENOMEM);
415 }
416 
417 /*
418  * hierarchical_sort(struct mapent *mapents, hiernode **rootnode, char *key
419  *                   char *mapname)
420  * sorts the mntpnts in each mapent to build a hierarchy of nodes, with
421  * with the rootnode being the mount root. The hierarchy is setup as
422  * levels, and subdirs below each level. Provides a link from node to
423  * the relevant mapentry.
424  * Returns PARSE_OK or appropriate error value
425  */
426 static int
hierarchical_sort(struct mapent * mapents,hiernode ** rootnode,char * key,char * mapname)427 hierarchical_sort(struct mapent *mapents, hiernode **rootnode, char *key,
428 	char *mapname)
429 {
430 	hiernode *prevnode, *currnode, *newnode;
431 	char *path;
432 	char dirname[MAXFILENAMELEN];
433 
434 	int rc = PARSE_OK;
435 	struct mapent *me = mapents;
436 
437 	/* allocate the rootnode with a default path of "" */
438 	*rootnode = NULL;
439 	if ((rc = alloc_hiernode(rootnode, "")) != PARSE_OK)
440 		return (rc);
441 
442 	/*
443 	 * walk through mapents - for each mapent, locate the position
444 	 * within the hierarchy by walking across leveldirs, and
445 	 * subdirs of matched leveldirs. Starts one level below
446 	 * the root (assumes an implicit match with rootnode).
447 	 * XXX - this could probably be done more cleanly using recursion.
448 	 */
449 	while (me != NULL) {
450 
451 		path = me->map_mntpnt;
452 
453 		if ((rc = get_dir_from_path(dirname, &path,
454 		    sizeof (dirname))) != PARSE_OK)
455 			return (rc);
456 
457 		prevnode = *rootnode;
458 		currnode = (*rootnode)->subdir;
459 
460 		while (dirname[0] != '\0') {
461 			if (currnode != NULL) {
462 				if (strcmp(currnode->dirname, dirname) == 0) {
463 					/*
464 					 * match found - mntpnt is a child of
465 					 * this node
466 					 */
467 					prevnode = currnode;
468 					currnode = currnode->subdir;
469 				} else {
470 					prevnode = currnode;
471 					currnode = currnode->leveldir;
472 
473 					if (currnode == NULL) {
474 						/*
475 						 * No more leveldirs to match.
476 						 * Add a new one
477 						 */
478 						if ((rc = alloc_hiernode
479 						    (&newnode, dirname))
480 						    != PARSE_OK)
481 							return (rc);
482 						prevnode->leveldir = newnode;
483 						prevnode = newnode;
484 						currnode = newnode->subdir;
485 					} else {
486 						/* try this leveldir */
487 						continue;
488 					}
489 				}
490 			} else {
491 				/* no more subdirs to match. Add a new one */
492 				if ((rc = alloc_hiernode(&newnode,
493 				    dirname)) != PARSE_OK)
494 					return (rc);
495 				prevnode->subdir = newnode;
496 				prevnode = newnode;
497 				currnode = newnode->subdir;
498 			}
499 			if ((rc = get_dir_from_path(dirname, &path,
500 			    sizeof (dirname))) != PARSE_OK)
501 				return (rc);
502 		}
503 
504 		if (prevnode->mapent != NULL) {
505 			/* duplicate mntpoint found */
506 			syslog(LOG_ERR,
507 			"hierarchical_sort: duplicate mntpnt map=%s key=%s",
508 			    mapname, key);
509 			return (PARSE_ERROR);
510 		}
511 
512 		/* provide a pointer from node to mapent */
513 		prevnode->mapent = me;
514 		me = me->map_next;
515 	}
516 
517 	if (trace > 3) {
518 		trace_prt(1, "\n\thierarchical_sort:\n");
519 		trace_hierarchy(*rootnode, 0);	/* 0 is rootnode's level */
520 	}
521 
522 	return (rc);
523 }
524 
525 /*
526  * push_options(hiernode *node, char *opts, char *mapopts, int err)
527  * Pushes the options down a hierarchical structure. Works recursively from the
528  * root, which is passed in on the first call. Uses a replacement policy.
529  * If a node points to a mapentry, and it has an option, then thats the option
530  * for that mapentry. Else, the node's mapent inherits the option from the
531  * default (which may be the global option for the entry or mapopts).
532  * err is useful in flagging entries with errors in pushing options.
533  * returns PARSE_OK or appropriate error value.
534  */
535 static int
push_options(hiernode * node,char * defaultopts,char * mapopts,int err)536 push_options(hiernode *node, char *defaultopts, char *mapopts, int err)
537 {
538 	int rc = PARSE_OK;
539 	struct mapent *me = NULL;
540 
541 	/* ensure that all the dirs at a level are passed the default options */
542 	while (node != NULL) {
543 		me = node->mapent;
544 		if (me != NULL) {	/* not all nodes point to a mapentry */
545 			me->map_err = err;
546 			if ((rc = set_mapent_opts(me, me->map_mntopts,
547 			    defaultopts, mapopts)) != PARSE_OK)
548 				return (rc);
549 		}
550 
551 		/* push the options to subdirs */
552 		if (node->subdir != NULL) {
553 			if (node->mapent && strcmp(node->mapent->map_fstype,
554 			    MNTTYPE_AUTOFS) == 0)
555 				err = MAPENT_UATFS;
556 			if ((rc = push_options(node->subdir, defaultopts,
557 			    mapopts, err)) != PARSE_OK)
558 				return (rc);
559 		}
560 		node = node->leveldir;
561 	}
562 	return (rc);
563 }
564 
565 #define	FSTYPE "fstype"
566 #define	FSTYPE_EQ "fstype="
567 #define	NO_OPTS ""
568 
569 /*
570  * set_mapent_opts(struct mapent *me, char *opts, char *defaultopts,
571  *			char *mapopts)
572  * sets the mapentry's options, fstype and mounter fields by separating
573  * out the fstype part from the opts. Use default options if opts is NULL.
574  * Note taht defaultopts may be the same as mapopts.
575  * Returns PARSE_OK or appropriate error value.
576  */
577 static int
set_mapent_opts(struct mapent * me,char * opts,char * defaultopts,char * mapopts)578 set_mapent_opts(struct mapent *me, char *opts, char *defaultopts,
579 		char *mapopts)
580 {
581 	char entryopts[AUTOFS_MAXOPTSLEN];
582 	char fstype[MAX_FSLEN], mounter[MAX_FSLEN];
583 	int rc = PARSE_OK;
584 	bool_t fstype_opt = FALSE;
585 
586 	strcpy(fstype, MNTTYPE_NFS);		/* default */
587 
588 	/* set options to default options, if none exist for this entry */
589 	if (opts == NULL) {
590 		opts = defaultopts;
591 		if (defaultopts == NULL) { /* NULL opts for entry */
592 			strcpy(mounter, fstype);
593 			goto done;
594 		}
595 	}
596 	if (*opts == '-')
597 		opts++;
598 
599 	/* separate opts into fstype and (other) entrypopts */
600 	get_opts(opts,	entryopts, fstype, &fstype_opt);
601 
602 	/* replace any existing opts */
603 	if (me->map_mntopts != NULL)
604 		free(me->map_mntopts);
605 	if ((me->map_mntopts = strdup(entryopts)) == NULL)
606 		return (ENOMEM);
607 	strcpy(mounter,	fstype);
608 
609 	/*
610 	 * child options are exactly fstype = somefs, we need to do some
611 	 * more option pushing work.
612 	 */
613 	if (fstype_opt == TRUE &&
614 	    (strcmp(me->map_mntopts, NO_OPTS) == 0)) {
615 		free(me->map_mntopts);
616 		if ((rc = fstype_opts(me, opts, defaultopts,
617 		    mapopts)) != PARSE_OK)
618 			return (rc);
619 	}
620 
621 done:
622 	if (((me->map_fstype = strdup(fstype)) == NULL) ||
623 	    ((me->map_mounter = strdup(mounter)) == NULL)) {
624 		if (me->map_fstype != NULL)
625 			free(me->map_fstype);
626 		syslog(LOG_ERR, "set_mapent_opts: No memory");
627 		return (ENOMEM);
628 	}
629 
630 	return (rc);
631 }
632 
633 /*
634  * Check the option string for an "fstype"
635  * option.  If found, return the fstype
636  * and the option string with the fstype
637  * option removed, e.g.
638  *
639  *  input:  "fstype=nfs,ro,nosuid"
640  *  opts:   "ro,nosuid"
641  *  fstype: "nfs"
642  *
643  * Also indicates if the fstype option was present
644  * by setting a flag, if the pointer to the flag
645  * is not NULL.
646  */
647 static void
get_opts(input,opts,fstype,fstype_opt)648 get_opts(input, opts, fstype, fstype_opt)
649 	char *input;
650 	char *opts; 	/* output */
651 	char *fstype;   /* output */
652 	bool_t *fstype_opt;
653 {
654 	char *p, *pb;
655 	char buf[MAXOPTSLEN];
656 	char *placeholder;
657 
658 	*opts = '\0';
659 	(void) strcpy(buf, input);
660 	pb = buf;
661 	while (p = (char *)strtok_r(pb, ",", &placeholder)) {
662 		pb = NULL;
663 		if (strncmp(p, FSTYPE_EQ, 7) == 0) {
664 			if (fstype_opt != NULL)
665 				*fstype_opt = TRUE;
666 			(void) strcpy(fstype, p + 7);
667 		} else {
668 			if (*opts)
669 				(void) strcat(opts, ",");
670 			(void) strcat(opts, p);
671 		}
672 	}
673 }
674 
675 /*
676  * fstype_opts(struct mapent *me, char *opts, char *defaultopts,
677  *				char *mapopts)
678  * We need to push global options to the child entry if it is exactly
679  * fstype=somefs.
680  */
681 static int
fstype_opts(struct mapent * me,char * opts,char * defaultopts,char * mapopts)682 fstype_opts(struct mapent *me, char *opts, char *defaultopts,
683 				char *mapopts)
684 {
685 	char pushentryopts[AUTOFS_MAXOPTSLEN];
686 	char pushfstype[MAX_FSLEN];
687 
688 	if (defaultopts && *defaultopts == '-')
689 		defaultopts++;
690 
691 	/*
692 	 * the options to push are the global defaults for the entry,
693 	 * if they exist, or mapopts, if the global defaults for the
694 	 * entry does not exist.
695 	 */
696 	if (strcmp(defaultopts, opts) == 0) {
697 		if (*mapopts == '-')
698 			mapopts++;
699 		get_opts(mapopts, pushentryopts, pushfstype, NULL);
700 	} else {
701 		get_opts(defaultopts, pushentryopts, pushfstype, NULL);
702 	}
703 
704 	me->map_mntopts = strdup(pushentryopts);
705 
706 	if (!me->map_mntopts) {
707 		syslog(LOG_ERR, "fstype_opts: No memory");
708 		return (ENOMEM);
709 	}
710 
711 	return (PARSE_OK);
712 }
713 
714 /*
715  * modify_mapents(struct mapent **mapents, char *mapname,
716  *			char *mapopts, char *subdir, hiernode *rootnode,
717  * 			char *key, uint_t isdirect, bool_t mount_access)
718  * modifies the intermediate mapentry list into the final one, and passes
719  * back a pointer to it. The final list may contain faked mapentries for
720  * hiernodes that do not point to a mapentry, or converted mapentries, if
721  * hiernodes that point to a mapentry need to be converted from nfs to autofs.
722  * mounts. Entries that are not directly 1 level below the subdir are removed.
723  * Returns PARSE_OK or PARSE_ERROR
724  */
725 static int
modify_mapents(struct mapent ** mapents,char * mapname,char * mapopts,char * subdir,hiernode * rootnode,char * key,uint_t isdirect,bool_t mount_access)726 modify_mapents(struct mapent **mapents, char *mapname,
727 			char *mapopts, char *subdir, hiernode *rootnode,
728 			char *key, uint_t isdirect, bool_t mount_access)
729 {
730 	struct mapent *mp = NULL;
731 	char w[MAXPATHLEN];
732 
733 	struct mapent *me;
734 	int rc = PARSE_OK;
735 	struct mapent *faked_mapents = NULL;
736 
737 	/*
738 	 * correct the mapentry mntlevel from default -1 to level depending on
739 	 * position in hierarchy, and build any faked mapentries, if required
740 	 * at one level below the rootnode given by subdir.
741 	 */
742 	if ((rc = set_and_fake_mapent_mntlevel(rootnode, subdir, key, mapname,
743 	    &faked_mapents, isdirect, mapopts, mount_access)) != PARSE_OK)
744 		return (rc);
745 
746 	/*
747 	 * attaches faked mapents to real mapents list. Assumes mapents
748 	 * is not NULL.
749 	 */
750 	me = *mapents;
751 	while (me->map_next != NULL)
752 		me = me->map_next;
753 	me->map_next = faked_mapents;
754 
755 	/*
756 	 * get rid of nodes marked at level -1
757 	 */
758 	me = *mapents;
759 	while (me != NULL) {
760 		if ((me->map_mntlevel ==  -1) || (me->map_err) ||
761 		    (mount_access == FALSE && me->map_mntlevel == 0)) {
762 			/*
763 			 * syslog any errors and free entry
764 			 */
765 			if (me->map_err)
766 				dump_mapent_err(me, key, mapname);
767 
768 			if (me ==  (*mapents)) {
769 				/* special case when head has to be freed */
770 				*mapents = me->map_next;
771 				if ((*mapents) ==  NULL) {
772 					/* something wierd happened */
773 					if (verbose)
774 						syslog(LOG_ERR,
775 						"modify_mapents: level error");
776 					return (PARSE_ERROR);
777 				}
778 
779 				/* separate out the node */
780 				me->map_next = NULL;
781 				free_mapent(me);
782 				me = *mapents;
783 			} else {
784 				mp->map_next = me->map_next;
785 				me->map_next = NULL;
786 				free_mapent(me);
787 				me = mp->map_next;
788 			}
789 			continue;
790 		}
791 
792 		/*
793 		 * convert level 1 mapents that are not already autonodes
794 		 * to autonodes
795 		 */
796 		if (me->map_mntlevel == 1 &&
797 		    (strcmp(me->map_fstype, MNTTYPE_AUTOFS) != 0) &&
798 		    (me->map_faked != TRUE)) {
799 			if ((rc = convert_mapent_to_automount(me, mapname,
800 			    mapopts)) != PARSE_OK)
801 				return (rc);
802 		}
803 		strcpy(w, (me->map_mntpnt+strlen(subdir)));
804 		strcpy(me->map_mntpnt, w);
805 		mp = me;
806 		me = me->map_next;
807 	}
808 
809 	if (trace > 3)
810 		trace_mapents("modify_mapents:", *mapents);
811 
812 	return (PARSE_OK);
813 }
814 
815 /*
816  * set_and_fake_mapent_mntlevel(hiernode *rootnode, char *subdir, char *key,
817  *			char *mapname, struct mapent **faked_mapents,
818  *			uint_t isdirect, char *mapopts, bool_t mount_access)
819  * sets the mapentry mount levels (depths) with respect to the subdir.
820  * Assigns a value of 0 to the new root. Finds the level1 directories by
821  * calling mark_*_level1_*(). Also cleans off extra /'s in level0 and
822  * level1 map_mntpnts. Note that one level below the new root is an existing
823  * mapentry if there's a mapentry (nfs mount) corresponding to the root,
824  * and the direct subdir set for the root, if there's no mapentry corresponding
825  * to the root (we install autodirs). Returns PARSE_OK or error value.
826  */
827 static int
set_and_fake_mapent_mntlevel(hiernode * rootnode,char * subdir,char * key,char * mapname,struct mapent ** faked_mapents,uint_t isdirect,char * mapopts,bool_t mount_access)828 set_and_fake_mapent_mntlevel(hiernode *rootnode, char *subdir, char *key,
829 		char *mapname, struct mapent **faked_mapents,
830 		uint_t isdirect, char *mapopts, bool_t mount_access)
831 {
832 	char dirname[MAXFILENAMELEN];
833 	char traversed_path[MAXPATHLEN]; /* used in building fake mapentries */
834 
835 	char *subdir_child = subdir;
836 	hiernode *prevnode = rootnode;
837 	hiernode *currnode = rootnode->subdir;
838 	int rc = PARSE_OK;
839 	traversed_path[0] = '\0';
840 
841 	/*
842 	 * find and mark the root by tracing down subdir. Use traversed_path
843 	 * to keep track of how far we go, while guaranteeing that it
844 	 * contains no '/' at the end. Took some mucking to get that right.
845 	 */
846 	if ((rc = get_dir_from_path(dirname, &subdir_child, sizeof (dirname)))
847 	    != PARSE_OK)
848 		return (rc);
849 
850 	if (dirname[0] != '\0')
851 		sprintf(traversed_path, "%s/%s", traversed_path, dirname);
852 
853 	prevnode = rootnode;
854 	currnode = rootnode->subdir;
855 	while (dirname[0] != '\0' && currnode != NULL) {
856 		if (strcmp(currnode->dirname, dirname) == 0) {
857 
858 			/* subdir is a child of currnode */
859 			prevnode = currnode;
860 			currnode = currnode->subdir;
861 
862 			if ((rc = get_dir_from_path(dirname, &subdir_child,
863 			    sizeof (dirname))) != PARSE_OK)
864 				return (rc);
865 			if (dirname[0] != '\0')
866 				sprintf(traversed_path, "%s/%s",
867 				    traversed_path, dirname);
868 
869 		} else {
870 			/* try next leveldir */
871 			prevnode = currnode;
872 			currnode = currnode->leveldir;
873 		}
874 	}
875 
876 	if (dirname[0] != '\0') {
877 		if (verbose)
878 			syslog(LOG_ERR,
879 			"set_and_fake_mapent_mntlevel: subdir=%s error: map=%s",
880 			    subdir, mapname);
881 		return (PARSE_ERROR);
882 	}
883 
884 	/*
885 	 * see if level of root really points to a mapent and if
886 	 * have access to that filessystem - call appropriate
887 	 * routine to mark level 1 nodes, and build faked entries
888 	 */
889 	if (prevnode->mapent != NULL && mount_access == TRUE) {
890 		if (trace > 3)
891 			trace_prt(1, "  node mountpoint %s\t travpath=%s\n",
892 			    prevnode->mapent->map_mntpnt, traversed_path);
893 
894 		/*
895 		 * Copy traversed path map_mntpnt to get rid of any extra
896 		 * '/' the map entry may contain.
897 		 */
898 		if (strlen(prevnode->mapent->map_mntpnt) <
899 		    strlen(traversed_path)) { /* sanity check */
900 			if (verbose)
901 				syslog(LOG_ERR,
902 				"set_and_fake_mapent_mntlevel: path=%s error",
903 				    traversed_path);
904 			return (PARSE_ERROR);
905 		}
906 		if (strcmp(prevnode->mapent->map_mntpnt, traversed_path) != 0)
907 			strcpy(prevnode->mapent->map_mntpnt, traversed_path);
908 
909 		prevnode->mapent->map_mntlevel = 0; /* root level is 0 */
910 		if (currnode != NULL) {
911 			if ((rc = mark_level1_root(currnode,
912 			    traversed_path)) != PARSE_OK)
913 				return (rc);
914 		}
915 	} else if (currnode != NULL) {
916 		if (trace > 3)
917 			trace_prt(1, "  No rootnode, travpath=%s\n",
918 			    traversed_path);
919 		if ((rc = mark_and_fake_level1_noroot(currnode,
920 		    traversed_path, key, mapname, faked_mapents, isdirect,
921 		    mapopts)) != PARSE_OK)
922 			return (rc);
923 	}
924 
925 	if (trace > 3) {
926 		trace_prt(1, "\n\tset_and_fake_mapent_mntlevel\n");
927 		trace_hierarchy(rootnode, 0);
928 	}
929 
930 	return (rc);
931 }
932 
933 
934 /*
935  * mark_level1_root(hiernode *node, char *traversed_path)
936  * marks nodes upto one level below the rootnode given by subdir
937  * recursively. Called if rootnode points to a mapent.
938  * In this routine, a level 1 node is considered to be the 1st existing
939  * mapentry below the root node, so there's no faking involved.
940  * Returns PARSE_OK or error value
941  */
942 static int
mark_level1_root(hiernode * node,char * traversed_path)943 mark_level1_root(hiernode *node, char *traversed_path)
944 {
945 	/* ensure we touch all leveldirs */
946 	while (node) {
947 		/*
948 		 * mark node level as 1, if one exists - else walk down
949 		 * subdirs until we find one.
950 		 */
951 		if (node->mapent ==  NULL) {
952 			char w[MAXPATHLEN];
953 
954 			if (node->subdir != NULL) {
955 				sprintf(w, "%s/%s", traversed_path,
956 				    node->dirname);
957 				if (mark_level1_root(node->subdir, w)
958 				    == PARSE_ERROR)
959 					return (PARSE_ERROR);
960 			} else {
961 				if (verbose) {
962 					syslog(LOG_ERR,
963 					"mark_level1_root: hierarchy error");
964 				}
965 				return (PARSE_ERROR);
966 			}
967 		} else {
968 			char w[MAXPATHLEN];
969 
970 			sprintf(w, "%s/%s", traversed_path, node->dirname);
971 			if (trace > 3)
972 				trace_prt(1, "  node mntpnt %s\t travpath %s\n",
973 				    node->mapent->map_mntpnt, w);
974 
975 			/* replace mntpnt with travpath to clean extra '/' */
976 			if (strlen(node->mapent->map_mntpnt) < strlen(w)) {
977 				if (verbose) {
978 					syslog(LOG_ERR,
979 					"mark_level1_root: path=%s error",
980 					    traversed_path);
981 				}
982 				return (PARSE_ERROR);
983 			}
984 			if (strcmp(node->mapent->map_mntpnt, w) != 0)
985 				strcpy(node->mapent->map_mntpnt, w);
986 			node->mapent->map_mntlevel = 1;
987 		}
988 		node = node->leveldir;
989 	}
990 	return (PARSE_OK);
991 }
992 
993 /*
994  * mark_and_fake_level1_noroot(hiernode *node, char *traversed_path,
995  * 			char *key,char *mapname, struct mapent **faked_mapents,
996  *			uint_t isdirect, char *mapopts)
997  * Called if the root of the hierarchy does not point to a mapent. marks nodes
998  * upto one physical level below the rootnode given by subdir. checks if
999  * there's a real mapentry. If not, it builds a faked one (autonode) at that
1000  * point. The faked autonode is direct, with the map being the same as the
1001  * original one from which the call originated. Options are same as that of
1002  * the map and assigned in automount_opts(). Returns PARSE_OK or error value.
1003  */
1004 static int
mark_and_fake_level1_noroot(hiernode * node,char * traversed_path,char * key,char * mapname,struct mapent ** faked_mapents,uint_t isdirect,char * mapopts)1005 mark_and_fake_level1_noroot(hiernode *node, char *traversed_path,
1006 			char *key, char *mapname, struct mapent **faked_mapents,
1007 			uint_t isdirect, char *mapopts)
1008 {
1009 	struct mapent *me;
1010 	int rc = 0;
1011 	char faked_map_mntpnt[MAXPATHLEN];
1012 	char w1[MAXPATHLEN];
1013 	char w[MAXPATHLEN];
1014 
1015 	while (node != NULL) {
1016 		if (node->mapent != NULL) {
1017 			/*
1018 			 * existing mapentry at level 1 - copy travpath to
1019 			 * get rid of extra '/' in mntpnt
1020 			 */
1021 			sprintf(w, "%s/%s", traversed_path, node->dirname);
1022 			if (trace > 3)
1023 				trace_prt(1, "  node mntpnt=%s\t travpath=%s\n",
1024 				    node->mapent->map_mntpnt, w);
1025 			if (strlen(node->mapent->map_mntpnt) < strlen(w)) {
1026 				/* sanity check */
1027 				if (verbose)
1028 					syslog(LOG_ERR,
1029 					"mark_fake_level1_noroot:path=%s error",
1030 					    traversed_path);
1031 				return (PARSE_ERROR);
1032 			}
1033 			if (strcmp(node->mapent->map_mntpnt, w) != 0)
1034 				strcpy(node->mapent->map_mntpnt, w);
1035 			node->mapent->map_mntlevel = 1;
1036 		} else {
1037 			/*
1038 			 * build the faked autonode
1039 			 */
1040 			if ((me = (struct mapent *)malloc(sizeof (*me)))
1041 			    == NULL) {
1042 				syslog(LOG_ERR,
1043 				"mark_and_fake_level1_noroot: out of memory");
1044 				return (ENOMEM);
1045 			}
1046 			(void) memset((char *)me, 0, sizeof (*me));
1047 
1048 			if ((me->map_fs = (struct mapfs *)
1049 			    malloc(sizeof (struct mapfs))) == NULL)
1050 				return (ENOMEM);
1051 			(void) memset(me->map_fs, 0, sizeof (struct mapfs));
1052 
1053 			if (isdirect) {
1054 				*w1 = '\0';
1055 			} else {
1056 				strcpy(w1, "/");
1057 				strcat(w1, key);
1058 			}
1059 			me->map_root = strdup(w1);
1060 
1061 			sprintf(faked_map_mntpnt, "%s/%s", traversed_path,
1062 			    node->dirname);
1063 			me->map_mntpnt = strdup(faked_map_mntpnt);
1064 			me->map_fstype = strdup(MNTTYPE_AUTOFS);
1065 			me->map_mounter = strdup(MNTTYPE_AUTOFS);
1066 
1067 			/* set options */
1068 			if ((rc = automount_opts(&me->map_mntopts, mapopts))
1069 			    != PARSE_OK)
1070 				return (rc);
1071 			me->map_fs->mfs_dir = strdup(mapname);
1072 			me->map_mntlevel = 1;
1073 			me->map_modified = FALSE;
1074 			me->map_faked = TRUE;   /* mark as faked */
1075 			if (me->map_root == NULL ||
1076 			    me->map_mntpnt == NULL ||
1077 			    me->map_fstype == NULL ||
1078 			    me->map_mounter == NULL ||
1079 			    me->map_mntopts == NULL ||
1080 			    me->map_fs->mfs_dir == NULL) {
1081 				syslog(LOG_ERR,
1082 				"mark_and_fake_level1_noroot: out of memory");
1083 				free_mapent(*faked_mapents);
1084 				return (ENOMEM);
1085 			}
1086 
1087 			if (*faked_mapents == NULL)
1088 				*faked_mapents = me;
1089 			else {			/* attach to the head */
1090 				me->map_next = *faked_mapents;
1091 				*faked_mapents = me;
1092 			}
1093 			node->mapent = me;
1094 		}
1095 		node = node->leveldir;
1096 	}
1097 	return (rc);
1098 }
1099 
1100 /*
1101  * convert_mapent_to_automount(struct mapent *me, char *mapname,
1102  *				char *mapopts)
1103  * change the mapentry me to an automount - free fields first and NULL them
1104  * to avoid freeing again, while freeing the mapentry at a later stage.
1105  * Could have avoided freeing entries here as we don't really look at them.
1106  * Give the converted mapent entry the options that came with the map using
1107  * automount_opts(). Returns PARSE_OK or appropriate error value.
1108  */
1109 static int
convert_mapent_to_automount(struct mapent * me,char * mapname,char * mapopts)1110 convert_mapent_to_automount(struct mapent *me, char *mapname,
1111 				char *mapopts)
1112 {
1113 	struct mapfs *mfs = me->map_fs;		/* assumes it exists */
1114 	int rc = PARSE_OK;
1115 
1116 	/* free relevant entries */
1117 	if (mfs->mfs_host) {
1118 		free(mfs->mfs_host);
1119 		mfs->mfs_host = NULL;
1120 	}
1121 	while (me->map_fs->mfs_next != NULL) {
1122 		mfs = me->map_fs->mfs_next;
1123 		if (mfs->mfs_host)
1124 			free(mfs->mfs_host);
1125 		if (mfs->mfs_dir)
1126 			free(mfs->mfs_dir);
1127 		me->map_fs->mfs_next = mfs->mfs_next;	/* nulls eventually */
1128 		free((void*)mfs);
1129 	}
1130 
1131 	/* replace relevant entries */
1132 	if (me->map_fstype)
1133 		free(me->map_fstype);
1134 	if ((me->map_fstype = strdup(MNTTYPE_AUTOFS)) == NULL)
1135 		goto alloc_failed;
1136 
1137 	if (me->map_mounter)
1138 		free(me->map_mounter);
1139 	if ((me->map_mounter = strdup(me->map_fstype)) == NULL)
1140 		goto alloc_failed;
1141 
1142 	if (me->map_fs->mfs_dir)
1143 		free(me->map_fs->mfs_dir);
1144 	if ((me->map_fs->mfs_dir = strdup(mapname)) == NULL)
1145 		goto alloc_failed;
1146 
1147 	/* set options */
1148 	if (me->map_mntopts)
1149 		free(me->map_mntopts);
1150 	if ((rc = automount_opts(&me->map_mntopts, mapopts)) != PARSE_OK)
1151 		return (rc);
1152 
1153 	/* mucked with this entry, set the map_modified field to TRUE */
1154 	me->map_modified = TRUE;
1155 
1156 	return (rc);
1157 
1158 alloc_failed:
1159 	syslog(LOG_ERR,
1160 	    "convert_mapent_to_automount: Memory allocation failed");
1161 	return (ENOMEM);
1162 }
1163 
1164 /*
1165  * automount_opts(char **map_mntopts, char *mapopts)
1166  * modifies automount opts - gets rid of all "indirect" and "direct" strings
1167  * if they exist, and then adds a direct string to force a direct automount.
1168  * Rest of the mapopts stay intact. Returns PARSE_OK or appropriate error.
1169  */
1170 static int
automount_opts(char ** map_mntopts,char * mapopts)1171 automount_opts(char **map_mntopts, char *mapopts)
1172 {
1173 	char *opts;
1174 	char *opt;
1175 	int len;
1176 	char *placeholder;
1177 	char buf[AUTOFS_MAXOPTSLEN];
1178 
1179 	char *addopt = "direct";
1180 
1181 	len = strlen(mapopts)+ strlen(addopt)+2;	/* +2 for ",", '\0' */
1182 	if (len > AUTOFS_MAXOPTSLEN) {
1183 		syslog(LOG_ERR,
1184 		"option string %s too long (max=%d)", mapopts,
1185 		    AUTOFS_MAXOPTSLEN-8);
1186 		return (PARSE_ERROR);
1187 	}
1188 
1189 	if (((*map_mntopts) = ((char *)malloc(len))) == NULL) {
1190 		syslog(LOG_ERR,	"automount_opts: Memory allocation failed");
1191 		return (ENOMEM);
1192 	}
1193 	memset(*map_mntopts, 0, len);
1194 
1195 	strcpy(buf, mapopts);
1196 	opts = buf;
1197 	while ((opt = strtok_r(opts, ",", &placeholder)) != NULL) {
1198 		opts = NULL;
1199 
1200 		/* remove trailing and leading spaces */
1201 		while (isspace(*opt))
1202 			opt++;
1203 		len = strlen(opt)-1;
1204 		while (isspace(opt[len]))
1205 			opt[len--] = '\0';
1206 
1207 		/*
1208 		 * if direct or indirect found, get rid of it, else put it
1209 		 * back
1210 		 */
1211 		if ((strcmp(opt, "indirect") == 0) ||
1212 		    (strcmp(opt, "direct") == 0))
1213 			continue;
1214 		if (*map_mntopts[0] != '\0')
1215 			strcat(*map_mntopts, ",");
1216 		strcat(*map_mntopts, opt);
1217 	}
1218 
1219 	/* add the direct string at the end */
1220 	if (*map_mntopts[0] != '\0')
1221 		strcat(*map_mntopts,	",");
1222 	strcat(*map_mntopts, addopt);
1223 
1224 	return (PARSE_OK);
1225 }
1226 
1227 /*
1228  * parse_fsinfo(char *mapname, struct mapent *mapents)
1229  * parses the filesystem information stored in me->map_fsw and me->map_fswq
1230  * and calls appropriate filesystem parser.
1231  * Returns PARSE_OK or an appropriate error value.
1232  */
1233 static int
parse_fsinfo(char * mapname,struct mapent * mapents)1234 parse_fsinfo(char *mapname, struct mapent *mapents)
1235 {
1236 	struct mapent *me = mapents;
1237 	char *bufp;
1238 	char *bufq;
1239 	int wordsz = MAXPATHLEN;
1240 	int err = 0;
1241 
1242 	while (me != NULL) {
1243 		bufp = "";
1244 		bufq = "";
1245 		if (strcmp(me->map_fstype, MNTTYPE_NFS) == 0) {
1246 			err = parse_nfs(mapname, me, me->map_fsw,
1247 			    me->map_fswq, &bufp, &bufq, wordsz);
1248 		} else {
1249 			err = parse_special(me, me->map_fsw, me->map_fswq,
1250 			    &bufp, &bufq, wordsz);
1251 		}
1252 
1253 		if (err != PARSE_OK || *me->map_fsw != '\0' ||
1254 		    *me->map_fswq != '\0') {
1255 			/* sanity check */
1256 			if (verbose)
1257 				syslog(LOG_ERR,
1258 				"parse_fsinfo: mount location error %s",
1259 				    me->map_fsw);
1260 			return (PARSE_ERROR);
1261 		}
1262 
1263 		me = me->map_next;
1264 	}
1265 
1266 	if (trace > 3) {
1267 		trace_mapents("parse_fsinfo:", mapents);
1268 	}
1269 
1270 	return (PARSE_OK);
1271 }
1272 
1273 /*
1274  * This function parses the map entry for a nfs type file system
1275  * The input is the string lp (and lq) which can be one of the
1276  * following forms:
1277  * a) host[(penalty)][,host[(penalty)]]... :/directory
1278  * b) host[(penalty)]:/directory[ host[(penalty)]:/directory]...
1279  * This routine constructs a mapfs link-list for each of
1280  * the hosts and the corresponding file system. The list
1281  * is then attatched to the mapent struct passed in.
1282  */
1283 int
parse_nfs(mapname,me,fsw,fswq,lp,lq,wsize)1284 parse_nfs(mapname, me, fsw, fswq, lp, lq, wsize)
1285 	struct mapent *me;
1286 	char *mapname, *fsw, *fswq, **lp, **lq;
1287 	int wsize;
1288 {
1289 	struct mapfs *mfs, **mfsp;
1290 	char *wlp, *wlq;
1291 	char *hl, hostlist[1024], *hlq, hostlistq[1024];
1292 	char hostname_and_penalty[MXHOSTNAMELEN+5];
1293 	char *hn, *hnq, hostname[MXHOSTNAMELEN+1];
1294 	char dirname[MAXPATHLEN+1], subdir[MAXPATHLEN+1];
1295 	char qbuff[MAXPATHLEN+1], qbuff1[MAXPATHLEN+1];
1296 	char pbuff[10], pbuffq[10];
1297 	int penalty;
1298 	char w[MAXPATHLEN];
1299 	char wq[MAXPATHLEN];
1300 	int host_cnt;
1301 
1302 	mfsp = &me->map_fs;
1303 	*mfsp = NULL;
1304 
1305 	/*
1306 	 * there may be more than one entry in the map list. Get the
1307 	 * first one. Use temps to handle the word information and
1308 	 * copy back into fsw and fswq fields when done.
1309 	 */
1310 	*lp = fsw;
1311 	*lq = fswq;
1312 	if (getword(w, wq, lp, lq, ' ', wsize) == -1)
1313 		return (PARSE_ERROR);
1314 	while (*w && *w != '/') {
1315 		bool_t maybe_url;
1316 
1317 		maybe_url = TRUE;
1318 
1319 		wlp = w; wlq = wq;
1320 		if (getword(hostlist, hostlistq, &wlp, &wlq, ':',
1321 			    sizeof (hostlist)) == -1)
1322 			return (PARSE_ERROR);
1323 		if (!*hostlist)
1324 			goto bad_entry;
1325 
1326 		if (strcmp(hostlist, "nfs") != 0)
1327 			maybe_url = FALSE;
1328 
1329 		if (getword(dirname, qbuff, &wlp, &wlq, ':',
1330 					sizeof (dirname)) == -1)
1331 			return (PARSE_ERROR);
1332 		if (*dirname == '\0')
1333 			goto bad_entry;
1334 
1335 		if (maybe_url == TRUE && strncmp(dirname, "//", 2) != 0)
1336 			maybe_url = FALSE;
1337 
1338 		/*
1339 		 * See the next block comment ("Once upon a time ...") to
1340 		 * understand this. It turns the deprecated concept
1341 		 * of "subdir mounts" produced some useful code for handling
1342 		 * the possibility of a ":port#" in the URL.
1343 		 */
1344 		if (maybe_url == FALSE)
1345 			*subdir = '/';
1346 		else
1347 			*subdir = ':';
1348 
1349 		*qbuff = ' ';
1350 
1351 		/*
1352 		 * Once upon time, before autofs, there was support for
1353 		 * "subdir mounts". The idea was to "economize" the
1354 		 * number of mounts, so if you had a number of entries
1355 		 * all referring to a common subdirectory, e.g.
1356 		 *
1357 		 *	carol    seasons:/export/home11/carol
1358 		 *	ted	 seasons:/export/home11/ted
1359 		 *	alice	 seasons:/export/home11/alice
1360 		 *
1361 		 * then you could tell the automounter to mount a
1362 		 * common mountpoint which was delimited by the second
1363 		 * colon:
1364 		 *
1365 		 *	carol    seasons:/export/home11:carol
1366 		 *	ted	 seasons:/export/home11:ted
1367 		 *	alice	 seasons:/export/home11:alice
1368 		 *
1369 		 * The automounter would mount seasons:/export/home11
1370 		 * then for any other map entry that referenced the same
1371 		 * directory it would build a symbolic link that
1372 		 * appended the remainder of the path after the second
1373 		 * colon, i.e.  once the common subdir was mounted, then
1374 		 * other directories could be accessed just by link
1375 		 * building - no further mounts required.
1376 		 *
1377 		 * In theory the "mount saving" idea sounded good. In
1378 		 * practice the saving didn't amount to much and the
1379 		 * symbolic links confused people because the common
1380 		 * mountpoint had to have a pseudonym.
1381 		 *
1382 		 * To remain backward compatible with the existing
1383 		 * maps, we interpret a second colon as a slash.
1384 		 */
1385 		if (getword(subdir+1, qbuff+1, &wlp, &wlq, ':',
1386 				sizeof (subdir)) == -1)
1387 			return (PARSE_ERROR);
1388 
1389 		if (*(subdir+1))
1390 			(void) strcat(dirname, subdir);
1391 
1392 		hl = hostlist; hlq = hostlistq;
1393 
1394 		host_cnt = 0;
1395 		for (;;) {
1396 
1397 			if (getword(hostname_and_penalty, qbuff, &hl, &hlq, ',',
1398 				sizeof (hostname_and_penalty)) == -1)
1399 				return (PARSE_ERROR);
1400 			if (!*hostname_and_penalty)
1401 				break;
1402 
1403 			host_cnt++;
1404 			if (host_cnt > 1)
1405 				maybe_url = FALSE;
1406 
1407 			hn = hostname_and_penalty;
1408 			hnq = qbuff;
1409 			if (getword(hostname, qbuff1, &hn, &hnq, '(',
1410 				sizeof (hostname)) == -1)
1411 				return (PARSE_ERROR);
1412 			if (hostname[0] == '\0')
1413 				goto bad_entry;
1414 
1415 			if (strcmp(hostname, hostname_and_penalty) == 0) {
1416 				penalty = 0;
1417 			} else {
1418 				maybe_url = FALSE;
1419 				hn++; hnq++;
1420 				if (getword(pbuff, pbuffq, &hn, &hnq, ')',
1421 					sizeof (pbuff)) == -1)
1422 					return (PARSE_ERROR);
1423 				if (!*pbuff)
1424 					penalty = 0;
1425 				else
1426 					penalty = atoi(pbuff);
1427 			}
1428 			mfs = (struct mapfs *)malloc(sizeof (*mfs));
1429 			if (mfs == NULL) {
1430 				syslog(LOG_ERR,
1431 				"parse_nfs: Memory allocation failed");
1432 				return (PARSE_ERROR);
1433 			}
1434 			(void) memset(mfs, 0, sizeof (*mfs));
1435 			*mfsp = mfs;
1436 			mfsp = &mfs->mfs_next;
1437 
1438 			if (maybe_url == TRUE) {
1439 				char *host;
1440 				char *path;
1441 				char *sport;
1442 
1443 				host = dirname+2;
1444 				path = strchr(host, '/');
1445 				if (path == NULL) {
1446 					syslog(LOG_ERR,
1447 					"parse_nfs: illegal nfs url syntax: %s",
1448 					host);
1449 
1450 					return (PARSE_ERROR);
1451 				}
1452 				*path = '\0';
1453 				sport =  strchr(host, ':');
1454 
1455 				if (sport != NULL && sport < path) {
1456 					*sport = '\0';
1457 					mfs->mfs_port = atoi(sport+1);
1458 
1459 					if (mfs->mfs_port > USHRT_MAX) {
1460 						syslog(LOG_ERR,
1461 							"parse_nfs: invalid "
1462 							"port number (%d) in "
1463 							"NFS URL",
1464 							mfs->mfs_port);
1465 
1466 						return (PARSE_ERROR);
1467 					}
1468 
1469 				}
1470 
1471 				path++;
1472 				if (*path == '\0')
1473 					path = ".";
1474 
1475 				mfs->mfs_flags |= MFS_URL;
1476 
1477 				mfs->mfs_host = strdup(host);
1478 				mfs->mfs_dir = strdup(path);
1479 			} else {
1480 				mfs->mfs_host = strdup(hostname);
1481 				mfs->mfs_dir = strdup(dirname);
1482 			}
1483 
1484 			mfs->mfs_penalty = penalty;
1485 			if (mfs->mfs_host == NULL || mfs->mfs_dir == NULL) {
1486 				syslog(LOG_ERR,
1487 				"parse_nfs: Memory allocation failed");
1488 				return (PARSE_ERROR);
1489 			}
1490 		}
1491 		/*
1492 		 * We check host_cnt to make sure we haven't parsed an entry
1493 		 * with no host information.
1494 		 */
1495 		if (host_cnt == 0) {
1496 			syslog(LOG_ERR,
1497 			"parse_nfs: invalid host specified - bad entry "
1498 			"in map %s \"%s\"",
1499 			mapname, w);
1500 			return (PARSE_ERROR);
1501 		}
1502 		if (getword(w, wq, lp, lq, ' ', wsize) == -1)
1503 			return (PARSE_ERROR);
1504 	}
1505 
1506 	strcpy(fsw, w);
1507 	strcpy(fswq, wq);
1508 
1509 	return (PARSE_OK);
1510 
1511 bad_entry:
1512 	syslog(LOG_ERR, "parse_nfs: bad entry in map %s \"%s\"", mapname, w);
1513 	return (PARSE_ERROR);
1514 }
1515 
1516 static int
parse_special(me,w,wq,lp,lq,wsize)1517 parse_special(me, w, wq, lp, lq, wsize)
1518 	struct mapent *me;
1519 	char *w, *wq, **lp, **lq;
1520 	int wsize;
1521 {
1522 	char devname[MAXPATHLEN + 1], qbuf[MAXPATHLEN + 1];
1523 	char *wlp, *wlq;
1524 	struct mapfs *mfs;
1525 
1526 	wlp = w;
1527 	wlq = wq;
1528 	if (getword(devname, qbuf, &wlp, &wlq, ' ', sizeof (devname)) == -1)
1529 		return (PARSE_ERROR);
1530 	if (devname[0] == '\0')
1531 		return (PARSE_ERROR);
1532 
1533 	mfs = (struct mapfs *)malloc(sizeof (struct mapfs));
1534 	if (mfs == NULL)
1535 		return (PARSE_ERROR);
1536 	(void) memset(mfs, 0, sizeof (*mfs));
1537 
1538 	/*
1539 	 * A device name that begins with a slash could
1540 	 * be confused with a mountpoint path, hence use
1541 	 * a colon to escape a device string that begins
1542 	 * with a slash, e.g.
1543 	 *
1544 	 *	foo  -ro  /bar  foo:/bar
1545 	 * and
1546 	 *	foo  -ro  /dev/sr0
1547 	 *
1548 	 * would confuse the parser.  The second instance
1549 	 * must use a colon:
1550 	 *
1551 	 *	foo  -ro  :/dev/sr0
1552 	 */
1553 	mfs->mfs_dir = strdup(&devname[devname[0] == ':']);
1554 	if (mfs->mfs_dir == NULL)
1555 		return (PARSE_ERROR);
1556 	me->map_fs = mfs;
1557 	if (getword(w, wq, lp, lq, ' ', wsize) == -1)
1558 		return (PARSE_ERROR);
1559 	return (0);
1560 }
1561 
1562 /*
1563  * get_dir_from_path(char *dir, char **path, int dirsz)
1564  * gets the directory name dir from path for max string of length dirsz.
1565  * A modification of the getword routine. Assumes the delimiter is '/'
1566  * and that excess /'s are redundant.
1567  * Returns PARSE_OK or PARSE_ERROR
1568  */
1569 static int
get_dir_from_path(char * dir,char ** path,int dirsz)1570 get_dir_from_path(char *dir, char **path, int dirsz)
1571 {
1572 	char *tmp = dir;
1573 	int count = dirsz;
1574 
1575 	if (dirsz <= 0) {
1576 		if (verbose)
1577 			syslog(LOG_ERR,
1578 			"get_dir_from_path: invalid directory size %d", dirsz);
1579 		return (PARSE_ERROR);
1580 	}
1581 
1582 	/* get rid of leading /'s in path */
1583 	while (**path == '/')
1584 		(*path)++;
1585 
1586 	/* now at a word or at the end of path */
1587 	while ((**path) && ((**path) != '/')) {
1588 		if (--count <= 0) {
1589 			*tmp = '\0';
1590 			syslog(LOG_ERR,
1591 			"get_dir_from_path: max pathlength exceeded %d", dirsz);
1592 			return (PARSE_ERROR);
1593 		}
1594 		*dir++ = *(*path)++;
1595 	}
1596 
1597 	*dir = '\0';
1598 
1599 	/* get rid of trailing /'s in path */
1600 	while (**path == '/')
1601 		(*path)++;
1602 
1603 	return (PARSE_OK);
1604 }
1605 
1606 /*
1607  * alloc_hiernode(hiernode **newnode, char *dirname)
1608  * allocates a new hiernode corresponding to a new directory entry
1609  * in the hierarchical structure, and passes a pointer to it back
1610  * to the calling program.
1611  * Returns PARSE_OK or appropriate error value.
1612  */
1613 static int
alloc_hiernode(hiernode ** newnode,char * dirname)1614 alloc_hiernode(hiernode **newnode, char *dirname)
1615 {
1616 	if ((*newnode = (hiernode *)malloc(sizeof (hiernode))) == NULL) {
1617 		syslog(LOG_ERR,	"alloc_hiernode: Memory allocation failed");
1618 		return (ENOMEM);
1619 	}
1620 
1621 	memset(((char *)*newnode), 0, sizeof (hiernode));
1622 	strcpy(((*newnode)->dirname), dirname);
1623 	return (PARSE_OK);
1624 }
1625 
1626 /*
1627  * free_hiernode(hiernode *node)
1628  * frees the allocated hiernode given the head of the structure
1629  * recursively calls itself until it frees entire structure.
1630  * Returns nothing.
1631  */
1632 static void
free_hiernode(hiernode * node)1633 free_hiernode(hiernode *node)
1634 {
1635 	hiernode *currnode = node;
1636 	hiernode *prevnode = NULL;
1637 
1638 	while (currnode != NULL) {
1639 		if (currnode->subdir != NULL)
1640 			free_hiernode(currnode->subdir);
1641 		prevnode = currnode;
1642 		currnode = currnode->leveldir;
1643 		free((void*)prevnode);
1644 	}
1645 }
1646 
1647 /*
1648  * free_mapent(struct mapent *)
1649  * free the mapentry and its fields
1650  */
1651 void
free_mapent(me)1652 free_mapent(me)
1653 	struct mapent *me;
1654 {
1655 	struct mapfs *mfs;
1656 	struct mapent *m;
1657 
1658 	while (me) {
1659 		while (me->map_fs) {
1660 			mfs = me->map_fs;
1661 			if (mfs->mfs_host)
1662 				free(mfs->mfs_host);
1663 			if (mfs->mfs_dir)
1664 				free(mfs->mfs_dir);
1665 			if (mfs->mfs_args)
1666 				free(mfs->mfs_args);
1667 			if (mfs->mfs_nconf)
1668 				freenetconfigent(mfs->mfs_nconf);
1669 			me->map_fs = mfs->mfs_next;
1670 			free((char *)mfs);
1671 		}
1672 
1673 		if (me->map_root)
1674 			free(me->map_root);
1675 		if (me->map_mntpnt)
1676 			free(me->map_mntpnt);
1677 		if (me->map_mntopts)
1678 			free(me->map_mntopts);
1679 		if (me->map_fstype)
1680 			free(me->map_fstype);
1681 		if (me->map_mounter)
1682 			free(me->map_mounter);
1683 		if (me->map_fsw)
1684 			free(me->map_fsw);
1685 		if (me->map_fswq)
1686 			free(me->map_fswq);
1687 
1688 		m = me;
1689 		me = me->map_next;
1690 		free((char *)m);
1691 	}
1692 }
1693 
1694 /*
1695  * trace_mapents(struct mapent *mapents)
1696  * traces through the mapentry structure and prints it element by element
1697  * returns nothing
1698  */
1699 static void
trace_mapents(char * s,struct mapent * mapents)1700 trace_mapents(char *s, struct mapent *mapents)
1701 {
1702 	struct mapfs  *mfs;
1703 	struct mapent *me;
1704 
1705 	trace_prt(1, "\n\t%s\n", s);
1706 	for (me = mapents; me; me = me->map_next) {
1707 		trace_prt(1, "  (%s,%s)\t %s%s -%s\n",
1708 		    me->map_fstype ? me->map_fstype : "",
1709 		    me->map_mounter ? me->map_mounter : "",
1710 		    me->map_root  ? me->map_root : "",
1711 		    me->map_mntpnt ? me->map_mntpnt : "",
1712 		    me->map_mntopts ? me->map_mntopts : "");
1713 		for (mfs = me->map_fs; mfs; mfs = mfs->mfs_next)
1714 			trace_prt(0, "\t\t%s:%s\n",
1715 			    mfs->mfs_host ? mfs->mfs_host: "",
1716 			    mfs->mfs_dir ? mfs->mfs_dir : "");
1717 
1718 		trace_prt(1, "\tme->map_fsw=%s\n",
1719 		    me->map_fsw ? me->map_fsw:"",
1720 		    me->map_fswq ? me->map_fsw:"");
1721 		trace_prt(1, "\t mntlevel=%d\t%s\t%s err=%d\n",
1722 		    me->map_mntlevel,
1723 		    me->map_modified ? "modify=TRUE":"modify=FALSE",
1724 		    me->map_faked ? "faked=TRUE":"faked=FALSE",
1725 		    me->map_err);
1726 	}
1727 }
1728 
1729 /*
1730  * trace_hierarchy(hiernode *node)
1731  * traces the allocated hiernode given the head of the structure
1732  * recursively calls itself until it traces entire structure.
1733  * the first call made at the root is made with a zero level.
1734  * nodelevel is simply used to print tab and make the tracing clean.
1735  * Returns nothing.
1736  */
1737 static void
trace_hierarchy(hiernode * node,int nodelevel)1738 trace_hierarchy(hiernode *node, int nodelevel)
1739 {
1740 	hiernode *currnode = node;
1741 	int i;
1742 
1743 	while (currnode != NULL) {
1744 		if (currnode->subdir != NULL) {
1745 			for (i = 0; i < nodelevel; i++)
1746 				trace_prt(0, "\t");
1747 			trace_prt(0, "\t(%s, ",
1748 			    currnode->dirname ? currnode->dirname :"");
1749 			if (currnode->mapent) {
1750 				trace_prt(0, "%d, %s)\n",
1751 				    currnode->mapent->map_mntlevel,
1752 				    currnode->mapent->map_mntopts ?
1753 				    currnode->mapent->map_mntopts:"");
1754 			}
1755 			else
1756 				trace_prt(0, " ,)\n");
1757 			nodelevel++;
1758 			trace_hierarchy(currnode->subdir, nodelevel);
1759 		} else {
1760 			for (i = 0; i < nodelevel; i++)
1761 				trace_prt(0, "\t");
1762 			trace_prt(0, "\t(%s, ",
1763 			    currnode->dirname ? currnode->dirname :"");
1764 			if (currnode->mapent) {
1765 				trace_prt(0, "%d, %s)\n",
1766 				    currnode->mapent->map_mntlevel,
1767 				    currnode->mapent->map_mntopts ?
1768 				    currnode->mapent->map_mntopts:"");
1769 			}
1770 			else
1771 				trace_prt(0, ", )\n");
1772 		}
1773 		currnode = currnode->leveldir;
1774 	}
1775 }
1776 
1777 struct mapent *
do_mapent_hosts(mapopts,host,isdirect)1778 do_mapent_hosts(mapopts, host, isdirect)
1779 	char *mapopts, *host;
1780 	uint_t isdirect;
1781 {
1782 	CLIENT *cl;
1783 	struct mapent *me, *ms, *mp;
1784 	struct mapfs *mfs;
1785 	struct exportnode *ex = NULL;
1786 	struct exportnode *exlist, *texlist, **texp, *exnext;
1787 	struct timeval timeout;
1788 	enum clnt_stat clnt_stat;
1789 	char name[MAXPATHLEN];
1790 	char entryopts[MAXOPTSLEN];
1791 	char fstype[32], mounter[32];
1792 	int exlen, duplicate;
1793 	struct mnttab mb;	/* needed for hasmntopt() to get nfs version */
1794 	rpcvers_t nfsvers;	/* version in map options, 0 if not there */
1795 	rpcvers_t vers, versmin; /* used to negotiate nfs vers in pingnfs() */
1796 	int retries, delay;
1797 	int foundvers;
1798 
1799 	if (trace > 1)
1800 		trace_prt(1, "  do_mapent_hosts: host %s\n", host);
1801 
1802 	/* check for special case: host is me */
1803 
1804 	if (self_check(host)) {
1805 		ms = (struct mapent *)malloc(sizeof (*ms));
1806 		if (ms == NULL)
1807 			goto alloc_failed;
1808 		(void) memset((char *)ms, 0, sizeof (*ms));
1809 		(void) strcpy(fstype, MNTTYPE_NFS);
1810 		get_opts(mapopts, entryopts, fstype, NULL);
1811 		ms->map_mntopts = strdup(entryopts);
1812 		if (ms->map_mntopts == NULL)
1813 			goto alloc_failed;
1814 		ms->map_mounter = strdup(fstype);
1815 		if (ms->map_mounter == NULL)
1816 			goto alloc_failed;
1817 		ms->map_fstype = strdup(MNTTYPE_NFS);
1818 		if (ms->map_fstype == NULL)
1819 			goto alloc_failed;
1820 
1821 		if (isdirect)
1822 			name[0] = '\0';
1823 		else {
1824 			(void) strcpy(name, "/");
1825 			(void) strcat(name, host);
1826 		}
1827 		ms->map_root = strdup(name);
1828 		if (ms->map_root == NULL)
1829 			goto alloc_failed;
1830 		ms->map_mntpnt = strdup("");
1831 		if (ms->map_mntpnt == NULL)
1832 			goto alloc_failed;
1833 		mfs = (struct mapfs *)malloc(sizeof (*mfs));
1834 		if (mfs == NULL)
1835 			goto alloc_failed;
1836 		(void) memset((char *)mfs, 0, sizeof (*mfs));
1837 		ms->map_fs = mfs;
1838 		mfs->mfs_host = strdup(host);
1839 		if (mfs->mfs_host == NULL)
1840 			goto alloc_failed;
1841 		mfs->mfs_dir  = strdup("/");
1842 		if (mfs->mfs_dir == NULL)
1843 			goto alloc_failed;
1844 
1845 		/* initialize mntlevel and modify */
1846 		ms->map_mntlevel = -1;
1847 		ms->map_modified = FALSE;
1848 		ms->map_faked = FALSE;
1849 
1850 		if (trace > 1)
1851 			trace_prt(1,
1852 			"  do_mapent_hosts: self-host %s OK\n", host);
1853 
1854 		return (ms);
1855 	}
1856 
1857 	/*
1858 	 * Call pingnfs. Note that we can't have replicated hosts in /net.
1859 	 * XXX - we would like to avoid duplicating the across the wire calls
1860 	 * made here in nfsmount(). The pingnfs cache should help avoid it.
1861 	 */
1862 	mb.mnt_mntopts = mapopts;
1863 	foundvers = nopt(&mb, MNTOPT_VERS, (int *)&nfsvers);
1864 	if (!foundvers)
1865 		nfsvers = 0;
1866 	if (set_versrange(nfsvers, &vers, &versmin) != 0) {
1867 		syslog(LOG_ERR, "Incorrect NFS version specified for %s", host);
1868 		return ((struct mapent *)NULL);
1869 	}
1870 	if (pingnfs(host, get_retry(mapopts) + 1, &vers, versmin, 0, FALSE,
1871 	    NULL, NULL) != RPC_SUCCESS)
1872 		return ((struct mapent *)NULL);
1873 
1874 	retries = get_retry(mapopts);
1875 	delay = INITDELAY;
1876 retry:
1877 	/* get export list of host */
1878 	cl = clnt_create(host, MOUNTPROG, MOUNTVERS, "circuit_v");
1879 	if (cl == NULL) {
1880 		cl = clnt_create(host, MOUNTPROG, MOUNTVERS, "datagram_v");
1881 		if (cl == NULL) {
1882 			syslog(LOG_ERR,
1883 			"do_mapent_hosts: %s %s", host, clnt_spcreateerror(""));
1884 			return ((struct mapent *)NULL);
1885 		}
1886 
1887 	}
1888 #ifdef MALLOC_DEBUG
1889 	add_alloc("CLNT_HANDLE", cl, 0, __FILE__, __LINE__);
1890 	add_alloc("AUTH_HANDLE", cl->cl_auth, 0,
1891 		__FILE__, __LINE__);
1892 #endif
1893 
1894 	timeout.tv_usec = 0;
1895 	timeout.tv_sec  = 25;
1896 	if (clnt_stat = clnt_call(cl, MOUNTPROC_EXPORT, xdr_void, 0,
1897 				xdr_exports, (caddr_t)&ex, timeout)) {
1898 
1899 		if (retries-- > 0) {
1900 			clnt_destroy(cl);
1901 			DELAY(delay);
1902 			goto retry;
1903 		}
1904 
1905 		syslog(LOG_ERR,
1906 			"do_mapent_hosts: %s: export list: %s",
1907 			host, clnt_sperrno(clnt_stat));
1908 #ifdef MALLOC_DEBUG
1909 		drop_alloc("CLNT_HANDLE", cl, __FILE__, __LINE__);
1910 		drop_alloc("AUTH_HANDLE", cl->cl_auth,
1911 			__FILE__, __LINE__);
1912 #endif
1913 		clnt_destroy(cl);
1914 		return ((struct mapent *)NULL);
1915 	}
1916 
1917 #ifdef MALLOC_DEBUG
1918 	drop_alloc("CLNT_HANDLE", cl, __FILE__, __LINE__);
1919 	drop_alloc("AUTH_HANDLE", cl->cl_auth,
1920 		__FILE__, __LINE__);
1921 #endif
1922 	clnt_destroy(cl);
1923 
1924 	if (ex == NULL) {
1925 		if (trace > 1)
1926 			trace_prt(1,
1927 			    gettext("  getmapent_hosts: null export list\n"));
1928 		return ((struct mapent *)NULL);
1929 	}
1930 
1931 	/* now sort by length of names - to get mount order right */
1932 	exlist = ex;
1933 	texlist = NULL;
1934 #ifdef lint
1935 	exnext = NULL;
1936 #endif
1937 	for (; ex; ex = exnext) {
1938 		exnext = ex->ex_next;
1939 		exlen = strlen(ex->ex_dir);
1940 		duplicate = 0;
1941 		for (texp = &texlist; *texp; texp = &((*texp)->ex_next)) {
1942 			if (exlen < (int)strlen((*texp)->ex_dir))
1943 				break;
1944 			duplicate = (strcmp(ex->ex_dir, (*texp)->ex_dir) == 0);
1945 			if (duplicate) {
1946 				/* disregard duplicate entry */
1947 				freeex_ent(ex);
1948 				break;
1949 			}
1950 		}
1951 		if (!duplicate) {
1952 			ex->ex_next = *texp;
1953 			*texp = ex;
1954 		}
1955 	}
1956 	exlist = texlist;
1957 
1958 	(void) strcpy(fstype, MNTTYPE_NFS);
1959 	get_opts(mapopts, entryopts, fstype, NULL);
1960 	(void) strcpy(mounter, fstype);
1961 
1962 	/* Now create a mapent from the export list */
1963 	ms = NULL;
1964 	me = NULL;
1965 
1966 	for (ex = exlist; ex; ex = ex->ex_next) {
1967 		mp = me;
1968 		me = (struct mapent *)malloc(sizeof (*me));
1969 		if (me == NULL)
1970 			goto alloc_failed;
1971 		(void) memset((char *)me, 0, sizeof (*me));
1972 
1973 		if (ms == NULL)
1974 			ms = me;
1975 		else
1976 			mp->map_next = me;
1977 
1978 		if (isdirect)
1979 			name[0] = '\0';
1980 		else {
1981 			(void) strcpy(name, "/");
1982 			(void) strcat(name, host);
1983 		}
1984 		me->map_root = strdup(name);
1985 		if (me->map_root == NULL)
1986 			goto alloc_failed;
1987 
1988 		*name = '\0';
1989 		if (strcmp(ex->ex_dir, "/") != 0) {
1990 			if (*(ex->ex_dir) != '/')
1991 				(void) strcpy(name, "/");
1992 			(void) strcat(name, ex->ex_dir);
1993 		}
1994 		me->map_mntpnt = strdup(name);
1995 		if (me->map_mntpnt == NULL)
1996 			goto alloc_failed;
1997 
1998 		me->map_fstype = strdup(fstype);
1999 		if (me->map_fstype == NULL)
2000 			goto alloc_failed;
2001 		me->map_mounter = strdup(mounter);
2002 		if (me->map_mounter == NULL)
2003 			goto alloc_failed;
2004 		me->map_mntopts = strdup(entryopts);
2005 		if (me->map_mntopts == NULL)
2006 			goto alloc_failed;
2007 
2008 		mfs = (struct mapfs *)malloc(sizeof (*mfs));
2009 		if (mfs == NULL)
2010 			goto alloc_failed;
2011 		(void) memset((char *)mfs, 0, sizeof (*mfs));
2012 		me->map_fs = mfs;
2013 		mfs->mfs_host = strdup(host);
2014 		if (mfs->mfs_host == NULL)
2015 			goto alloc_failed;
2016 		mfs->mfs_dir = strdup(ex->ex_dir);
2017 		if (mfs->mfs_dir == NULL)
2018 			goto alloc_failed;
2019 
2020 		/* initialize mntlevel and modify values */
2021 		me->map_mntlevel = -1;
2022 		me->map_modified = FALSE;
2023 		me->map_faked = FALSE;
2024 	}
2025 	freeex(exlist);
2026 
2027 	if (trace > 1)
2028 		trace_prt(1, "  do_mapent_hosts: host %s OK\n", host);
2029 
2030 	return (ms);
2031 
2032 alloc_failed:
2033 	syslog(LOG_ERR, "do_mapent_hosts: Memory allocation failed");
2034 	free_mapent(ms);
2035 	freeex(exlist);
2036 	return ((struct mapent *)NULL);
2037 }
2038 
2039 
2040 static void
freeex_ent(ex)2041 freeex_ent(ex)
2042 	struct exportnode *ex;
2043 {
2044 	struct groupnode *groups, *tmpgroups;
2045 
2046 	free(ex->ex_dir);
2047 	groups = ex->ex_groups;
2048 	while (groups) {
2049 		free(groups->gr_name);
2050 		tmpgroups = groups->gr_next;
2051 		free((char *)groups);
2052 		groups = tmpgroups;
2053 	}
2054 	free((char *)ex);
2055 }
2056 
2057 static void
freeex(ex)2058 freeex(ex)
2059 	struct exportnode *ex;
2060 {
2061 	struct exportnode *tmpex;
2062 
2063 	while (ex) {
2064 		tmpex = ex->ex_next;
2065 		freeex_ent(ex);
2066 		ex = tmpex;
2067 	}
2068 }
2069 
2070 static const char uatfs_err[] = "submount under fstype=autofs not supported";
2071 /*
2072  * dump_mapent_err(struct mapent *me, char *key, char *mapname)
2073  * syslog appropriate error in mapentries.
2074  */
dump_mapent_err(struct mapent * me,char * key,char * mapname)2075 static void dump_mapent_err(struct mapent *me, char *key, char *mapname)
2076 {
2077 	switch (me->map_err) {
2078 	case MAPENT_NOERR:
2079 		if (verbose)
2080 			syslog(LOG_ERR,
2081 			"map=%s key=%s mntpnt=%s: no error");
2082 		break;
2083 	case MAPENT_UATFS:
2084 		syslog(LOG_ERR,
2085 		"mountpoint %s in map %s key %s not mounted: %s",
2086 		    me->map_mntpnt, mapname, key, uatfs_err);
2087 		break;
2088 	default:
2089 		if (verbose)
2090 			syslog(LOG_ERR,
2091 			"map=%s key=%s mntpnt=%s: unknown mapentry error");
2092 	}
2093 }
2094