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 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 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 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 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 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 * 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 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 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 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 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