1 /*- 2 * Copyright (c) 2016 The DragonFly Project 3 * Copyright (c) 2014 The FreeBSD Foundation 4 * All rights reserved. 5 * 6 * This software was developed by Edward Tomasz Napierala under sponsorship 7 * from the FreeBSD Foundation. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 * 30 * $FreeBSD: head/usr.sbin/autofs/common.c 303527 2016-07-30 01:10:05Z bapt $ 31 */ 32 33 #include <sys/types.h> 34 #include <sys/stat.h> 35 #include <assert.h> 36 #include <err.h> 37 #include <errno.h> 38 #include <fcntl.h> 39 #include <libgen.h> 40 #include <paths.h> 41 #include <stdio.h> 42 #include <stdlib.h> 43 #include <string.h> 44 #include <unistd.h> 45 46 #include "common.h" 47 48 extern FILE *yyin; 49 extern char *yytext; 50 extern int yylex(void); 51 52 static void parse_master_yyin(struct node *root, const char *master); 53 static void parse_map_yyin(struct node *parent, const char *map, 54 const char *executable_key); 55 56 char * 57 checked_strdup(const char *s) 58 { 59 char *c; 60 61 assert(s != NULL); 62 63 c = strdup(s); 64 if (c == NULL) 65 log_err(1, "strdup"); 66 return (c); 67 } 68 69 /* 70 * Concatenate two strings, inserting separator between them, unless not needed. 71 */ 72 char * 73 concat(const char *s1, char separator, const char *s2) 74 { 75 char *result; 76 char s1last, s2first; 77 int ret; 78 79 if (s1 == NULL) 80 s1 = ""; 81 if (s2 == NULL) 82 s2 = ""; 83 84 if (s1[0] == '\0') 85 s1last = '\0'; 86 else 87 s1last = s1[strlen(s1) - 1]; 88 89 s2first = s2[0]; 90 91 if (s1last == separator && s2first == separator) { 92 /* 93 * If s1 ends with the separator and s2 begins with 94 * it - skip the latter; otherwise concatenating "/" 95 * and "/foo" would end up returning "//foo". 96 */ 97 ret = asprintf(&result, "%s%s", s1, s2 + 1); 98 } else if (s1last == separator || s2first == separator || 99 s1[0] == '\0' || s2[0] == '\0') { 100 ret = asprintf(&result, "%s%s", s1, s2); 101 } else { 102 ret = asprintf(&result, "%s%c%s", s1, separator, s2); 103 } 104 if (ret < 0) 105 log_err(1, "asprintf"); 106 107 //log_debugx("%s: got %s and %s, returning %s", __func__, s1, s2, result); 108 109 return (result); 110 } 111 112 void 113 create_directory(const char *path) 114 { 115 char *component, *copy, *tofree, *partial, *tmp; 116 int error; 117 118 assert(path[0] == '/'); 119 120 /* 121 * +1 to skip the leading slash. 122 */ 123 copy = tofree = checked_strdup(path + 1); 124 125 partial = checked_strdup(""); 126 for (;;) { 127 component = strsep(©, "/"); 128 if (component == NULL) 129 break; 130 tmp = concat(partial, '/', component); 131 free(partial); 132 partial = tmp; 133 //log_debugx("creating \"%s\"", partial); 134 error = mkdir(partial, 0755); 135 if (error != 0 && errno != EEXIST) { 136 log_warn("cannot create %s", partial); 137 return; 138 } 139 } 140 141 free(tofree); 142 } 143 144 struct node * 145 node_new_root(void) 146 { 147 struct node *n; 148 149 n = calloc(1, sizeof(*n)); 150 if (n == NULL) 151 log_err(1, "calloc"); 152 // XXX 153 n->n_key = checked_strdup("/"); 154 n->n_options = checked_strdup(""); 155 156 TAILQ_INIT(&n->n_children); 157 158 return (n); 159 } 160 161 struct node * 162 node_new(struct node *parent, char *key, char *options, char *location, 163 const char *config_file, int config_line) 164 { 165 struct node *n; 166 167 n = calloc(1, sizeof(*n)); 168 if (n == NULL) 169 log_err(1, "calloc"); 170 171 TAILQ_INIT(&n->n_children); 172 assert(key != NULL); 173 assert(key[0] != '\0'); 174 n->n_key = key; 175 if (options != NULL) 176 n->n_options = options; 177 else 178 n->n_options = strdup(""); 179 n->n_location = location; 180 assert(config_file != NULL); 181 n->n_config_file = config_file; 182 assert(config_line >= 0); 183 n->n_config_line = config_line; 184 185 assert(parent != NULL); 186 n->n_parent = parent; 187 TAILQ_INSERT_TAIL(&parent->n_children, n, n_next); 188 189 return (n); 190 } 191 192 struct node * 193 node_new_map(struct node *parent, char *key, char *options, char *map, 194 const char *config_file, int config_line) 195 { 196 struct node *n; 197 198 n = calloc(1, sizeof(*n)); 199 if (n == NULL) 200 log_err(1, "calloc"); 201 202 TAILQ_INIT(&n->n_children); 203 assert(key != NULL); 204 assert(key[0] != '\0'); 205 n->n_key = key; 206 if (options != NULL) 207 n->n_options = options; 208 else 209 n->n_options = strdup(""); 210 n->n_map = map; 211 assert(config_file != NULL); 212 n->n_config_file = config_file; 213 assert(config_line >= 0); 214 n->n_config_line = config_line; 215 216 assert(parent != NULL); 217 n->n_parent = parent; 218 TAILQ_INSERT_TAIL(&parent->n_children, n, n_next); 219 220 return (n); 221 } 222 223 static struct node * 224 node_duplicate(const struct node *o, struct node *parent) 225 { 226 const struct node *child; 227 struct node *n; 228 229 if (parent == NULL) 230 parent = o->n_parent; 231 232 n = node_new(parent, o->n_key, o->n_options, o->n_location, 233 o->n_config_file, o->n_config_line); 234 235 TAILQ_FOREACH(child, &o->n_children, n_next) 236 node_duplicate(child, n); 237 238 return (n); 239 } 240 241 static void 242 node_delete(struct node *n) 243 { 244 struct node *child, *tmp; 245 246 assert (n != NULL); 247 248 TAILQ_FOREACH_SAFE(child, &n->n_children, n_next, tmp) 249 node_delete(child); 250 251 if (n->n_parent != NULL) 252 TAILQ_REMOVE(&n->n_parent->n_children, n, n_next); 253 254 free(n); 255 } 256 257 /* 258 * Move (reparent) node 'n' to make it sibling of 'previous', placed 259 * just after it. 260 */ 261 static void 262 node_move_after(struct node *n, struct node *previous) 263 { 264 265 TAILQ_REMOVE(&n->n_parent->n_children, n, n_next); 266 n->n_parent = previous->n_parent; 267 TAILQ_INSERT_AFTER(&previous->n_parent->n_children, previous, n, n_next); 268 } 269 270 static void 271 node_expand_includes(struct node *root, bool is_master) 272 { 273 struct node *n, *n2, *tmp, *tmp2, *tmproot; 274 int error; 275 276 TAILQ_FOREACH_SAFE(n, &root->n_children, n_next, tmp) { 277 if (n->n_key[0] != '+') 278 continue; 279 280 error = access(AUTO_INCLUDE_PATH, F_OK); 281 if (error != 0) { 282 log_errx(1, "directory services not configured; " 283 "%s does not exist", AUTO_INCLUDE_PATH); 284 } 285 286 /* 287 * "+1" to skip leading "+". 288 */ 289 yyin = auto_popen(AUTO_INCLUDE_PATH, n->n_key + 1, NULL); 290 assert(yyin != NULL); 291 292 tmproot = node_new_root(); 293 if (is_master) 294 parse_master_yyin(tmproot, n->n_key); 295 else 296 parse_map_yyin(tmproot, n->n_key, NULL); 297 298 error = auto_pclose(yyin); 299 yyin = NULL; 300 if (error != 0) { 301 log_errx(1, "failed to handle include \"%s\"", 302 n->n_key); 303 } 304 305 /* 306 * Entries to be included are now in tmproot. We need to merge 307 * them with the rest, preserving their place and ordering. 308 */ 309 TAILQ_FOREACH_REVERSE_SAFE(n2, 310 &tmproot->n_children, nodehead, n_next, tmp2) { 311 node_move_after(n2, n); 312 } 313 314 node_delete(n); 315 node_delete(tmproot); 316 } 317 } 318 319 static char * 320 expand_ampersand(char *string, const char *key) 321 { 322 char c, *expanded; 323 int i, ret, before_len = 0; 324 bool backslashed = false; 325 326 assert(key[0] != '\0'); 327 328 expanded = checked_strdup(string); 329 330 for (i = 0; string[i] != '\0'; i++) { 331 c = string[i]; 332 if (c == '\\' && backslashed == false) { 333 backslashed = true; 334 continue; 335 } 336 if (backslashed) { 337 backslashed = false; 338 continue; 339 } 340 backslashed = false; 341 if (c != '&') 342 continue; 343 344 /* 345 * The 'before_len' variable contains the number 346 * of characters before the '&'. 347 */ 348 before_len = i; 349 //assert(i + 1 < (int)strlen(string)); 350 351 ret = asprintf(&expanded, "%.*s%s%s", 352 before_len, string, key, string + before_len + 1); 353 if (ret < 0) 354 log_err(1, "asprintf"); 355 356 //log_debugx("\"%s\" expanded with key \"%s\" to \"%s\"", 357 // string, key, expanded); 358 359 /* 360 * Figure out where to start searching for next variable. 361 */ 362 string = expanded; 363 i = before_len + strlen(key); 364 backslashed = false; 365 //assert(i < (int)strlen(string)); 366 } 367 368 return (expanded); 369 } 370 371 /* 372 * Expand "&" in n_location. If the key is NULL, try to use 373 * key from map entries themselves. Keep in mind that maps 374 * consist of tho levels of node structures, the key is one 375 * level up. 376 * 377 * Variant with NULL key is for "automount -LL". 378 */ 379 void 380 node_expand_ampersand(struct node *n, const char *key) 381 { 382 struct node *child; 383 384 if (n->n_location != NULL) { 385 if (key == NULL) { 386 if (n->n_parent != NULL && 387 strcmp(n->n_parent->n_key, "*") != 0) { 388 n->n_location = expand_ampersand(n->n_location, 389 n->n_parent->n_key); 390 } 391 } else { 392 n->n_location = expand_ampersand(n->n_location, key); 393 } 394 } 395 396 TAILQ_FOREACH(child, &n->n_children, n_next) 397 node_expand_ampersand(child, key); 398 } 399 400 /* 401 * Expand "*" in n_key. 402 */ 403 void 404 node_expand_wildcard(struct node *n, const char *key) 405 { 406 struct node *child, *expanded; 407 408 assert(key != NULL); 409 410 if (strcmp(n->n_key, "*") == 0) { 411 expanded = node_duplicate(n, NULL); 412 expanded->n_key = checked_strdup(key); 413 node_move_after(expanded, n); 414 } 415 416 TAILQ_FOREACH(child, &n->n_children, n_next) 417 node_expand_wildcard(child, key); 418 } 419 420 int 421 node_expand_defined(struct node *n) 422 { 423 struct node *child; 424 int error, cumulated_error = 0; 425 426 if (n->n_location != NULL) { 427 n->n_location = defined_expand(n->n_location); 428 if (n->n_location == NULL) { 429 log_warnx("failed to expand location for %s", 430 node_path(n)); 431 return (EINVAL); 432 } 433 } 434 435 TAILQ_FOREACH(child, &n->n_children, n_next) { 436 error = node_expand_defined(child); 437 if (error != 0 && cumulated_error == 0) 438 cumulated_error = error; 439 } 440 441 return (cumulated_error); 442 } 443 444 static bool 445 node_is_direct_key(const struct node *n) 446 { 447 448 if (n->n_parent != NULL && n->n_parent->n_parent == NULL && 449 strcmp(n->n_key, "/-") == 0) { 450 return (true); 451 } 452 453 return (false); 454 } 455 456 bool 457 node_is_direct_map(const struct node *n) 458 { 459 460 for (;;) { 461 assert(n->n_parent != NULL); 462 if (n->n_parent->n_parent == NULL) 463 break; 464 n = n->n_parent; 465 } 466 467 return (node_is_direct_key(n)); 468 } 469 470 bool 471 node_has_wildcards(const struct node *n) 472 { 473 const struct node *child; 474 475 TAILQ_FOREACH(child, &n->n_children, n_next) { 476 if (strcmp(child->n_key, "*") == 0) 477 return (true); 478 } 479 480 return (false); 481 } 482 483 static void 484 node_expand_maps(struct node *n, bool indirect) 485 { 486 struct node *child, *tmp; 487 488 TAILQ_FOREACH_SAFE(child, &n->n_children, n_next, tmp) { 489 if (node_is_direct_map(child)) { 490 if (indirect) 491 continue; 492 } else { 493 if (indirect == false) 494 continue; 495 } 496 497 /* 498 * This is the first-level map node; the one that contains 499 * the key and subnodes with mountpoints and actual map names. 500 */ 501 if (child->n_map == NULL) 502 continue; 503 504 if (indirect) { 505 log_debugx("map \"%s\" is an indirect map, parsing", 506 child->n_map); 507 } else { 508 log_debugx("map \"%s\" is a direct map, parsing", 509 child->n_map); 510 } 511 parse_map(child, child->n_map, NULL, NULL); 512 } 513 } 514 515 static void 516 node_expand_direct_maps(struct node *n) 517 { 518 519 node_expand_maps(n, false); 520 } 521 522 void 523 node_expand_indirect_maps(struct node *n) 524 { 525 526 node_expand_maps(n, true); 527 } 528 529 static char * 530 node_path_x(const struct node *n, char *x) 531 { 532 char *path; 533 534 if (n->n_parent == NULL) 535 return (x); 536 537 /* 538 * Return "/-" for direct maps only if we were asked for path 539 * to the "/-" node itself, not to any of its subnodes. 540 */ 541 if (node_is_direct_key(n) && x[0] != '\0') 542 return (x); 543 544 assert(n->n_key[0] != '\0'); 545 path = concat(n->n_key, '/', x); 546 free(x); 547 548 return (node_path_x(n->n_parent, path)); 549 } 550 551 /* 552 * Return full path for node, consisting of concatenated 553 * paths of node itself and all its parents, up to the root. 554 */ 555 char * 556 node_path(const struct node *n) 557 { 558 char *path; 559 size_t len; 560 561 path = node_path_x(n, checked_strdup("")); 562 563 /* 564 * Strip trailing slash, unless the whole path is "/". 565 */ 566 len = strlen(path); 567 if (len > 1 && path[len - 1] == '/') 568 path[len - 1] = '\0'; 569 570 return (path); 571 } 572 573 static char * 574 node_options_x(const struct node *n, char *x) 575 { 576 char *options; 577 578 if (n == NULL) 579 return (x); 580 581 options = concat(x, ',', n->n_options); 582 free(x); 583 584 return (node_options_x(n->n_parent, options)); 585 } 586 587 /* 588 * Return options for node, consisting of concatenated 589 * options from the node itself and all its parents, 590 * up to the root. 591 */ 592 char * 593 node_options(const struct node *n) 594 { 595 596 return (node_options_x(n, checked_strdup(""))); 597 } 598 599 static void 600 node_print_indent(const struct node *n, const char *cmdline_options, 601 int indent) 602 { 603 const struct node *child, *first_child; 604 char *path, *options, *tmp; 605 606 path = node_path(n); 607 tmp = node_options(n); 608 options = concat(cmdline_options, ',', tmp); 609 free(tmp); 610 611 /* 612 * Do not show both parent and child node if they have the same 613 * mountpoint; only show the child node. This means the typical, 614 * "key location", map entries are shown in a single line; 615 * the "key mountpoint1 location2 mountpoint2 location2" entries 616 * take multiple lines. 617 */ 618 first_child = TAILQ_FIRST(&n->n_children); 619 if (first_child == NULL || TAILQ_NEXT(first_child, n_next) != NULL || 620 strcmp(path, node_path(first_child)) != 0) { 621 assert(n->n_location == NULL || n->n_map == NULL); 622 printf("%*.s%-*s %s%-*s %-*s # %s map %s at %s:%d\n", 623 indent, "", 624 25 - indent, 625 path, 626 options[0] != '\0' ? "-" : " ", 627 20, 628 options[0] != '\0' ? options : "", 629 20, 630 n->n_location != NULL ? n->n_location : n->n_map != NULL ? n->n_map : "", 631 node_is_direct_map(n) ? "direct" : "indirect", 632 indent == 0 ? "referenced" : "defined", 633 n->n_config_file, n->n_config_line); 634 } 635 636 free(path); 637 free(options); 638 639 TAILQ_FOREACH(child, &n->n_children, n_next) 640 node_print_indent(child, cmdline_options, indent + 2); 641 } 642 643 /* 644 * Recursively print node with all its children. The cmdline_options 645 * argument is used for additional options to be prepended to all the 646 * others - usually those are the options passed by command line. 647 */ 648 void 649 node_print(const struct node *n, const char *cmdline_options) 650 { 651 const struct node *child; 652 653 TAILQ_FOREACH(child, &n->n_children, n_next) 654 node_print_indent(child, cmdline_options, 0); 655 } 656 657 static struct node * 658 node_find_x(struct node *node, const char *path) 659 { 660 struct node *child, *found; 661 char *tmp; 662 size_t tmplen; 663 664 //log_debugx("looking up %s in %s", path, node_path(node)); 665 666 if (!node_is_direct_key(node)) { 667 tmp = node_path(node); 668 tmplen = strlen(tmp); 669 if (strncmp(tmp, path, tmplen) != 0) { 670 free(tmp); 671 return (NULL); 672 } 673 if (path[tmplen] != '/' && path[tmplen] != '\0') { 674 /* 675 * If we have two map entries like 'foo' and 'foobar', make 676 * sure the search for 'foobar' won't match 'foo' instead. 677 */ 678 free(tmp); 679 return (NULL); 680 } 681 free(tmp); 682 } 683 684 TAILQ_FOREACH(child, &node->n_children, n_next) { 685 found = node_find_x(child, path); 686 if (found != NULL) 687 return (found); 688 } 689 690 if (node->n_parent == NULL || node_is_direct_key(node)) 691 return (NULL); 692 693 return (node); 694 } 695 696 struct node * 697 node_find(struct node *root, const char *path) 698 { 699 struct node *node; 700 701 assert(root->n_parent == NULL); 702 703 node = node_find_x(root, path); 704 if (node != NULL) 705 assert(node != root); 706 707 return (node); 708 } 709 710 /* 711 * Canonical form of a map entry looks like this: 712 * 713 * key [-options] [ [/mountpoint] [-options2] location ... ] 714 * 715 * Entries for executable maps are slightly different, as they 716 * lack the 'key' field and are always single-line; the key field 717 * for those maps is taken from 'executable_key' argument. 718 * 719 * We parse it in such a way that a map always has two levels - first 720 * for key, and the second, for the mountpoint. 721 */ 722 static void 723 parse_map_yyin(struct node *parent, const char *map, const char *executable_key) 724 { 725 char *key = NULL, *options = NULL, *mountpoint = NULL, 726 *options2 = NULL, *location = NULL; 727 int ret; 728 struct node *node; 729 730 lineno = 1; 731 732 if (executable_key != NULL) 733 key = checked_strdup(executable_key); 734 735 for (;;) { 736 ret = yylex(); 737 if (ret == 0 || ret == NEWLINE) { 738 /* 739 * In case of executable map, the key is always 740 * non-NULL, even if the map is empty. So, make sure 741 * we don't fail empty maps here. 742 */ 743 if ((key != NULL && executable_key == NULL) || 744 options != NULL) { 745 log_errx(1, "truncated entry at %s, line %d", 746 map, lineno); 747 } 748 if (ret == 0 || executable_key != NULL) { 749 /* 750 * End of file. 751 */ 752 break; 753 } else { 754 key = options = NULL; 755 continue; 756 } 757 } 758 if (key == NULL) { 759 key = checked_strdup(yytext); 760 if (key[0] == '+') { 761 node_new(parent, key, NULL, NULL, map, lineno); 762 key = options = NULL; 763 continue; 764 } 765 continue; 766 } else if (yytext[0] == '-') { 767 if (options != NULL) { 768 log_errx(1, "duplicated options at %s, line %d", 769 map, lineno); 770 } 771 /* 772 * +1 to skip leading "-". 773 */ 774 options = checked_strdup(yytext + 1); 775 continue; 776 } 777 778 /* 779 * We cannot properly handle a situation where the map key 780 * is "/". Ignore such entries. 781 * 782 * XXX: According to Piete Brooks, Linux automounter uses 783 * "/" as a wildcard character in LDAP maps. Perhaps 784 * we should work around this braindamage by substituting 785 * "*" for "/"? 786 */ 787 if (strcmp(key, "/") == 0) { 788 log_warnx("nonsensical map key \"/\" at %s, line %d; " 789 "ignoring map entry ", map, lineno); 790 791 /* 792 * Skip the rest of the entry. 793 */ 794 do { 795 ret = yylex(); 796 } while (ret != 0 && ret != NEWLINE); 797 798 key = options = NULL; 799 continue; 800 } 801 802 //log_debugx("adding map node, %s", key); 803 node = node_new(parent, key, options, NULL, map, lineno); 804 key = options = NULL; 805 806 for (;;) { 807 if (yytext[0] == '/') { 808 if (mountpoint != NULL) { 809 log_errx(1, "duplicated mountpoint " 810 "in %s, line %d", map, lineno); 811 } 812 if (options2 != NULL || location != NULL) { 813 log_errx(1, "mountpoint out of order " 814 "in %s, line %d", map, lineno); 815 } 816 mountpoint = checked_strdup(yytext); 817 goto again; 818 } 819 820 if (yytext[0] == '-') { 821 if (options2 != NULL) { 822 log_errx(1, "duplicated options " 823 "in %s, line %d", map, lineno); 824 } 825 if (location != NULL) { 826 log_errx(1, "options out of order " 827 "in %s, line %d", map, lineno); 828 } 829 options2 = checked_strdup(yytext + 1); 830 goto again; 831 } 832 833 if (location != NULL) { 834 log_errx(1, "too many arguments " 835 "in %s, line %d", map, lineno); 836 } 837 838 /* 839 * If location field starts with colon, e.g. ":/dev/cd0", 840 * then strip it. 841 */ 842 if (yytext[0] == ':') { 843 location = checked_strdup(yytext + 1); 844 if (location[0] == '\0') { 845 log_errx(1, "empty location in %s, " 846 "line %d", map, lineno); 847 } 848 } else { 849 location = checked_strdup(yytext); 850 } 851 852 if (mountpoint == NULL) 853 mountpoint = checked_strdup("/"); 854 if (options2 == NULL) 855 options2 = checked_strdup(""); 856 857 #if 0 858 log_debugx("adding map node, %s %s %s", 859 mountpoint, options2, location); 860 #endif 861 node_new(node, mountpoint, options2, location, 862 map, lineno); 863 mountpoint = options2 = location = NULL; 864 again: 865 ret = yylex(); 866 if (ret == 0 || ret == NEWLINE) { 867 if (mountpoint != NULL || options2 != NULL || 868 location != NULL) { 869 log_errx(1, "truncated entry " 870 "in %s, line %d", map, lineno); 871 } 872 break; 873 } 874 } 875 } 876 } 877 878 /* 879 * Parse output of a special map called without argument. It is a list 880 * of keys, separated by newlines. They can contain whitespace, so use 881 * getline(3) instead of lexer used for maps. 882 */ 883 static void 884 parse_map_keys_yyin(struct node *parent, const char *map) 885 { 886 char *line = NULL, *key; 887 size_t linecap = 0; 888 ssize_t linelen; 889 890 lineno = 1; 891 892 for (;;) { 893 linelen = getline(&line, &linecap, yyin); 894 if (linelen < 0) { 895 /* 896 * End of file. 897 */ 898 break; 899 } 900 if (linelen <= 1) { 901 /* 902 * Empty line, consisting of just the newline. 903 */ 904 continue; 905 } 906 907 /* 908 * "-1" to strip the trailing newline. 909 */ 910 key = strndup(line, linelen - 1); 911 912 log_debugx("adding key \"%s\"", key); 913 node_new(parent, key, NULL, NULL, map, lineno); 914 lineno++; 915 } 916 free(line); 917 } 918 919 static bool 920 file_is_executable(const char *path) 921 { 922 struct stat sb; 923 int error; 924 925 error = stat(path, &sb); 926 if (error != 0) 927 log_err(1, "cannot stat %s", path); 928 if ((sb.st_mode & S_IXUSR) || (sb.st_mode & S_IXGRP) || 929 (sb.st_mode & S_IXOTH)) 930 return (true); 931 return (false); 932 } 933 934 /* 935 * Parse a special map, e.g. "-hosts". 936 */ 937 static void 938 parse_special_map(struct node *parent, const char *map, const char *key) 939 { 940 char *path; 941 int error, ret; 942 943 assert(map[0] == '-'); 944 945 /* 946 * +1 to skip leading "-" in map name. 947 */ 948 ret = asprintf(&path, "%s/special_%s", AUTO_SPECIAL_PREFIX, map + 1); 949 if (ret < 0) 950 log_err(1, "asprintf"); 951 952 yyin = auto_popen(path, key, NULL); 953 assert(yyin != NULL); 954 955 if (key == NULL) { 956 parse_map_keys_yyin(parent, map); 957 } else { 958 parse_map_yyin(parent, map, key); 959 } 960 961 error = auto_pclose(yyin); 962 yyin = NULL; 963 if (error != 0) 964 log_errx(1, "failed to handle special map \"%s\"", map); 965 966 node_expand_includes(parent, false); 967 node_expand_direct_maps(parent); 968 969 free(path); 970 } 971 972 /* 973 * Retrieve and parse map from directory services, e.g. LDAP. 974 * Note that it is different from executable maps, in that 975 * the include script outputs the whole map to standard output 976 * (as opposed to executable maps that only output a single 977 * entry, without the key), and it takes the map name as an 978 * argument, instead of key. 979 */ 980 static void 981 parse_included_map(struct node *parent, const char *map) 982 { 983 int error; 984 985 assert(map[0] != '-'); 986 assert(map[0] != '/'); 987 988 error = access(AUTO_INCLUDE_PATH, F_OK); 989 if (error != 0) { 990 log_errx(1, "directory services not configured;" 991 " %s does not exist", AUTO_INCLUDE_PATH); 992 } 993 994 yyin = auto_popen(AUTO_INCLUDE_PATH, map, NULL); 995 assert(yyin != NULL); 996 997 parse_map_yyin(parent, map, NULL); 998 999 error = auto_pclose(yyin); 1000 yyin = NULL; 1001 if (error != 0) 1002 log_errx(1, "failed to handle remote map \"%s\"", map); 1003 1004 node_expand_includes(parent, false); 1005 node_expand_direct_maps(parent); 1006 } 1007 1008 void 1009 parse_map(struct node *parent, const char *map, const char *key, 1010 bool *wildcards) 1011 { 1012 char *path = NULL; 1013 int error, ret; 1014 bool executable; 1015 1016 assert(map != NULL); 1017 assert(map[0] != '\0'); 1018 1019 log_debugx("parsing map \"%s\"", map); 1020 1021 if (wildcards != NULL) 1022 *wildcards = false; 1023 1024 if (map[0] == '-') { 1025 if (wildcards != NULL) 1026 *wildcards = true; 1027 return (parse_special_map(parent, map, key)); 1028 } 1029 1030 if (map[0] == '/') { 1031 path = checked_strdup(map); 1032 } else { 1033 ret = asprintf(&path, "%s/%s", AUTO_MAP_PREFIX, map); 1034 if (ret < 0) 1035 log_err(1, "asprintf"); 1036 log_debugx("map \"%s\" maps to \"%s\"", map, path); 1037 1038 /* 1039 * See if the file exists. If not, try to obtain the map 1040 * from directory services. 1041 */ 1042 error = access(path, F_OK); 1043 if (error != 0) { 1044 log_debugx("map file \"%s\" does not exist; falling " 1045 "back to directory services", path); 1046 return (parse_included_map(parent, map)); 1047 } 1048 } 1049 1050 executable = file_is_executable(path); 1051 1052 if (executable) { 1053 log_debugx("map \"%s\" is executable", map); 1054 1055 if (wildcards != NULL) 1056 *wildcards = true; 1057 1058 if (key != NULL) { 1059 yyin = auto_popen(path, key, NULL); 1060 } else { 1061 yyin = auto_popen(path, NULL); 1062 } 1063 assert(yyin != NULL); 1064 } else { 1065 yyin = fopen(path, "r"); 1066 if (yyin == NULL) 1067 log_err(1, "unable to open \"%s\"", path); 1068 } 1069 1070 free(path); 1071 path = NULL; 1072 1073 parse_map_yyin(parent, map, executable ? key : NULL); 1074 1075 if (executable) { 1076 error = auto_pclose(yyin); 1077 yyin = NULL; 1078 if (error != 0) { 1079 log_errx(1, "failed to handle executable map \"%s\"", 1080 map); 1081 } 1082 } else { 1083 fclose(yyin); 1084 } 1085 yyin = NULL; 1086 1087 log_debugx("done parsing map \"%s\"", map); 1088 1089 node_expand_includes(parent, false); 1090 node_expand_direct_maps(parent); 1091 } 1092 1093 static void 1094 parse_master_yyin(struct node *root, const char *master) 1095 { 1096 char *mountpoint = NULL, *map = NULL, *options = NULL; 1097 int ret; 1098 1099 /* 1100 * XXX: 1 gives incorrect values; wtf? 1101 */ 1102 lineno = 0; 1103 1104 for (;;) { 1105 ret = yylex(); 1106 if (ret == 0 || ret == NEWLINE) { 1107 if (mountpoint != NULL) { 1108 //log_debugx("adding map for %s", mountpoint); 1109 node_new_map(root, mountpoint, options, map, 1110 master, lineno); 1111 } 1112 if (ret == 0) { 1113 break; 1114 } else { 1115 mountpoint = map = options = NULL; 1116 continue; 1117 } 1118 } 1119 if (mountpoint == NULL) { 1120 mountpoint = checked_strdup(yytext); 1121 } else if (map == NULL) { 1122 map = checked_strdup(yytext); 1123 } else if (options == NULL) { 1124 /* 1125 * +1 to skip leading "-". 1126 */ 1127 options = checked_strdup(yytext + 1); 1128 } else { 1129 log_errx(1, "too many arguments at %s, line %d", 1130 master, lineno); 1131 } 1132 } 1133 } 1134 1135 void 1136 parse_master(struct node *root, const char *master) 1137 { 1138 1139 log_debugx("parsing auto_master file at \"%s\"", master); 1140 1141 yyin = fopen(master, "r"); 1142 if (yyin == NULL) 1143 err(1, "unable to open %s", master); 1144 1145 parse_master_yyin(root, master); 1146 1147 fclose(yyin); 1148 yyin = NULL; 1149 1150 log_debugx("done parsing \"%s\"", master); 1151 1152 node_expand_includes(root, true); 1153 node_expand_direct_maps(root); 1154 } 1155 1156 /* 1157 * Two things daemon(3) does, that we actually also want to do 1158 * when running in foreground, is closing the stdin and chdiring 1159 * to "/". This is what we do here. 1160 */ 1161 void 1162 lesser_daemon(void) 1163 { 1164 int error, fd; 1165 1166 error = chdir("/"); 1167 if (error != 0) 1168 log_warn("chdir"); 1169 1170 fd = open(_PATH_DEVNULL, O_RDWR, 0); 1171 if (fd < 0) { 1172 log_warn("cannot open %s", _PATH_DEVNULL); 1173 return; 1174 } 1175 1176 error = dup2(fd, STDIN_FILENO); 1177 if (error != 0) 1178 log_warn("dup2"); 1179 1180 error = close(fd); 1181 if (error != 0) { 1182 /* Bloody hell. */ 1183 log_warn("close"); 1184 } 1185 } 1186 1187 int 1188 main(int argc, char **argv) 1189 { 1190 char *cmdname; 1191 1192 if (argv[0] == NULL) 1193 log_errx(1, "NULL command name"); 1194 1195 cmdname = basename(argv[0]); 1196 1197 if (strcmp(cmdname, "automount") == 0) 1198 return (main_automount(argc, argv)); 1199 else if (strcmp(cmdname, "automountd") == 0) 1200 main_automountd(argc, argv); 1201 else if (strcmp(cmdname, "autounmountd") == 0) 1202 main_autounmountd(argc, argv); 1203 else 1204 log_errx(1, "binary name should be either \"automount\", " 1205 "\"automountd\", or \"autounmountd\""); 1206 } 1207