2 * Copyright (c) 2016 The DragonFly Project
3 * Copyright (c) 2014 The FreeBSD Foundation
6 * This software was developed by Edward Tomasz Napierala under sponsorship
7 * from the FreeBSD Foundation.
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
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.
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
30 * $FreeBSD: head/usr.sbin/autofs/common.c 303527 2016-07-30 01:10:05Z bapt $
33 #include <sys/types.h>
45 #include <vfs/autofs/autofs_ioctl.h>
51 extern int yylex(void);
53 static void parse_master_yyin(struct node *root, const char *master);
54 static void parse_map_yyin(struct node *parent, const char *map,
55 const char *executable_key);
58 checked_strdup(const char *s)
71 * Concatenate two strings, inserting separator between them, unless not needed.
74 concat(const char *s1, char separator, const char *s2)
88 s1last = s1[strlen(s1) - 1];
92 if (s1last == separator && s2first == separator) {
94 * If s1 ends with the separator and s2 begins with
95 * it - skip the latter; otherwise concatenating "/"
96 * and "/foo" would end up returning "//foo".
98 ret = asprintf(&result, "%s%s", s1, s2 + 1);
99 } else if (s1last == separator || s2first == separator ||
100 s1[0] == '\0' || s2[0] == '\0') {
101 ret = asprintf(&result, "%s%s", s1, s2);
103 ret = asprintf(&result, "%s%c%s", s1, separator, s2);
106 log_err(1, "asprintf");
108 //log_debugx("%s: got %s and %s, returning %s", __func__, s1, s2, result);
114 create_directory(const char *path)
116 char *component, *copy, *tofree, *partial, *tmp;
119 assert(path[0] == '/');
122 * +1 to skip the leading slash.
124 copy = tofree = checked_strdup(path + 1);
126 partial = checked_strdup("");
128 component = strsep(©, "/");
129 if (component == NULL)
131 tmp = concat(partial, '/', component);
134 //log_debugx("creating \"%s\"", partial);
135 error = mkdir(partial, 0755);
136 if (error != 0 && errno != EEXIST) {
137 log_warn("cannot create %s", partial);
150 n = calloc(1, sizeof(*n));
152 log_err(1, "calloc");
154 n->n_key = checked_strdup("/");
155 n->n_options = checked_strdup("");
157 TAILQ_INIT(&n->n_children);
163 node_new(struct node *parent, char *key, char *options, char *location,
164 const char *config_file, int config_line)
168 n = calloc(1, sizeof(*n));
170 log_err(1, "calloc");
172 TAILQ_INIT(&n->n_children);
174 assert(key[0] != '\0');
177 n->n_options = options;
179 n->n_options = strdup("");
180 n->n_location = location;
181 assert(config_file != NULL);
182 n->n_config_file = config_file;
183 assert(config_line >= 0);
184 n->n_config_line = config_line;
186 assert(parent != NULL);
187 n->n_parent = parent;
188 TAILQ_INSERT_TAIL(&parent->n_children, n, n_next);
194 node_new_map(struct node *parent, char *key, char *options, char *map,
195 const char *config_file, int config_line)
199 n = calloc(1, sizeof(*n));
201 log_err(1, "calloc");
203 TAILQ_INIT(&n->n_children);
205 assert(key[0] != '\0');
208 n->n_options = options;
210 n->n_options = strdup("");
212 assert(config_file != NULL);
213 n->n_config_file = config_file;
214 assert(config_line >= 0);
215 n->n_config_line = config_line;
217 assert(parent != NULL);
218 n->n_parent = parent;
219 TAILQ_INSERT_TAIL(&parent->n_children, n, n_next);
225 node_duplicate(const struct node *o, struct node *parent)
227 const struct node *child;
231 parent = o->n_parent;
233 n = node_new(parent, o->n_key, o->n_options, o->n_location,
234 o->n_config_file, o->n_config_line);
236 TAILQ_FOREACH(child, &o->n_children, n_next)
237 node_duplicate(child, n);
243 node_delete(struct node *n)
245 struct node *child, *tmp;
249 TAILQ_FOREACH_SAFE(child, &n->n_children, n_next, tmp)
252 if (n->n_parent != NULL)
253 TAILQ_REMOVE(&n->n_parent->n_children, n, n_next);
259 * Move (reparent) node 'n' to make it sibling of 'previous', placed
263 node_move_after(struct node *n, struct node *previous)
266 TAILQ_REMOVE(&n->n_parent->n_children, n, n_next);
267 n->n_parent = previous->n_parent;
268 TAILQ_INSERT_AFTER(&previous->n_parent->n_children, previous, n, n_next);
272 node_expand_includes(struct node *root, bool is_master)
274 struct node *n, *n2, *tmp, *tmp2, *tmproot;
277 TAILQ_FOREACH_SAFE(n, &root->n_children, n_next, tmp) {
278 if (n->n_key[0] != '+')
281 error = access(AUTO_INCLUDE_PATH, F_OK);
283 log_errx(1, "directory services not configured; "
284 "%s does not exist", AUTO_INCLUDE_PATH);
288 * "+1" to skip leading "+".
290 yyin = auto_popen(AUTO_INCLUDE_PATH, n->n_key + 1, NULL);
291 assert(yyin != NULL);
293 tmproot = node_new_root();
295 parse_master_yyin(tmproot, n->n_key);
297 parse_map_yyin(tmproot, n->n_key, NULL);
299 error = auto_pclose(yyin);
302 log_errx(1, "failed to handle include \"%s\"",
307 * Entries to be included are now in tmproot. We need to merge
308 * them with the rest, preserving their place and ordering.
310 TAILQ_FOREACH_REVERSE_SAFE(n2,
311 &tmproot->n_children, nodehead, n_next, tmp2) {
312 node_move_after(n2, n);
316 node_delete(tmproot);
321 expand_ampersand(char *string, const char *key)
324 int i, ret, before_len = 0;
325 bool backslashed = false;
327 assert(key[0] != '\0');
329 expanded = checked_strdup(string);
331 for (i = 0; string[i] != '\0'; i++) {
333 if (c == '\\' && backslashed == false) {
346 * The 'before_len' variable contains the number
347 * of characters before the '&'.
350 //assert(i + 1 < (int)strlen(string));
352 ret = asprintf(&expanded, "%.*s%s%s",
353 before_len, string, key, string + before_len + 1);
355 log_err(1, "asprintf");
357 //log_debugx("\"%s\" expanded with key \"%s\" to \"%s\"",
358 // string, key, expanded);
361 * Figure out where to start searching for next variable.
364 i = before_len + strlen(key);
366 //assert(i < (int)strlen(string));
373 * Expand "&" in n_location. If the key is NULL, try to use
374 * key from map entries themselves. Keep in mind that maps
375 * consist of tho levels of node structures, the key is one
378 * Variant with NULL key is for "automount -LL".
381 node_expand_ampersand(struct node *n, const char *key)
385 if (n->n_location != NULL) {
387 if (n->n_parent != NULL &&
388 strcmp(n->n_parent->n_key, "*") != 0) {
389 n->n_location = expand_ampersand(n->n_location,
393 n->n_location = expand_ampersand(n->n_location, key);
397 TAILQ_FOREACH(child, &n->n_children, n_next)
398 node_expand_ampersand(child, key);
402 * Expand "*" in n_key.
405 node_expand_wildcard(struct node *n, const char *key)
407 struct node *child, *expanded;
411 if (strcmp(n->n_key, "*") == 0) {
412 expanded = node_duplicate(n, NULL);
413 expanded->n_key = checked_strdup(key);
414 node_move_after(expanded, n);
417 TAILQ_FOREACH(child, &n->n_children, n_next)
418 node_expand_wildcard(child, key);
422 node_expand_defined(struct node *n)
425 int error, cumulated_error = 0;
427 if (n->n_location != NULL) {
428 n->n_location = defined_expand(n->n_location);
429 if (n->n_location == NULL) {
430 log_warnx("failed to expand location for %s",
436 TAILQ_FOREACH(child, &n->n_children, n_next) {
437 error = node_expand_defined(child);
438 if (error != 0 && cumulated_error == 0)
439 cumulated_error = error;
442 return (cumulated_error);
446 node_is_direct_key(const struct node *n)
449 if (n->n_parent != NULL && n->n_parent->n_parent == NULL &&
450 strcmp(n->n_key, "/-") == 0) {
458 node_is_direct_map(const struct node *n)
462 assert(n->n_parent != NULL);
463 if (n->n_parent->n_parent == NULL)
468 return (node_is_direct_key(n));
472 node_has_wildcards(const struct node *n)
474 const struct node *child;
476 TAILQ_FOREACH(child, &n->n_children, n_next) {
477 if (strcmp(child->n_key, "*") == 0)
485 node_expand_maps(struct node *n, bool indirect)
487 struct node *child, *tmp;
489 TAILQ_FOREACH_SAFE(child, &n->n_children, n_next, tmp) {
490 if (node_is_direct_map(child)) {
494 if (indirect == false)
499 * This is the first-level map node; the one that contains
500 * the key and subnodes with mountpoints and actual map names.
502 if (child->n_map == NULL)
506 log_debugx("map \"%s\" is an indirect map, parsing",
509 log_debugx("map \"%s\" is a direct map, parsing",
512 parse_map(child, child->n_map, NULL, NULL);
517 node_expand_direct_maps(struct node *n)
520 node_expand_maps(n, false);
524 node_expand_indirect_maps(struct node *n)
527 node_expand_maps(n, true);
531 node_path_x(const struct node *n, char *x)
535 if (n->n_parent == NULL)
539 * Return "/-" for direct maps only if we were asked for path
540 * to the "/-" node itself, not to any of its subnodes.
542 if (node_is_direct_key(n) && x[0] != '\0')
545 assert(n->n_key[0] != '\0');
546 path = concat(n->n_key, '/', x);
549 return (node_path_x(n->n_parent, path));
553 * Return full path for node, consisting of concatenated
554 * paths of node itself and all its parents, up to the root.
557 node_path(const struct node *n)
562 path = node_path_x(n, checked_strdup(""));
565 * Strip trailing slash, unless the whole path is "/".
568 if (len > 1 && path[len - 1] == '/')
569 path[len - 1] = '\0';
575 node_options_x(const struct node *n, char *x)
582 options = concat(x, ',', n->n_options);
585 return (node_options_x(n->n_parent, options));
589 * Return options for node, consisting of concatenated
590 * options from the node itself and all its parents,
594 node_options(const struct node *n)
597 return (node_options_x(n, checked_strdup("")));
601 node_print_indent(const struct node *n, const char *cmdline_options,
604 const struct node *child, *first_child;
605 char *path, *options, *tmp;
608 tmp = node_options(n);
609 options = concat(cmdline_options, ',', tmp);
613 * Do not show both parent and child node if they have the same
614 * mountpoint; only show the child node. This means the typical,
615 * "key location", map entries are shown in a single line;
616 * the "key mountpoint1 location2 mountpoint2 location2" entries
617 * take multiple lines.
619 first_child = TAILQ_FIRST(&n->n_children);
620 if (first_child == NULL || TAILQ_NEXT(first_child, n_next) != NULL ||
621 strcmp(path, node_path(first_child)) != 0) {
622 assert(n->n_location == NULL || n->n_map == NULL);
623 printf("%*.s%-*s %s%-*s %-*s # %s map %s at %s:%d\n",
627 options[0] != '\0' ? "-" : " ",
629 options[0] != '\0' ? options : "",
631 n->n_location != NULL ? n->n_location : n->n_map != NULL ? n->n_map : "",
632 node_is_direct_map(n) ? "direct" : "indirect",
633 indent == 0 ? "referenced" : "defined",
634 n->n_config_file, n->n_config_line);
640 TAILQ_FOREACH(child, &n->n_children, n_next)
641 node_print_indent(child, cmdline_options, indent + 2);
645 * Recursively print node with all its children. The cmdline_options
646 * argument is used for additional options to be prepended to all the
647 * others - usually those are the options passed by command line.
650 node_print(const struct node *n, const char *cmdline_options)
652 const struct node *child;
654 TAILQ_FOREACH(child, &n->n_children, n_next)
655 node_print_indent(child, cmdline_options, 0);
659 node_find_x(struct node *node, const char *path)
661 struct node *child, *found;
665 //log_debugx("looking up %s in %s", path, node_path(node));
667 if (!node_is_direct_key(node)) {
668 tmp = node_path(node);
669 tmplen = strlen(tmp);
670 if (strncmp(tmp, path, tmplen) != 0) {
674 if (path[tmplen] != '/' && path[tmplen] != '\0') {
676 * If we have two map entries like 'foo' and 'foobar', make
677 * sure the search for 'foobar' won't match 'foo' instead.
685 TAILQ_FOREACH(child, &node->n_children, n_next) {
686 found = node_find_x(child, path);
691 if (node->n_parent == NULL || node_is_direct_key(node))
698 node_find(struct node *root, const char *path)
702 assert(root->n_parent == NULL);
704 node = node_find_x(root, path);
706 assert(node != root);
712 * Canonical form of a map entry looks like this:
714 * key [-options] [ [/mountpoint] [-options2] location ... ]
716 * Entries for executable maps are slightly different, as they
717 * lack the 'key' field and are always single-line; the key field
718 * for those maps is taken from 'executable_key' argument.
720 * We parse it in such a way that a map always has two levels - first
721 * for key, and the second, for the mountpoint.
724 parse_map_yyin(struct node *parent, const char *map, const char *executable_key)
726 char *key = NULL, *options = NULL, *mountpoint = NULL,
727 *options2 = NULL, *location = NULL;
733 if (executable_key != NULL)
734 key = checked_strdup(executable_key);
738 if (ret == 0 || ret == NEWLINE) {
740 * In case of executable map, the key is always
741 * non-NULL, even if the map is empty. So, make sure
742 * we don't fail empty maps here.
744 if ((key != NULL && executable_key == NULL) ||
746 log_errx(1, "truncated entry at %s, line %d",
749 if (ret == 0 || executable_key != NULL) {
755 key = options = NULL;
760 key = checked_strdup(yytext);
762 node_new(parent, key, NULL, NULL, map, lineno);
763 key = options = NULL;
767 } else if (yytext[0] == '-') {
768 if (options != NULL) {
769 log_errx(1, "duplicated options at %s, line %d",
773 * +1 to skip leading "-".
775 options = checked_strdup(yytext + 1);
780 * We cannot properly handle a situation where the map key
781 * is "/". Ignore such entries.
783 * XXX: According to Piete Brooks, Linux automounter uses
784 * "/" as a wildcard character in LDAP maps. Perhaps
785 * we should work around this braindamage by substituting
788 if (strcmp(key, "/") == 0) {
789 log_warnx("nonsensical map key \"/\" at %s, line %d; "
790 "ignoring map entry ", map, lineno);
793 * Skip the rest of the entry.
797 } while (ret != 0 && ret != NEWLINE);
799 key = options = NULL;
803 //log_debugx("adding map node, %s", key);
804 node = node_new(parent, key, options, NULL, map, lineno);
805 key = options = NULL;
808 if (yytext[0] == '/') {
809 if (mountpoint != NULL) {
810 log_errx(1, "duplicated mountpoint "
811 "in %s, line %d", map, lineno);
813 if (options2 != NULL || location != NULL) {
814 log_errx(1, "mountpoint out of order "
815 "in %s, line %d", map, lineno);
817 mountpoint = checked_strdup(yytext);
821 if (yytext[0] == '-') {
822 if (options2 != NULL) {
823 log_errx(1, "duplicated options "
824 "in %s, line %d", map, lineno);
826 if (location != NULL) {
827 log_errx(1, "options out of order "
828 "in %s, line %d", map, lineno);
830 options2 = checked_strdup(yytext + 1);
834 if (location != NULL) {
835 log_errx(1, "too many arguments "
836 "in %s, line %d", map, lineno);
840 * If location field starts with colon, e.g. ":/dev/cd0",
843 if (yytext[0] == ':') {
844 location = checked_strdup(yytext + 1);
845 if (location[0] == '\0') {
846 log_errx(1, "empty location in %s, "
847 "line %d", map, lineno);
850 location = checked_strdup(yytext);
853 if (mountpoint == NULL)
854 mountpoint = checked_strdup("/");
855 if (options2 == NULL)
856 options2 = checked_strdup("");
859 log_debugx("adding map node, %s %s %s",
860 mountpoint, options2, location);
862 node_new(node, mountpoint, options2, location,
864 mountpoint = options2 = location = NULL;
867 if (ret == 0 || ret == NEWLINE) {
868 if (mountpoint != NULL || options2 != NULL ||
870 log_errx(1, "truncated entry "
871 "in %s, line %d", map, lineno);
880 * Parse output of a special map called without argument. It is a list
881 * of keys, separated by newlines. They can contain whitespace, so use
882 * getline(3) instead of lexer used for maps.
885 parse_map_keys_yyin(struct node *parent, const char *map)
887 char *line = NULL, *key;
894 linelen = getline(&line, &linecap, yyin);
903 * Empty line, consisting of just the newline.
909 * "-1" to strip the trailing newline.
911 key = strndup(line, linelen - 1);
913 log_debugx("adding key \"%s\"", key);
914 node_new(parent, key, NULL, NULL, map, lineno);
921 file_is_executable(const char *path)
926 error = stat(path, &sb);
928 log_err(1, "cannot stat %s", path);
929 if ((sb.st_mode & S_IXUSR) || (sb.st_mode & S_IXGRP) ||
930 (sb.st_mode & S_IXOTH))
936 * Parse a special map, e.g. "-hosts".
939 parse_special_map(struct node *parent, const char *map, const char *key)
944 assert(map[0] == '-');
947 * +1 to skip leading "-" in map name.
949 ret = asprintf(&path, "%s/special_%s", AUTO_SPECIAL_PREFIX, map + 1);
951 log_err(1, "asprintf");
953 yyin = auto_popen(path, key, NULL);
954 assert(yyin != NULL);
957 parse_map_keys_yyin(parent, map);
959 parse_map_yyin(parent, map, key);
962 error = auto_pclose(yyin);
965 log_errx(1, "failed to handle special map \"%s\"", map);
967 node_expand_includes(parent, false);
968 node_expand_direct_maps(parent);
974 * Retrieve and parse map from directory services, e.g. LDAP.
975 * Note that it is different from executable maps, in that
976 * the include script outputs the whole map to standard output
977 * (as opposed to executable maps that only output a single
978 * entry, without the key), and it takes the map name as an
979 * argument, instead of key.
982 parse_included_map(struct node *parent, const char *map)
986 assert(map[0] != '-');
987 assert(map[0] != '/');
989 error = access(AUTO_INCLUDE_PATH, F_OK);
991 log_errx(1, "directory services not configured;"
992 " %s does not exist", AUTO_INCLUDE_PATH);
995 yyin = auto_popen(AUTO_INCLUDE_PATH, map, NULL);
996 assert(yyin != NULL);
998 parse_map_yyin(parent, map, NULL);
1000 error = auto_pclose(yyin);
1003 log_errx(1, "failed to handle remote map \"%s\"", map);
1005 node_expand_includes(parent, false);
1006 node_expand_direct_maps(parent);
1010 parse_map(struct node *parent, const char *map, const char *key,
1017 assert(map != NULL);
1018 assert(map[0] != '\0');
1020 log_debugx("parsing map \"%s\"", map);
1022 if (wildcards != NULL)
1025 if (map[0] == '-') {
1026 if (wildcards != NULL)
1028 return (parse_special_map(parent, map, key));
1031 if (map[0] == '/') {
1032 path = checked_strdup(map);
1034 ret = asprintf(&path, "%s/%s", AUTO_MAP_PREFIX, map);
1036 log_err(1, "asprintf");
1037 log_debugx("map \"%s\" maps to \"%s\"", map, path);
1040 * See if the file exists. If not, try to obtain the map
1041 * from directory services.
1043 error = access(path, F_OK);
1045 log_debugx("map file \"%s\" does not exist; falling "
1046 "back to directory services", path);
1047 return (parse_included_map(parent, map));
1051 executable = file_is_executable(path);
1054 log_debugx("map \"%s\" is executable", map);
1056 if (wildcards != NULL)
1060 yyin = auto_popen(path, key, NULL);
1062 yyin = auto_popen(path, NULL);
1064 assert(yyin != NULL);
1066 yyin = fopen(path, "r");
1068 log_err(1, "unable to open \"%s\"", path);
1074 parse_map_yyin(parent, map, executable ? key : NULL);
1077 error = auto_pclose(yyin);
1080 log_errx(1, "failed to handle executable map \"%s\"",
1088 log_debugx("done parsing map \"%s\"", map);
1090 node_expand_includes(parent, false);
1091 node_expand_direct_maps(parent);
1095 parse_master_yyin(struct node *root, const char *master)
1097 char *mountpoint = NULL, *map = NULL, *options = NULL;
1101 * XXX: 1 gives incorrect values; wtf?
1107 if (ret == 0 || ret == NEWLINE) {
1108 if (mountpoint != NULL) {
1109 //log_debugx("adding map for %s", mountpoint);
1110 node_new_map(root, mountpoint, options, map,
1116 mountpoint = map = options = NULL;
1120 if (mountpoint == NULL) {
1121 mountpoint = checked_strdup(yytext);
1122 } else if (map == NULL) {
1123 map = checked_strdup(yytext);
1124 } else if (options == NULL) {
1126 * +1 to skip leading "-".
1128 options = checked_strdup(yytext + 1);
1130 log_errx(1, "too many arguments at %s, line %d",
1137 parse_master(struct node *root, const char *master)
1140 log_debugx("parsing auto_master file at \"%s\"", master);
1142 yyin = fopen(master, "r");
1144 err(1, "unable to open %s", master);
1146 parse_master_yyin(root, master);
1151 log_debugx("done parsing \"%s\"", master);
1153 node_expand_includes(root, true);
1154 node_expand_direct_maps(root);
1158 * Two things daemon(3) does, that we actually also want to do
1159 * when running in foreground, is closing the stdin and chdiring
1160 * to "/". This is what we do here.
1171 fd = open(_PATH_DEVNULL, O_RDWR, 0);
1173 log_warn("cannot open %s", _PATH_DEVNULL);
1177 error = dup2(fd, STDIN_FILENO);
1189 main(int argc, char **argv)
1193 if (argv[0] == NULL)
1194 log_errx(1, "NULL command name");
1196 cmdname = basename(argv[0]);
1198 if (strcmp(cmdname, "automount") == 0)
1199 return (main_automount(argc, argv));
1200 else if (strcmp(cmdname, "automountd") == 0)
1201 return (main_automountd(argc, argv));
1202 else if (strcmp(cmdname, "autounmountd") == 0)
1203 return (main_autounmountd(argc, argv));
1205 log_errx(1, "binary name should be either \"automount\", "
1206 "\"automountd\", or \"autounmountd\"");