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 *	ns_files.c
23 *
24 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
25 * Use is subject to license terms.
26 */
27
28#pragma ident	"%Z%%M%	%I%	%E% SMI"
29
30#include <stdio.h>
31#include <stdlib.h>
32#include <syslog.h>
33#include <string.h>
34#include <ctype.h>
35#include <nsswitch.h>
36#include <sys/stat.h>
37#include <sys/param.h>
38#include <rpc/rpc.h>
39#include <rpcsvc/nfs_prot.h>
40#include <thread.h>
41#include <assert.h>
42#include <errno.h>
43#include <fcntl.h>
44#include <unistd.h>
45#include <synch.h>
46#include <sys/types.h>
47#include <sys/wait.h>
48#include <strings.h>
49#include "automount.h"
50
51static int read_execout(char *key, char **lp, char *fname, char *line,
52			int linesz);
53static int call_read_execout(char *key, char **lp, char *fname, char *line,
54			int linesz);
55static FILE *file_open(char *, char *, char **, char ***);
56
57/*
58 * Initialize the stack
59 */
60void
61init_files(char **stack, char ***stkptr)
62{
63	/*
64	 * The call is bogus for automountd since the stack is
65	 * is more appropriately initialized in the thread-private
66	 * routines
67	 */
68	if (stack == NULL && stkptr == NULL)
69		return;
70	(void) stack_op(INIT, NULL, stack, stkptr);
71}
72
73int
74getmapent_files(key, mapname, ml, stack, stkptr, iswildcard, isrestricted)
75	char *key;
76	char *mapname;
77	struct mapline *ml;
78	char **stack, ***stkptr;
79	bool_t *iswildcard;
80	bool_t isrestricted;
81{
82	int nserr;
83	FILE *fp;
84	char word[MAXPATHLEN+1], wordq[MAXPATHLEN+1];
85	char linebuf[LINESZ], lineqbuf[LINESZ];
86	char *lp, *lq;
87	struct stat stbuf;
88	char fname[MAXFILENAMELEN]; /* /etc prepended to mapname if reqd */
89	int syntaxok = 1;
90
91	if (iswildcard)
92		*iswildcard = FALSE;
93	if ((fp = file_open(mapname, fname, stack, stkptr)) == NULL) {
94		nserr = __NSW_UNAVAIL;
95		goto done;
96	}
97
98	if (stat(fname, &stbuf) < 0) {
99		nserr = __NSW_UNAVAIL;
100		goto done;
101	}
102
103	/*
104	 * If the file has its execute bit on then
105	 * assume it's an executable map.
106	 * Execute it and pass the key as an argument.
107	 * Expect to get a map entry on the stdout.
108	 * Ignore the "x" bit on restricted maps.
109	 */
110	if (!isrestricted && (stbuf.st_mode & S_IXUSR)) {
111		int rc;
112
113		if (trace > 1) {
114			trace_prt(1,
115				"\tExecutable map: map=%s key=%s\n",
116				fname, key);
117		}
118
119		rc = call_read_execout(key, &lp, fname, ml->linebuf, LINESZ);
120
121		if (rc != 0) {
122			nserr = __NSW_UNAVAIL;
123			goto done;
124		}
125
126		if (strlen(ml->linebuf) == 0) {
127			nserr = __NSW_NOTFOUND;
128			goto done;
129		}
130
131		unquote(ml->linebuf, ml->lineqbuf);
132		nserr = __NSW_SUCCESS;
133		goto done;
134	}
135
136
137	/*
138	 * It's just a normal map file.
139	 * Search for the entry with the required key.
140	 */
141	for (;;) {
142		lp = get_line(fp, fname, linebuf, sizeof (linebuf));
143		if (lp == NULL) {
144			nserr = __NSW_NOTFOUND;
145			goto done;
146		}
147		if (verbose && syntaxok && isspace(*(uchar_t *)lp)) {
148			syntaxok = 0;
149			syslog(LOG_ERR,
150				"leading space in map entry \"%s\" in %s",
151				lp, mapname);
152		}
153		lq = lineqbuf;
154		unquote(lp, lq);
155		if ((getword(word, wordq, &lp, &lq, ' ', sizeof (word))
156			== -1) || (word[0] == '\0'))
157			continue;
158		if (strcmp(word, key) == 0)
159			break;
160		if (word[0] == '*' && word[1] == '\0') {
161			if (iswildcard)
162				*iswildcard = TRUE;
163			break;
164		}
165		if (word[0] == '+') {
166			nserr = getmapent(key, word+1, ml, stack, stkptr,
167						iswildcard, isrestricted);
168			if (nserr == __NSW_SUCCESS)
169				goto done;
170			continue;
171		}
172
173		/*
174		 * sanity check each map entry key against
175		 * the lookup key as the map is searched.
176		 */
177		if (verbose && syntaxok) { /* sanity check entry */
178			if (*key == '/') {
179				if (*word != '/') {
180					syntaxok = 0;
181					syslog(LOG_ERR,
182					"bad key \"%s\" in direct map %s\n",
183					word, mapname);
184				}
185			} else {
186				if (strchr(word, '/')) {
187					syntaxok = 0;
188					syslog(LOG_ERR,
189					"bad key \"%s\" in indirect map %s\n",
190					word, mapname);
191				}
192			}
193		}
194	}
195
196	(void) strcpy(ml->linebuf, lp);
197	(void) strcpy(ml->lineqbuf, lq);
198	nserr = __NSW_SUCCESS;
199done:
200	if (fp) {
201		(void) stack_op(POP, (char *)NULL, stack, stkptr);
202		(void) fclose(fp);
203	}
204
205
206	return (nserr);
207}
208
209int
210getmapkeys_files(mapname, list, error, cache_time, stack, stkptr)
211	char *mapname;
212	struct dir_entry **list;
213	int *error;
214	int *cache_time;
215	char **stack, ***stkptr;
216{
217	FILE *fp = NULL;
218	char word[MAXPATHLEN+1], wordq[MAXPATHLEN+1];
219	char linebuf[LINESZ], lineqbuf[LINESZ];
220	char *lp, *lq;
221	struct stat stbuf;
222	char fname[MAXFILENAMELEN]; /* /etc prepended to mapname if reqd */
223	int syntaxok = 1;
224	int nserr;
225	struct dir_entry *last = NULL;
226
227	if (trace > 1)
228		trace_prt(1, "getmapkeys_files %s\n", mapname);
229
230	*cache_time = RDDIR_CACHE_TIME;
231	if ((fp = file_open(mapname, fname, stack, stkptr)) == NULL) {
232		*error = ENOENT;
233		nserr = __NSW_UNAVAIL;
234		goto done;
235	}
236	if (fseek(fp, 0L, SEEK_SET) == -1) {
237		*error = ENOENT;
238		nserr = __NSW_UNAVAIL;
239		goto done;
240	}
241
242	if (stat(fname, &stbuf) < 0) {
243		*error = ENOENT;
244		nserr = __NSW_UNAVAIL;
245		goto done;
246	}
247
248	/*
249	 * If the file has its execute bit on then
250	 * assume it's an executable map.
251	 * I don't know how to list executable maps, return
252	 * an empty map.
253	 */
254	if (stbuf.st_mode & S_IXUSR) {
255		*error = 0;
256		nserr = __NSW_SUCCESS;
257		goto done;
258	}
259	/*
260	 * It's just a normal map file.
261	 * List entries one line at a time.
262	 */
263	for (;;) {
264		lp = get_line(fp, fname, linebuf, sizeof (linebuf));
265		if (lp == NULL) {
266			nserr = __NSW_SUCCESS;
267			goto done;
268		}
269		if (syntaxok && isspace(*(uchar_t *)lp)) {
270			syntaxok = 0;
271			syslog(LOG_ERR,
272				"leading space in map entry \"%s\" in %s",
273				lp, mapname);
274		}
275		lq = lineqbuf;
276		unquote(lp, lq);
277		if ((getword(word, wordq, &lp, &lq, ' ', MAXFILENAMELEN)
278				== -1) || (word[0] == '\0'))
279			continue;
280		/*
281		 * Wildcard entries should be ignored and this should be
282		 * the last entry read to corroborate the search through
283		 * files, i.e., search for key until a wildcard is reached.
284		 */
285		if (word[0] == '*' && word[1] == '\0')
286			break;
287		if (word[0] == '+') {
288			/*
289			 * Name switch here
290			 */
291			getmapkeys(word+1, list, error, cache_time,
292				stack, stkptr, 0);
293			/*
294			 * the list may have been updated, therefore
295			 * our 'last' may no longer be valid
296			 */
297			last = NULL;
298			continue;
299		}
300
301		if (add_dir_entry(word, list, &last) != 0) {
302			*error = ENOMEM;
303			goto done;
304		}
305		assert(last != NULL);
306	}
307
308	nserr = __NSW_SUCCESS;
309done:
310	if (fp) {
311		(void) stack_op(POP, (char *)NULL, stack, stkptr);
312		(void) fclose(fp);
313	}
314
315	if (*list != NULL) {
316		/*
317		 * list of entries found
318		 */
319		*error = 0;
320	}
321	return (nserr);
322}
323
324int
325loadmaster_files(mastermap, defopts, stack, stkptr)
326	char *mastermap;
327	char *defopts;
328	char **stack, ***stkptr;
329{
330	FILE *fp;
331	int done = 0;
332	char *line, *dir, *map, *opts;
333	char linebuf[LINESZ];
334	char lineq[LINESZ];
335	char fname[MAXFILENAMELEN]; /* /etc prepended to mapname if reqd */
336
337
338	if ((fp = file_open(mastermap, fname, stack, stkptr)) == NULL)
339		return (__NSW_UNAVAIL);
340
341	while ((line = get_line(fp, fname, linebuf,
342				sizeof (linebuf))) != NULL) {
343		unquote(line, lineq);
344		if (macro_expand("", line, lineq, LINESZ)) {
345			syslog(LOG_ERR,
346				"map %s: line too long (max %d chars)",
347				mastermap, LINESZ - 1);
348			continue;
349		}
350		dir = line;
351		while (*dir && isspace(*dir))
352			dir++;
353		if (*dir == '\0')
354			continue;
355		map = dir;
356
357		while (*map && !isspace(*map)) map++;
358		if (*map)
359			*map++ = '\0';
360
361		if (*dir == '+') {
362			opts = map;
363			while (*opts && isspace(*opts))
364				opts++;
365			if (*opts != '-')
366				opts = defopts;
367			else
368				opts++;
369			/*
370			 * Check for no embedded blanks.
371			 */
372			if (strcspn(opts, " 	") == strlen(opts)) {
373				dir++;
374				(void) loadmaster_map(dir, opts, stack, stkptr);
375			} else {
376pr_msg("Warning: invalid entry for %s in %s ignored.\n", dir, fname);
377				continue;
378			}
379
380		} else {
381			while (*map && isspace(*map))
382				map++;
383			if (*map == '\0')
384				continue;
385			opts = map;
386			while (*opts && !isspace(*opts))
387				opts++;
388			if (*opts) {
389				*opts++ = '\0';
390				while (*opts && isspace(*opts))
391					opts++;
392			}
393			if (*opts != '-')
394				opts = defopts;
395			else
396				opts++;
397			/*
398			 * Check for no embedded blanks.
399			 */
400			if (strcspn(opts, " 	") == strlen(opts)) {
401				dirinit(dir, map, opts, 0, stack, stkptr);
402			} else {
403pr_msg("Warning: invalid entry for %s in %s ignored.\n", dir, fname);
404				continue;
405			}
406		}
407		done++;
408	}
409
410	(void) stack_op(POP, (char *)NULL, stack, stkptr);
411	(void) fclose(fp);
412
413	return (done ? __NSW_SUCCESS : __NSW_NOTFOUND);
414}
415
416int
417loaddirect_files(map, local_map, opts, stack, stkptr)
418	char *map, *local_map, *opts;
419	char **stack, ***stkptr;
420{
421	FILE *fp;
422	int done = 0;
423	char *line, *p1, *p2;
424	char linebuf[LINESZ];
425	char fname[MAXFILENAMELEN]; /* /etc prepended to mapname if reqd */
426
427	if ((fp = file_open(map, fname, stack, stkptr)) == NULL)
428		return (__NSW_UNAVAIL);
429
430	while ((line = get_line(fp, fname, linebuf,
431				sizeof (linebuf))) != NULL) {
432		p1 = line;
433		while (*p1 && isspace(*p1))
434			p1++;
435		if (*p1 == '\0')
436			continue;
437		p2 = p1;
438		while (*p2 && !isspace(*p2))
439			p2++;
440		*p2 = '\0';
441		if (*p1 == '+') {
442			p1++;
443			(void) loaddirect_map(p1, local_map, opts, stack,
444					stkptr);
445		} else {
446			dirinit(p1, local_map, opts, 1, stack, stkptr);
447		}
448		done++;
449	}
450
451	(void) stack_op(POP, (char *)NULL, stack, stkptr);
452	(void) fclose(fp);
453
454	return (done ? __NSW_SUCCESS : __NSW_NOTFOUND);
455}
456
457/*
458 * This procedure opens the file and pushes it onto the
459 * the stack. Only if a file is opened successfully, is
460 * it pushed onto the stack
461 */
462static FILE *
463file_open(map, fname, stack, stkptr)
464	char *map, *fname;
465	char **stack, ***stkptr;
466{
467	FILE *fp;
468
469	if (*map != '/') {
470		/* prepend an "/etc" */
471		(void) strcpy(fname, "/etc/");
472		(void) strcat(fname, map);
473	} else
474		(void) strcpy(fname, map);
475
476	fp = fopen(fname, "r");
477
478	if (fp != NULL) {
479		if (!stack_op(PUSH, fname, stack, stkptr)) {
480			(void) fclose(fp);
481			return (NULL);
482		}
483	}
484	return (fp);
485}
486
487/*
488 * reimplemnted to be MT-HOT.
489 */
490int
491stack_op(op, name, stack, stkptr)
492	int op;
493	char *name;
494	char **stack, ***stkptr;
495{
496	char **ptr = NULL;
497	char **stk_top = &stack[STACKSIZ - 1];
498
499	/*
500	 * the stackptr points to the next empty slot
501	 * for PUSH: put the element and increment stkptr
502	 * for POP: decrement stkptr and free
503	 */
504
505	switch (op) {
506	case INIT:
507		for (ptr = stack; ptr != stk_top; ptr++)
508			*ptr = (char *)NULL;
509		*stkptr = stack;
510		return (1);
511	case ERASE:
512		for (ptr = stack; ptr != stk_top; ptr++)
513			if (*ptr) {
514				if (trace > 1)
515					trace_prt(1, "  ERASE %s\n", *ptr);
516				free (*ptr);
517				*ptr = (char *)NULL;
518			}
519		*stkptr = stack;
520		return (1);
521	case PUSH:
522		if (*stkptr == stk_top)
523			return (0);
524		for (ptr = stack; ptr != *stkptr; ptr++)
525			if (*ptr && (strcmp(*ptr, name) == 0)) {
526				return (0);
527			}
528		if (trace > 1)
529			trace_prt(1, "  PUSH %s\n", name);
530		if ((**stkptr = strdup(name)) == NULL) {
531			syslog(LOG_ERR, "stack_op: Memory alloc failed : %m");
532			return (0);
533		}
534		(*stkptr)++;
535		return (1);
536	case POP:
537		if (*stkptr != stack)
538			(*stkptr)--;
539		else
540			syslog(LOG_ERR, "Attempt to pop empty stack\n");
541
542		if (*stkptr && **stkptr) {
543			if (trace > 1)
544				trace_prt(1, "  POP %s\n", **stkptr);
545			free (**stkptr);
546			**stkptr = (char *)NULL;
547		}
548		return (1);
549	default:
550		return (0);
551	}
552}
553
554#define	READ_EXECOUT_ARGS 3
555
556/*
557 * read_execout(char *key, char **lp, char *fname, char *line, int linesz)
558 * A simpler, multithreaded implementation of popen(). Used due to
559 * non multithreaded implementation of popen() (it calls vfork()) and a
560 * significant bug in execl().
561 * Returns 0 on OK or -1 on error.
562 */
563static int
564read_execout(char *key, char **lp, char *fname, char *line, int linesz)
565{
566	int p[2];
567	int status = 0;
568	int child_pid;
569	char *args[READ_EXECOUT_ARGS];
570	FILE *fp0;
571
572	if (pipe(p) < 0) {
573		syslog(LOG_ERR, "read_execout: Cannot create pipe");
574		return (-1);
575	}
576
577	/* setup args for execv */
578	if (((args[0] = strdup(fname)) == NULL) ||
579		((args[1] = strdup(key)) == NULL)) {
580		if (args[0] != NULL)
581			free(args[0]);
582		syslog(LOG_ERR, "read_execout: Memory allocation failed");
583		return (-1);
584	}
585	args[2] = NULL;
586
587	if (trace > 3)
588		trace_prt(1, "\tread_execout: forking .....\n");
589
590	switch ((child_pid = fork1())) {
591	case -1:
592		syslog(LOG_ERR, "read_execout: Cannot fork");
593		return (-1);
594	case 0:
595		/*
596		 * Child
597		 */
598		close(p[0]);
599		close(1);
600		if (fcntl(p[1], F_DUPFD, 1) != 1) {
601			syslog(LOG_ERR,
602			"read_execout: dup of stdout failed");
603			_exit(-1);
604		}
605		close(p[1]);
606		execv(fname, &args[0]);
607		_exit(-1);
608	default:
609		/*
610		 * Parent
611		 */
612		close(p[1]);
613
614		/*
615		 * wait for child to complete. Note we read after the
616		 * child exits to guarantee a full pipe.
617		 */
618		while (waitpid(child_pid, &status, 0) < 0) {
619			/* if waitpid fails with EINTR, restart */
620			if (errno != EINTR) {
621				status = -1;
622				break;
623			}
624		}
625		if (status != -1) {
626			if ((fp0 = fdopen(p[0], "r")) != NULL) {
627				*lp = get_line(fp0, fname, line, linesz);
628				fclose(fp0);
629			} else {
630				close(p[0]);
631				status = -1;
632			}
633		} else {
634			close(p[0]);
635		}
636
637		/* free args */
638		free(args[0]);
639		free(args[1]);
640
641		if (trace > 3)
642			trace_prt(1, "\tread_execout: map=%s key=%s line=%s\n",
643			fname, key, line);
644
645		return (status);
646	}
647}
648
649void
650automountd_do_exec_map(void *cookie, char *argp, size_t arg_size,
651		door_desc_t *dfd, uint_t n_desc)
652{
653	command_t	*command;
654	char	line[LINESZ];
655	char	*lp;
656	int	rc;
657
658	command = (command_t *)argp;
659
660	if (sizeof (*command) != arg_size) {
661		rc = 0;
662		syslog(LOG_ERR, "read_execout: invalid door arguments");
663		door_return((char *)&rc, sizeof (rc), NULL, 0);
664	}
665
666	rc = read_execout(command->key, &lp, command->file, line, LINESZ);
667
668	if (rc != 0) {
669		/*
670		 * read_execout returned an error, return 0 to the door_client
671		 * to indicate failure
672		 */
673		rc = 0;
674		door_return((char *)&rc, sizeof (rc), NULL, 0);
675	} else {
676		door_return((char *)line, LINESZ, NULL, 0);
677	}
678	trace_prt(1, "automountd_do_exec_map, door return failed %s, %s\n",
679	    command->file, strerror(errno));
680	door_return(NULL, 0, NULL, 0);
681}
682
683int
684call_read_execout(char *key, char **lp, char *fname, char *line,
685			int linesz)
686{
687	command_t command;
688	door_arg_t darg;
689	int ret;
690
691	bzero(&command, sizeof (command));
692	(void) strlcpy(command.file, fname, MAXPATHLEN);
693	(void) strlcpy(command.key, key, MAXOPTSLEN);
694
695	if (trace >= 1)
696		trace_prt(1, "call_read_execout %s %s\n", fname, key);
697	darg.data_ptr = (char *)&command;
698	darg.data_size = sizeof (command);
699	darg.desc_ptr = NULL;
700	darg.desc_num = 0;
701	darg.rbuf = line;
702	darg.rsize = linesz;
703
704	ret = door_call(did_exec_map, &darg);
705
706	lp = &line;
707	return (ret);
708}
709