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
51 static int read_execout(char *key, char **lp, char *fname, char *line,
52 int linesz);
53 static int call_read_execout(char *key, char **lp, char *fname, char *line,
54 int linesz);
55 static FILE *file_open(char *, char *, char **, char ***);
56
57 /*
58 * Initialize the stack
59 */
60 void
init_files(char ** stack,char *** stkptr)61 init_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
73 int
getmapent_files(key,mapname,ml,stack,stkptr,iswildcard,isrestricted)74 getmapent_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;
199 done:
200 if (fp) {
201 (void) stack_op(POP, (char *)NULL, stack, stkptr);
202 (void) fclose(fp);
203 }
204
205
206 return (nserr);
207 }
208
209 int
getmapkeys_files(mapname,list,error,cache_time,stack,stkptr)210 getmapkeys_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;
309 done:
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
324 int
loadmaster_files(mastermap,defopts,stack,stkptr)325 loadmaster_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 {
376 pr_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 {
403 pr_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
416 int
loaddirect_files(map,local_map,opts,stack,stkptr)417 loaddirect_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 */
462 static FILE *
file_open(map,fname,stack,stkptr)463 file_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 */
490 int
stack_op(op,name,stack,stkptr)491 stack_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 */
563 static int
read_execout(char * key,char ** lp,char * fname,char * line,int linesz)564 read_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
649 void
automountd_do_exec_map(void * cookie,char * argp,size_t arg_size,door_desc_t * dfd,uint_t n_desc)650 automountd_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
683 int
call_read_execout(char * key,char ** lp,char * fname,char * line,int linesz)684 call_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