2 * Copyright (c) 2014 The FreeBSD Foundation
5 * This software was developed by Edward Tomasz Napierala under sponsorship
6 * from the FreeBSD Foundation.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 #include <sys/types.h>
34 #include <sys/ioctl.h>
35 #include <sys/param.h>
36 #include <sys/linker.h>
37 #include <sys/mount.h>
38 #include <sys/socket.h>
41 #include <sys/utsname.h>
60 #include "autofs_ioctl.h"
66 extern int yylex(void);
68 static void parse_master_yyin(struct node *root, const char *master);
69 static void parse_map_yyin(struct node *parent, const char *map,
70 const char *executable_key);
73 checked_strdup(const char *s)
86 * Take two pointers to strings, concatenate the contents with "/" in the
87 * middle, make the first pointer point to the result, the second pointer
88 * to NULL, and free the old strings.
90 * Concatenate pathnames, basically.
93 concat(char **p1, char **p2)
102 *p1 = checked_strdup("");
105 *p2 = checked_strdup("");
107 ret = asprintf(&path, "%s/%s", *p1, *p2);
109 log_err(1, "asprintf");
122 * Concatenate two strings, inserting separator between them, unless not needed.
124 * This function is very convenient to use when you do not care about freeing
125 * memory - which is okay here, because we are a short running process.
128 separated_concat(const char *s1, const char *s2, char separator)
136 if (s1[0] == '\0' || s2[0] == '\0' ||
137 s1[strlen(s1) - 1] == separator || s2[0] == separator) {
138 ret = asprintf(&result, "%s%s", s1, s2);
140 ret = asprintf(&result, "%s%c%s", s1, separator, s2);
143 log_err(1, "asprintf");
145 //log_debugx("separated_concat: got %s and %s, returning %s", s1, s2, result);
151 create_directory(const char *path)
153 char *component, *copy, *tofree, *partial;
156 assert(path[0] == '/');
159 * +1 to skip the leading slash.
161 copy = tofree = checked_strdup(path + 1);
165 component = strsep(©, "/");
166 if (component == NULL)
168 concat(&partial, &component);
169 //log_debugx("checking \"%s\" for existence", partial);
170 error = access(partial, F_OK);
174 log_err(1, "cannot access %s", partial);
175 log_debugx("directory %s does not exist, creating",
177 error = mkdir(partial, 0755);
179 log_err(1, "cannot create %s", partial);
190 n = calloc(1, sizeof(*n));
192 log_err(1, "calloc");
194 n->n_key = checked_strdup("/");
195 n->n_options = checked_strdup("");
197 TAILQ_INIT(&n->n_children);
203 node_new(struct node *parent, char *key, char *options, char *location,
204 const char *config_file, int config_line)
208 n = calloc(1, sizeof(*n));
210 log_err(1, "calloc");
212 TAILQ_INIT(&n->n_children);
216 n->n_options = options;
218 n->n_options = strdup("");
219 n->n_location = location;
220 assert(config_file != NULL);
221 n->n_config_file = config_file;
222 assert(config_line >= 0);
223 n->n_config_line = config_line;
225 assert(parent != NULL);
226 n->n_parent = parent;
227 TAILQ_INSERT_TAIL(&parent->n_children, n, n_next);
233 node_new_map(struct node *parent, char *key, char *options, char *map,
234 const char *config_file, int config_line)
238 n = calloc(1, sizeof(*n));
240 log_err(1, "calloc");
242 TAILQ_INIT(&n->n_children);
246 n->n_options = options;
248 n->n_options = strdup("");
250 assert(config_file != NULL);
251 n->n_config_file = config_file;
252 assert(config_line >= 0);
253 n->n_config_line = config_line;
255 assert(parent != NULL);
256 n->n_parent = parent;
257 TAILQ_INSERT_TAIL(&parent->n_children, n, n_next);
263 node_duplicate(const struct node *o, struct node *parent)
265 const struct node *child;
269 parent = o->n_parent;
271 n = node_new(parent, o->n_key, o->n_options, o->n_location,
272 o->n_config_file, o->n_config_line);
274 TAILQ_FOREACH(child, &o->n_children, n_next)
275 node_duplicate(child, n);
281 node_delete(struct node *n)
283 struct node *child, *tmp;
287 TAILQ_FOREACH_SAFE(child, &n->n_children, n_next, tmp)
290 if (n->n_parent != NULL)
291 TAILQ_REMOVE(&n->n_parent->n_children, n, n_next);
297 * Move (reparent) node 'n' to make it sibling of 'previous', placed
301 node_move_after(struct node *n, struct node *previous)
304 TAILQ_REMOVE(&n->n_parent->n_children, n, n_next);
305 n->n_parent = previous->n_parent;
306 TAILQ_INSERT_AFTER(&previous->n_parent->n_children, previous, n, n_next);
310 node_expand_includes(struct node *root, bool is_master)
312 struct node *n, *n2, *tmp, *tmp2, *tmproot;
315 TAILQ_FOREACH_SAFE(n, &root->n_children, n_next, tmp) {
316 if (n->n_key[0] != '+')
319 error = access(AUTO_INCLUDE_PATH, F_OK);
321 log_errx(1, "directory services not configured; "
322 "%s does not exist", AUTO_INCLUDE_PATH);
326 * "+1" to skip leading "+".
328 yyin = auto_popen(AUTO_INCLUDE_PATH, n->n_key + 1, NULL);
329 assert(yyin != NULL);
331 tmproot = node_new_root();
333 parse_master_yyin(tmproot, n->n_key);
335 parse_map_yyin(tmproot, n->n_key, NULL);
337 error = auto_pclose(yyin);
340 log_errx(1, "failed to handle include \"%s\"",
345 * Entries to be included are now in tmproot. We need to merge
346 * them with the rest, preserving their place and ordering.
348 TAILQ_FOREACH_REVERSE_SAFE(n2,
349 &tmproot->n_children, nodehead, n_next, tmp2) {
350 node_move_after(n2, n);
354 node_delete(tmproot);
359 expand_ampersand(char *string, const char *key)
362 int i, ret, before_len = 0;
363 bool backslashed = false;
365 assert(key[0] != '\0');
367 expanded = checked_strdup(string);
369 for (i = 0; string[i] != '\0'; i++) {
371 if (c == '\\' && backslashed == false) {
384 * The 'before_len' variable contains the number
385 * of characters before the '&'.
388 //assert(i + 1 < (int)strlen(string));
390 ret = asprintf(&expanded, "%.*s%s%s",
391 before_len, string, key, string + before_len + 1);
393 log_err(1, "asprintf");
395 //log_debugx("\"%s\" expanded with key \"%s\" to \"%s\"",
396 // string, key, expanded);
399 * Figure out where to start searching for next variable.
402 i = before_len + strlen(key);
404 //assert(i < (int)strlen(string));
411 * Expand "&" in n_location. If the key is NULL, try to use
412 * key from map entries themselves. Keep in mind that maps
413 * consist of tho levels of node structures, the key is one
416 * Variant with NULL key is for "automount -LL".
419 node_expand_ampersand(struct node *n, const char *key)
423 if (n->n_location != NULL) {
425 if (n->n_parent != NULL &&
426 strcmp(n->n_parent->n_key, "*") != 0) {
427 n->n_location = expand_ampersand(n->n_location,
431 n->n_location = expand_ampersand(n->n_location, key);
435 TAILQ_FOREACH(child, &n->n_children, n_next)
436 node_expand_ampersand(child, key);
440 * Expand "*" in n_key.
443 node_expand_wildcard(struct node *n, const char *key)
445 struct node *child, *expanded;
449 if (strcmp(n->n_key, "*") == 0) {
450 expanded = node_duplicate(n, NULL);
451 expanded->n_key = checked_strdup(key);
452 node_move_after(expanded, n);
455 TAILQ_FOREACH(child, &n->n_children, n_next)
456 node_expand_wildcard(child, key);
460 node_expand_defined(struct node *n)
463 int error, cumulated_error = 0;
465 if (n->n_location != NULL) {
466 n->n_location = defined_expand(n->n_location);
467 if (n->n_location == NULL) {
468 log_warnx("failed to expand location for %s",
474 TAILQ_FOREACH(child, &n->n_children, n_next) {
475 error = node_expand_defined(child);
476 if (error != 0 && cumulated_error == 0)
477 cumulated_error = error;
480 return (cumulated_error);
484 node_is_direct_map(const struct node *n)
488 assert(n->n_parent != NULL);
489 if (n->n_parent->n_parent == NULL)
494 assert(n->n_key != NULL);
495 if (strcmp(n->n_key, "/-") != 0)
502 node_expand_maps(struct node *n, bool indirect)
504 struct node *child, *tmp;
506 TAILQ_FOREACH_SAFE(child, &n->n_children, n_next, tmp) {
507 if (node_is_direct_map(child)) {
511 if (indirect == false)
516 * This is the first-level map node; the one that contains
517 * the key and subnodes with mountpoints and actual map names.
519 if (child->n_map == NULL)
523 log_debugx("map \"%s\" is an indirect map, parsing",
526 log_debugx("map \"%s\" is a direct map, parsing",
529 parse_map(child, child->n_map, NULL);
534 node_expand_direct_maps(struct node *n)
537 node_expand_maps(n, false);
541 node_expand_indirect_maps(struct node *n)
544 node_expand_maps(n, true);
548 node_path_x(const struct node *n, char *x)
553 if (n->n_parent == NULL)
557 * Return "/-" for direct maps only if we were asked for path
558 * to the "/-" node itself, not to any of its subnodes.
560 if (n->n_parent->n_parent == NULL &&
561 strcmp(n->n_key, "/-") == 0 &&
566 path = separated_concat(n->n_key, x, '/');
570 * Strip trailing slash.
574 if (path[len - 1] == '/')
575 path[len - 1] = '\0';
577 return (node_path_x(n->n_parent, path));
581 * Return full path for node, consisting of concatenated
582 * paths of node itself and all its parents, up to the root.
585 node_path(const struct node *n)
588 return (node_path_x(n, checked_strdup("")));
592 node_options_x(const struct node *n, char *x)
596 options = separated_concat(x, n->n_options, ',');
597 if (n->n_parent == NULL)
600 return (node_options_x(n->n_parent, options));
604 * Return options for node, consisting of concatenated
605 * options from the node itself and all its parents,
609 node_options(const struct node *n)
612 return (node_options_x(n, checked_strdup("")));
616 node_print_indent(const struct node *n, int indent)
618 const struct node *child, *first_child;
619 char *path, *options;
622 options = node_options(n);
625 * Do not show both parent and child node if they have the same
626 * mountpoint; only show the child node. This means the typical,
627 * "key location", map entries are shown in a single line;
628 * the "key mountpoint1 location2 mountpoint2 location2" entries
629 * take multiple lines.
631 first_child = TAILQ_FIRST(&n->n_children);
632 if (first_child == NULL || TAILQ_NEXT(first_child, n_next) != NULL ||
633 strcmp(path, node_path(first_child)) != 0) {
634 assert(n->n_location == NULL || n->n_map == NULL);
635 printf("%*.s%-*s %s%-*s %-*s # %s map %s at %s:%d\n",
639 options[0] != '\0' ? "-" : " ",
641 options[0] != '\0' ? options : "",
643 n->n_location != NULL ? n->n_location : n->n_map != NULL ? n->n_map : "",
644 node_is_direct_map(n) ? "direct" : "indirect",
645 indent == 0 ? "referenced" : "defined",
646 n->n_config_file, n->n_config_line);
652 TAILQ_FOREACH(child, &n->n_children, n_next)
653 node_print_indent(child, indent + 2);
657 node_print(const struct node *n)
659 const struct node *child;
661 TAILQ_FOREACH(child, &n->n_children, n_next)
662 node_print_indent(child, 0);
666 node_find(struct node *node, const char *path)
668 struct node *child, *found;
671 //log_debugx("looking up %s in %s", path, node->n_key);
673 tmp = node_path(node);
674 if (strncmp(tmp, path, strlen(tmp)) != 0) {
680 TAILQ_FOREACH(child, &node->n_children, n_next) {
681 found = node_find(child, path);
690 * Canonical form of a map entry looks like this:
692 * key [-options] [ [/mountpoint] [-options2] location ... ]
694 * Entries for executable maps are slightly different, as they
695 * lack the 'key' field and are always single-line; the key field
696 * for those maps is taken from 'executable_key' argument.
698 * We parse it in such a way that a map always has two levels - first
699 * for key, and the second, for the mountpoint.
702 parse_map_yyin(struct node *parent, const char *map, const char *executable_key)
704 char *key = NULL, *options = NULL, *mountpoint = NULL,
705 *options2 = NULL, *location = NULL;
711 if (executable_key != NULL)
712 key = checked_strdup(executable_key);
716 if (ret == 0 || ret == NEWLINE) {
717 if (key != NULL || options != NULL) {
718 log_errx(1, "truncated entry at %s, line %d",
721 if (ret == 0 || executable_key != NULL) {
727 key = options = NULL;
732 key = checked_strdup(yytext);
734 node_new(parent, key, NULL, NULL, map, lineno);
735 key = options = NULL;
739 } else if (yytext[0] == '-') {
740 if (options != NULL) {
741 log_errx(1, "duplicated options at %s, line %d",
745 * +1 to skip leading "-".
747 options = checked_strdup(yytext + 1);
752 * We cannot properly handle a situation where the map key
753 * is "/". Ignore such entries.
755 * XXX: According to Piete Brooks, Linux automounter uses
756 * "/" as a wildcard character in LDAP maps. Perhaps
757 * we should work around this braindamage by substituting
760 if (strcmp(key, "/") == 0) {
761 log_warnx("nonsensical map key \"/\" at %s, line %d; "
762 "ignoring map entry ", map, lineno);
765 * Skip the rest of the entry.
769 } while (ret != 0 && ret != NEWLINE);
771 key = options = NULL;
775 //log_debugx("adding map node, %s", key);
776 node = node_new(parent, key, options, NULL, map, lineno);
777 key = options = NULL;
780 if (yytext[0] == '/') {
781 if (mountpoint != NULL) {
782 log_errx(1, "duplicated mountpoint "
783 "in %s, line %d", map, lineno);
785 if (options2 != NULL || location != NULL) {
786 log_errx(1, "mountpoint out of order "
787 "in %s, line %d", map, lineno);
789 mountpoint = checked_strdup(yytext);
793 if (yytext[0] == '-') {
794 if (options2 != NULL) {
795 log_errx(1, "duplicated options "
796 "in %s, line %d", map, lineno);
798 if (location != NULL) {
799 log_errx(1, "options out of order "
800 "in %s, line %d", map, lineno);
802 options2 = checked_strdup(yytext + 1);
806 if (location != NULL) {
807 log_errx(1, "too many arguments "
808 "in %s, line %d", map, lineno);
812 * If location field starts with colon, e.g. ":/dev/cd0",
815 if (yytext[0] == ':') {
816 location = checked_strdup(yytext + 1);
817 if (location[0] == '\0') {
818 log_errx(1, "empty location in %s, "
819 "line %d", map, lineno);
822 location = checked_strdup(yytext);
825 if (mountpoint == NULL)
826 mountpoint = checked_strdup("/");
827 if (options2 == NULL)
828 options2 = checked_strdup("");
831 log_debugx("adding map node, %s %s %s",
832 mountpoint, options2, location);
834 node_new(node, mountpoint, options2, location,
836 mountpoint = options2 = location = NULL;
839 if (ret == 0 || ret == NEWLINE) {
840 if (mountpoint != NULL || options2 != NULL ||
842 log_errx(1, "truncated entry "
843 "in %s, line %d", map, lineno);
852 file_is_executable(const char *path)
857 error = stat(path, &sb);
859 log_err(1, "cannot stat %s", path);
860 if ((sb.st_mode & S_IXUSR) || (sb.st_mode & S_IXGRP) ||
861 (sb.st_mode & S_IXOTH))
867 * Parse a special map, e.g. "-hosts".
870 parse_special_map(struct node *parent, const char *map, const char *key)
875 assert(map[0] == '-');
878 log_debugx("skipping map %s due to forced -nobrowse", map);
883 * +1 to skip leading "-" in map name.
885 ret = asprintf(&path, "%s/special_%s", AUTO_SPECIAL_PREFIX, map + 1);
887 log_err(1, "asprintf");
889 yyin = auto_popen(path, key, NULL);
890 assert(yyin != NULL);
892 parse_map_yyin(parent, map, key);
894 error = auto_pclose(yyin);
897 log_errx(1, "failed to handle special map \"%s\"", map);
899 node_expand_includes(parent, false);
900 node_expand_direct_maps(parent);
906 * Retrieve and parse map from directory services, e.g. LDAP.
907 * Note that it is different from executable maps, in that
908 * the include script outputs the whole map to standard output
909 * (as opposed to executable maps that only output a single
910 * entry, without the key), and it takes the map name as an
911 * argument, instead of key.
914 parse_included_map(struct node *parent, const char *map)
918 assert(map[0] != '-');
919 assert(map[0] != '/');
921 error = access(AUTO_INCLUDE_PATH, F_OK);
923 log_errx(1, "directory services not configured;"
924 " %s does not exist", AUTO_INCLUDE_PATH);
927 yyin = auto_popen(AUTO_INCLUDE_PATH, map, NULL);
928 assert(yyin != NULL);
930 parse_map_yyin(parent, map, NULL);
932 error = auto_pclose(yyin);
935 log_errx(1, "failed to handle remote map \"%s\"", map);
937 node_expand_includes(parent, false);
938 node_expand_direct_maps(parent);
942 parse_map(struct node *parent, const char *map, const char *key)
949 assert(map[0] != '\0');
951 log_debugx("parsing map \"%s\"", map);
954 return (parse_special_map(parent, map, key));
957 path = checked_strdup(map);
959 ret = asprintf(&path, "%s/%s", AUTO_MAP_PREFIX, map);
961 log_err(1, "asprintf");
962 log_debugx("map \"%s\" maps to \"%s\"", map, path);
965 * See if the file exists. If not, try to obtain the map
966 * from directory services.
968 error = access(path, F_OK);
970 log_debugx("map file \"%s\" does not exist; falling "
971 "back to directory services", path);
972 return (parse_included_map(parent, map));
976 executable = file_is_executable(path);
979 log_debugx("map \"%s\" is executable", map);
982 yyin = auto_popen(path, key, NULL);
984 yyin = auto_popen(path, NULL);
986 assert(yyin != NULL);
988 yyin = fopen(path, "r");
990 log_err(1, "unable to open \"%s\"", path);
996 parse_map_yyin(parent, map, executable ? key : NULL);
999 error = auto_pclose(yyin);
1002 log_errx(1, "failed to handle executable map \"%s\"",
1010 log_debugx("done parsing map \"%s\"", map);
1012 node_expand_includes(parent, false);
1013 node_expand_direct_maps(parent);
1017 parse_master_yyin(struct node *root, const char *master)
1019 char *mountpoint = NULL, *map = NULL, *options = NULL;
1023 * XXX: 1 gives incorrect values; wtf?
1029 if (ret == 0 || ret == NEWLINE) {
1030 if (mountpoint != NULL) {
1031 //log_debugx("adding map for %s", mountpoint);
1032 node_new_map(root, mountpoint, options, map,
1038 mountpoint = map = options = NULL;
1042 if (mountpoint == NULL) {
1043 mountpoint = checked_strdup(yytext);
1044 } else if (map == NULL) {
1045 map = checked_strdup(yytext);
1046 } else if (options == NULL) {
1048 * +1 to skip leading "-".
1050 options = checked_strdup(yytext + 1);
1052 log_errx(1, "too many arguments at %s, line %d",
1059 parse_master(struct node *root, const char *master)
1062 log_debugx("parsing auto_master file at \"%s\"", master);
1064 yyin = fopen(master, "r");
1066 err(1, "unable to open %s", master);
1068 parse_master_yyin(root, master);
1073 log_debugx("done parsing \"%s\"", master);
1075 node_expand_includes(root, true);
1076 node_expand_direct_maps(root);
1080 * Two things daemon(3) does, that we actually also want to do
1081 * when running in foreground, is closing the stdin and chdiring
1082 * to "/". This is what we do here.
1093 fd = open(_PATH_DEVNULL, O_RDWR, 0);
1095 log_warn("cannot open %s", _PATH_DEVNULL);
1099 error = dup2(fd, STDIN_FILENO);
1111 main(int argc, char **argv)
1115 if (argv[0] == NULL)
1116 log_errx(1, "NULL command name");
1118 cmdname = basename(argv[0]);
1120 if (strcmp(cmdname, "automount") == 0)
1121 return (main_automount(argc, argv));
1122 else if (strcmp(cmdname, "automountd") == 0)
1123 return (main_automountd(argc, argv));
1124 else if (strcmp(cmdname, "autounmountd") == 0)
1125 return (main_autounmountd(argc, argv));
1127 log_errx(1, "binary name should be either \"automount\", "
1128 "\"automountd\", or \"autounmountd\"");