usr.sbin/autofs/common.c

/*-
 * Copyright (c) 2016 The DragonFly Project
 * Copyright (c) 2014 The FreeBSD Foundation
 * All rights reserved.
 *
 * This software was developed by Edward Tomasz Napierala under sponsorship
 * from the FreeBSD Foundation.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * $FreeBSD: head/usr.sbin/autofs/common.c 303527 2016-07-30 01:10:05Z bapt $
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <assert.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <libgen.h>
#include <paths.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <vfs/autofs/autofs_ioctl.h>

#include "common.h"

extern FILE *yyin;
extern char *yytext;
extern int yylex(void);

static void	parse_master_yyin(struct node *root, const char *master);
static void	parse_map_yyin(struct node *parent, const char *map,
		    const char *executable_key);

char *
checked_strdup(const char *s)
{
	char *c;

	assert(s != NULL);

	c = strdup(s);
	if (c == NULL)
		log_err(1, "strdup");
	return (c);
}

/*
 * Concatenate two strings, inserting separator between them, unless not needed.
 */
char *
concat(const char *s1, char separator, const char *s2)
{
	char *result;
	char s1last, s2first;
	int ret;

	if (s1 == NULL)
		s1 = "";
	if (s2 == NULL)
		s2 = "";

	if (s1[0] == '\0')
		s1last = '\0';
	else
		s1last = s1[strlen(s1) - 1];

	s2first = s2[0];

	if (s1last == separator && s2first == separator) {
		/*
		 * If s1 ends with the separator and s2 begins with
		 * it - skip the latter; otherwise concatenating "/"
		 * and "/foo" would end up returning "//foo".
		 */
		ret = asprintf(&result, "%s%s", s1, s2 + 1);
	} else if (s1last == separator || s2first == separator ||
	    s1[0] == '\0' || s2[0] == '\0') {
		ret = asprintf(&result, "%s%s", s1, s2);
	} else {
		ret = asprintf(&result, "%s%c%s", s1, separator, s2);
	}
	if (ret < 0)
		log_err(1, "asprintf");

	//log_debugx("%s: got %s and %s, returning %s", __func__, s1, s2, result);

	return (result);
}

void
create_directory(const char *path)
{
	char *component, *copy, *tofree, *partial, *tmp;
	int error;

	assert(path[0] == '/');

	/*
	 * +1 to skip the leading slash.
	 */
	copy = tofree = checked_strdup(path + 1);

	partial = checked_strdup("");
	for (;;) {
		component = strsep(&copy, "/");
		if (component == NULL)
			break;
		tmp = concat(partial, '/', component);
		free(partial);
		partial = tmp;
		//log_debugx("creating \"%s\"", partial);
		error = mkdir(partial, 0755);
		if (error != 0 && errno != EEXIST) {
			log_warn("cannot create %s", partial);
			return;
		}
	}

	free(tofree);
}

struct node *
node_new_root(void)
{
	struct node *n;

	n = calloc(1, sizeof(*n));
	if (n == NULL)
		log_err(1, "calloc");
	// XXX
	n->n_key = checked_strdup("/");
	n->n_options = checked_strdup("");

	TAILQ_INIT(&n->n_children);

	return (n);
}

struct node *
node_new(struct node *parent, char *key, char *options, char *location,
    const char *config_file, int config_line)
{
	struct node *n;

	n = calloc(1, sizeof(*n));
	if (n == NULL)
		log_err(1, "calloc");

	TAILQ_INIT(&n->n_children);
	assert(key != NULL);
	assert(key[0] != '\0');
	n->n_key = key;
	if (options != NULL)
		n->n_options = options;
	else
		n->n_options = strdup("");
	n->n_location = location;
	assert(config_file != NULL);
	n->n_config_file = config_file;
	assert(config_line >= 0);
	n->n_config_line = config_line;

	assert(parent != NULL);
	n->n_parent = parent;
	TAILQ_INSERT_TAIL(&parent->n_children, n, n_next);

	return (n);
}

struct node *
node_new_map(struct node *parent, char *key, char *options, char *map,
    const char *config_file, int config_line)
{
	struct node *n;

	n = calloc(1, sizeof(*n));
	if (n == NULL)
		log_err(1, "calloc");

	TAILQ_INIT(&n->n_children);
	assert(key != NULL);
	assert(key[0] != '\0');
	n->n_key = key;
	if (options != NULL)
		n->n_options = options;
	else
		n->n_options = strdup("");
	n->n_map = map;
	assert(config_file != NULL);
	n->n_config_file = config_file;
	assert(config_line >= 0);
	n->n_config_line = config_line;

	assert(parent != NULL);
	n->n_parent = parent;
	TAILQ_INSERT_TAIL(&parent->n_children, n, n_next);

	return (n);
}

static struct node *
node_duplicate(const struct node *o, struct node *parent)
{
	const struct node *child;
	struct node *n;

	if (parent == NULL)
		parent = o->n_parent;

	n = node_new(parent, o->n_key, o->n_options, o->n_location,
	    o->n_config_file, o->n_config_line);

	TAILQ_FOREACH(child, &o->n_children, n_next)
		node_duplicate(child, n);

	return (n);
}

static void
node_delete(struct node *n)
{
	struct node *child, *tmp;

	assert (n != NULL);

	TAILQ_FOREACH_SAFE(child, &n->n_children, n_next, tmp)
		node_delete(child);

	if (n->n_parent != NULL)
		TAILQ_REMOVE(&n->n_parent->n_children, n, n_next);

	free(n);
}

/*
 * Move (reparent) node 'n' to make it sibling of 'previous', placed
 * just after it.
 */
static void
node_move_after(struct node *n, struct node *previous)
{

	TAILQ_REMOVE(&n->n_parent->n_children, n, n_next);
	n->n_parent = previous->n_parent;
	TAILQ_INSERT_AFTER(&previous->n_parent->n_children, previous, n, n_next);
}

static void
node_expand_includes(struct node *root, bool is_master)
{
	struct node *n, *n2, *tmp, *tmp2, *tmproot;
	int error;

	TAILQ_FOREACH_SAFE(n, &root->n_children, n_next, tmp) {
		if (n->n_key[0] != '+')
			continue;

		error = access(AUTO_INCLUDE_PATH, F_OK);
		if (error != 0) {
			log_errx(1, "directory services not configured; "
			    "%s does not exist", AUTO_INCLUDE_PATH);
		}

		/*
		 * "+1" to skip leading "+".
		 */
		yyin = auto_popen(AUTO_INCLUDE_PATH, n->n_key + 1, NULL);
		assert(yyin != NULL);

		tmproot = node_new_root();
		if (is_master)
			parse_master_yyin(tmproot, n->n_key);
		else
			parse_map_yyin(tmproot, n->n_key, NULL);

		error = auto_pclose(yyin);
		yyin = NULL;
		if (error != 0) {
			log_errx(1, "failed to handle include \"%s\"",
			    n->n_key);
		}

		/*
		 * Entries to be included are now in tmproot.  We need to merge
		 * them with the rest, preserving their place and ordering.
		 */
		TAILQ_FOREACH_REVERSE_SAFE(n2,
		    &tmproot->n_children, nodehead, n_next, tmp2) {
			node_move_after(n2, n);
		}

		node_delete(n);
		node_delete(tmproot);
	}
}

static char *
expand_ampersand(char *string, const char *key)
{
	char c, *expanded;
	int i, ret, before_len = 0;
	bool backslashed = false;

	assert(key[0] != '\0');

	expanded = checked_strdup(string);

	for (i = 0; string[i] != '\0'; i++) {
		c = string[i];
		if (c == '\\' && backslashed == false) {
			backslashed = true;
			continue;
		}
		if (backslashed) {
			backslashed = false;
			continue;
		}
		backslashed = false;
		if (c != '&')
			continue;

		/*
		 * The 'before_len' variable contains the number
		 * of characters before the '&'.
		 */
		before_len = i;
		//assert(i + 1 < (int)strlen(string));

		ret = asprintf(&expanded, "%.*s%s%s",
		    before_len, string, key, string + before_len + 1);
		if (ret < 0)
			log_err(1, "asprintf");

		//log_debugx("\"%s\" expanded with key \"%s\" to \"%s\"",
		//    string, key, expanded);

		/*
		 * Figure out where to start searching for next variable.
		 */
		string = expanded;
		i = before_len + strlen(key);
		backslashed = false;
		//assert(i < (int)strlen(string));
	}

	return (expanded);
}

/*
 * Expand "&" in n_location.  If the key is NULL, try to use
 * key from map entries themselves.  Keep in mind that maps
 * consist of tho levels of node structures, the key is one
 * level up.
 *
 * Variant with NULL key is for "automount -LL".
 */
void
node_expand_ampersand(struct node *n, const char *key)
{
	struct node *child;

	if (n->n_location != NULL) {
		if (key == NULL) {
			if (n->n_parent != NULL &&
			    strcmp(n->n_parent->n_key, "*") != 0) {
				n->n_location = expand_ampersand(n->n_location,
				    n->n_parent->n_key);
			}
		} else {
			n->n_location = expand_ampersand(n->n_location, key);
		}
	}

	TAILQ_FOREACH(child, &n->n_children, n_next)
		node_expand_ampersand(child, key);
}

/*
 * Expand "*" in n_key.
 */
void
node_expand_wildcard(struct node *n, const char *key)
{
	struct node *child, *expanded;

	assert(key != NULL);

	if (strcmp(n->n_key, "*") == 0) {
		expanded = node_duplicate(n, NULL);
		expanded->n_key = checked_strdup(key);
		node_move_after(expanded, n);
	}

	TAILQ_FOREACH(child, &n->n_children, n_next)
		node_expand_wildcard(child, key);
}

int
node_expand_defined(struct node *n)
{
	struct node *child;
	int error, cumulated_error = 0;

	if (n->n_location != NULL) {
		n->n_location = defined_expand(n->n_location);
		if (n->n_location == NULL) {
			log_warnx("failed to expand location for %s",
			    node_path(n));
			return (EINVAL);
		}
	}

	TAILQ_FOREACH(child, &n->n_children, n_next) {
		error = node_expand_defined(child);
		if (error != 0 && cumulated_error == 0)
			cumulated_error = error;
	}

	return (cumulated_error);
}

static bool
node_is_direct_key(const struct node *n)
{

	if (n->n_parent != NULL && n->n_parent->n_parent == NULL &&
	    strcmp(n->n_key, "/-") == 0) {
		return (true);
	}

	return (false);
}

bool
node_is_direct_map(const struct node *n)
{

	for (;;) {
		assert(n->n_parent != NULL);
		if (n->n_parent->n_parent == NULL)
			break;
		n = n->n_parent;
	}

	return (node_is_direct_key(n));
}

bool
node_has_wildcards(const struct node *n)
{
	const struct node *child;

	TAILQ_FOREACH(child, &n->n_children, n_next) {
		if (strcmp(child->n_key, "*") == 0)
			return (true);
	}

	return (false);
}

static void
node_expand_maps(struct node *n, bool indirect)
{
	struct node *child, *tmp;

	TAILQ_FOREACH_SAFE(child, &n->n_children, n_next, tmp) {
		if (node_is_direct_map(child)) {
			if (indirect)
				continue;
		} else {
			if (indirect == false)
				continue;
		}

		/*
		 * This is the first-level map node; the one that contains
		 * the key and subnodes with mountpoints and actual map names.
		 */
		if (child->n_map == NULL)
			continue;

		if (indirect) {
			log_debugx("map \"%s\" is an indirect map, parsing",
			    child->n_map);
		} else {
			log_debugx("map \"%s\" is a direct map, parsing",
			    child->n_map);
		}
		parse_map(child, child->n_map, NULL, NULL);
	}
}

static void
node_expand_direct_maps(struct node *n)
{

	node_expand_maps(n, false);
}

void
node_expand_indirect_maps(struct node *n)
{

	node_expand_maps(n, true);
}

static char *
node_path_x(const struct node *n, char *x)
{
	char *path;

	if (n->n_parent == NULL)
		return (x);

	/*
	 * Return "/-" for direct maps only if we were asked for path
	 * to the "/-" node itself, not to any of its subnodes.
	 */
	if (node_is_direct_key(n) && x[0] != '\0')
		return (x);

	assert(n->n_key[0] != '\0');
	path = concat(n->n_key, '/', x);
	free(x);

	return (node_path_x(n->n_parent, path));
}

/*
 * Return full path for node, consisting of concatenated
 * paths of node itself and all its parents, up to the root.
 */
char *
node_path(const struct node *n)
{
	char *path;
	size_t len;

	path = node_path_x(n, checked_strdup(""));

	/*
	 * Strip trailing slash, unless the whole path is "/".
	 */
	len = strlen(path);
	if (len > 1 && path[len - 1] == '/')
		path[len - 1] = '\0';

	return (path);
}

static char *
node_options_x(const struct node *n, char *x)
{
	char *options;

	if (n == NULL)
		return (x);

	options = concat(x, ',', n->n_options);
	free(x);

	return (node_options_x(n->n_parent, options));
}

/*
 * Return options for node, consisting of concatenated
 * options from the node itself and all its parents,
 * up to the root.
 */
char *
node_options(const struct node *n)
{

	return (node_options_x(n, checked_strdup("")));
}

static void
node_print_indent(const struct node *n, const char *cmdline_options,
    int indent)
{
	const struct node *child, *first_child;
	char *path, *options, *tmp;

	path = node_path(n);
	tmp = node_options(n);
	options = concat(cmdline_options, ',', tmp);
	free(tmp);

	/*
	 * Do not show both parent and child node if they have the same
	 * mountpoint; only show the child node.  This means the typical,
	 * "key location", map entries are shown in a single line;
	 * the "key mountpoint1 location2 mountpoint2 location2" entries
	 * take multiple lines.
	 */
	first_child = TAILQ_FIRST(&n->n_children);
	if (first_child == NULL || TAILQ_NEXT(first_child, n_next) != NULL ||
	    strcmp(path, node_path(first_child)) != 0) {
		assert(n->n_location == NULL || n->n_map == NULL);
		printf("%*.s%-*s %s%-*s %-*s # %s map %s at %s:%d\n",
		    indent, "",
		    25 - indent,
		    path,
		    options[0] != '\0' ? "-" : " ",
		    20,
		    options[0] != '\0' ? options : "",
		    20,
		    n->n_location != NULL ? n->n_location : n->n_map != NULL ? n->n_map : "",
		    node_is_direct_map(n) ? "direct" : "indirect",
		    indent == 0 ? "referenced" : "defined",
		    n->n_config_file, n->n_config_line);
	}

	free(path);
	free(options);

	TAILQ_FOREACH(child, &n->n_children, n_next)
		node_print_indent(child, cmdline_options, indent + 2);
}

/*
 * Recursively print node with all its children.  The cmdline_options
 * argument is used for additional options to be prepended to all the
 * others - usually those are the options passed by command line.
 */
void
node_print(const struct node *n, const char *cmdline_options)
{
	const struct node *child;

	TAILQ_FOREACH(child, &n->n_children, n_next)
		node_print_indent(child, cmdline_options, 0);
}

static struct node *
node_find_x(struct node *node, const char *path)
{
	struct node *child, *found;
	char *tmp;
	size_t tmplen;

	//log_debugx("looking up %s in %s", path, node_path(node));

	if (!node_is_direct_key(node)) {
		tmp = node_path(node);
		tmplen = strlen(tmp);
		if (strncmp(tmp, path, tmplen) != 0) {
			free(tmp);
			return (NULL);
		}
		if (path[tmplen] != '/' && path[tmplen] != '\0') {
			/*
			 * If we have two map entries like 'foo' and 'foobar', make
			 * sure the search for 'foobar' won't match 'foo' instead.
			 */
			free(tmp);
			return (NULL);
		}
		free(tmp);
	}

	TAILQ_FOREACH(child, &node->n_children, n_next) {
		found = node_find_x(child, path);
		if (found != NULL)
			return (found);
	}

	if (node->n_parent == NULL || node_is_direct_key(node))
		return (NULL);

	return (node);
}

struct node *
node_find(struct node *root, const char *path)
{
	struct node *node;

	assert(root->n_parent == NULL);

	node = node_find_x(root, path);
	if (node != NULL)
		assert(node != root);

	return (node);
}

/*
 * Canonical form of a map entry looks like this:
 *
 * key [-options] [ [/mountpoint] [-options2] location ... ]
 *
 * Entries for executable maps are slightly different, as they
 * lack the 'key' field and are always single-line; the key field
 * for those maps is taken from 'executable_key' argument.
 *
 * We parse it in such a way that a map always has two levels - first
 * for key, and the second, for the mountpoint.
 */
static void
parse_map_yyin(struct node *parent, const char *map, const char *executable_key)
{
	char *key = NULL, *options = NULL, *mountpoint = NULL,
	    *options2 = NULL, *location = NULL;
	int ret;
	struct node *node;

	lineno = 1;

	if (executable_key != NULL)
		key = checked_strdup(executable_key);

	for (;;) {
		ret = yylex();
		if (ret == 0 || ret == NEWLINE) {
			/*
			 * In case of executable map, the key is always
			 * non-NULL, even if the map is empty.  So, make sure
			 * we don't fail empty maps here.
			 */
			if ((key != NULL && executable_key == NULL) ||
			    options != NULL) {
				log_errx(1, "truncated entry at %s, line %d",
				    map, lineno);
			}
			if (ret == 0 || executable_key != NULL) {
				/*
				 * End of file.
				 */
				break;
			} else {
				key = options = NULL;
				continue;
			}
		}
		if (key == NULL) {
			key = checked_strdup(yytext);
			if (key[0] == '+') {
				node_new(parent, key, NULL, NULL, map, lineno);
				key = options = NULL;
				continue;
			}
			continue;
		} else if (yytext[0] == '-') {
			if (options != NULL) {
				log_errx(1, "duplicated options at %s, line %d",
				    map, lineno);
			}
			/*
			 * +1 to skip leading "-".
			 */
			options = checked_strdup(yytext + 1);
			continue;
		}

		/*
		 * We cannot properly handle a situation where the map key
		 * is "/".  Ignore such entries.
		 *
		 * XXX: According to Piete Brooks, Linux automounter uses
		 *	"/" as a wildcard character in LDAP maps.  Perhaps
		 *	we should work around this braindamage by substituting
		 *	"*" for "/"?
		 */
		if (strcmp(key, "/") == 0) {
			log_warnx("nonsensical map key \"/\" at %s, line %d; "
			    "ignoring map entry ", map, lineno);

			/*
			 * Skip the rest of the entry.
			 */
			do {
				ret = yylex();
			} while (ret != 0 && ret != NEWLINE);

			key = options = NULL;
			continue;
		}

		//log_debugx("adding map node, %s", key);
		node = node_new(parent, key, options, NULL, map, lineno);
		key = options = NULL;

		for (;;) {
			if (yytext[0] == '/') {
				if (mountpoint != NULL) {
					log_errx(1, "duplicated mountpoint "
					    "in %s, line %d", map, lineno);
				}
				if (options2 != NULL || location != NULL) {
					log_errx(1, "mountpoint out of order "
					    "in %s, line %d", map, lineno);
				}
				mountpoint = checked_strdup(yytext);
				goto again;
			}

			if (yytext[0] == '-') {
				if (options2 != NULL) {
					log_errx(1, "duplicated options "
					    "in %s, line %d", map, lineno);
				}
				if (location != NULL) {
					log_errx(1, "options out of order "
					    "in %s, line %d", map, lineno);
				}
				options2 = checked_strdup(yytext + 1);
				goto again;
			}

			if (location != NULL) {
				log_errx(1, "too many arguments "
				    "in %s, line %d", map, lineno);
			}

			/*
			 * If location field starts with colon, e.g. ":/dev/cd0",
			 * then strip it.
			 */
			if (yytext[0] == ':') {
				location = checked_strdup(yytext + 1);
				if (location[0] == '\0') {
					log_errx(1, "empty location in %s, "
					    "line %d", map, lineno);
				}
			} else {
				location = checked_strdup(yytext);
			}

			if (mountpoint == NULL)
				mountpoint = checked_strdup("/");
			if (options2 == NULL)
				options2 = checked_strdup("");

#if 0
			log_debugx("adding map node, %s %s %s",
			    mountpoint, options2, location);
#endif
			node_new(node, mountpoint, options2, location,
			    map, lineno);
			mountpoint = options2 = location = NULL;
again:
			ret = yylex();
			if (ret == 0 || ret == NEWLINE) {
				if (mountpoint != NULL || options2 != NULL ||
				    location != NULL) {
					log_errx(1, "truncated entry "
					    "in %s, line %d", map, lineno);
				}
				break;
			}
		}
	}
}

/*
 * Parse output of a special map called without argument.  It is a list
 * of keys, separated by newlines.  They can contain whitespace, so use
 * getline(3) instead of lexer used for maps.
 */
static void
parse_map_keys_yyin(struct node *parent, const char *map)
{
	char *line = NULL, *key;
	size_t linecap = 0;
	ssize_t linelen;

	lineno = 1;

	for (;;) {
		linelen = getline(&line, &linecap, yyin);
		if (linelen < 0) {
			/*
			 * End of file.
			 */
			break;
		}
		if (linelen <= 1) {
			/*
			 * Empty line, consisting of just the newline.
			 */
			continue;
		}

		/*
		 * "-1" to strip the trailing newline.
		 */
		key = strndup(line, linelen - 1);

		log_debugx("adding key \"%s\"", key);
		node_new(parent, key, NULL, NULL, map, lineno);
		lineno++;
	}
	free(line);
}

static bool
file_is_executable(const char *path)
{
	struct stat sb;
	int error;

	error = stat(path, &sb);
	if (error != 0)
		log_err(1, "cannot stat %s", path);
	if ((sb.st_mode & S_IXUSR) || (sb.st_mode & S_IXGRP) ||
	    (sb.st_mode & S_IXOTH))
		return (true);
	return (false);
}

/*
 * Parse a special map, e.g. "-hosts".
 */
static void
parse_special_map(struct node *parent, const char *map, const char *key)
{
	char *path;
	int error, ret;

	assert(map[0] == '-');

	/*
	 * +1 to skip leading "-" in map name.
	 */
	ret = asprintf(&path, "%s/special_%s", AUTO_SPECIAL_PREFIX, map + 1);
	if (ret < 0)
		log_err(1, "asprintf");

	yyin = auto_popen(path, key, NULL);
	assert(yyin != NULL);

	if (key == NULL) {
		parse_map_keys_yyin(parent, map);
	} else {
		parse_map_yyin(parent, map, key);
	}

	error = auto_pclose(yyin);
	yyin = NULL;
	if (error != 0)
		log_errx(1, "failed to handle special map \"%s\"", map);

	node_expand_includes(parent, false);
	node_expand_direct_maps(parent);

	free(path);
}

/*
 * Retrieve and parse map from directory services, e.g. LDAP.
 * Note that it is different from executable maps, in that
 * the include script outputs the whole map to standard output
 * (as opposed to executable maps that only output a single
 * entry, without the key), and it takes the map name as an
 * argument, instead of key.
 */
static void
parse_included_map(struct node *parent, const char *map)
{
	int error;

	assert(map[0] != '-');
	assert(map[0] != '/');

	error = access(AUTO_INCLUDE_PATH, F_OK);
	if (error != 0) {
		log_errx(1, "directory services not configured;"
		    " %s does not exist", AUTO_INCLUDE_PATH);
	}

	yyin = auto_popen(AUTO_INCLUDE_PATH, map, NULL);
	assert(yyin != NULL);

	parse_map_yyin(parent, map, NULL);

	error = auto_pclose(yyin);
	yyin = NULL;
	if (error != 0)
		log_errx(1, "failed to handle remote map \"%s\"", map);

	node_expand_includes(parent, false);
	node_expand_direct_maps(parent);
}

void
parse_map(struct node *parent, const char *map, const char *key,
    bool *wildcards)
{
	char *path = NULL;
	int error, ret;
	bool executable;

	assert(map != NULL);
	assert(map[0] != '\0');

	log_debugx("parsing map \"%s\"", map);

	if (wildcards != NULL)
		*wildcards = false;

	if (map[0] == '-') {
		if (wildcards != NULL)
			*wildcards = true;
		return (parse_special_map(parent, map, key));
	}

	if (map[0] == '/') {
		path = checked_strdup(map);
	} else {
		ret = asprintf(&path, "%s/%s", AUTO_MAP_PREFIX, map);
		if (ret < 0)
			log_err(1, "asprintf");
		log_debugx("map \"%s\" maps to \"%s\"", map, path);

		/*
		 * See if the file exists.  If not, try to obtain the map
		 * from directory services.
		 */
		error = access(path, F_OK);
		if (error != 0) {
			log_debugx("map file \"%s\" does not exist; falling "
			    "back to directory services", path);
			return (parse_included_map(parent, map));
		}
	}

	executable = file_is_executable(path);

	if (executable) {
		log_debugx("map \"%s\" is executable", map);

		if (wildcards != NULL)
			*wildcards = true;

		if (key != NULL) {
			yyin = auto_popen(path, key, NULL);
		} else {
			yyin = auto_popen(path, NULL);
		}
		assert(yyin != NULL);
	} else {
		yyin = fopen(path, "r");
		if (yyin == NULL)
			log_err(1, "unable to open \"%s\"", path);
	}

	free(path);
	path = NULL;

	parse_map_yyin(parent, map, executable ? key : NULL);

	if (executable) {
		error = auto_pclose(yyin);
		yyin = NULL;
		if (error != 0) {
			log_errx(1, "failed to handle executable map \"%s\"",
			    map);
		}
	} else {
		fclose(yyin);
	}
	yyin = NULL;

	log_debugx("done parsing map \"%s\"", map);

	node_expand_includes(parent, false);
	node_expand_direct_maps(parent);
}

static void
parse_master_yyin(struct node *root, const char *master)
{
	char *mountpoint = NULL, *map = NULL, *options = NULL;
	int ret;

	/*
	 * XXX: 1 gives incorrect values; wtf?
	 */
	lineno = 0;

	for (;;) {
		ret = yylex();
		if (ret == 0 || ret == NEWLINE) {
			if (mountpoint != NULL) {
				//log_debugx("adding map for %s", mountpoint);
				node_new_map(root, mountpoint, options, map,
				    master, lineno);
			}
			if (ret == 0) {
				break;
			} else {
				mountpoint = map = options = NULL;
				continue;
			}
		}
		if (mountpoint == NULL) {
			mountpoint = checked_strdup(yytext);
		} else if (map == NULL) {
			map = checked_strdup(yytext);
		} else if (options == NULL) {
			/*
			 * +1 to skip leading "-".
			 */
			options = checked_strdup(yytext + 1);
		} else {
			log_errx(1, "too many arguments at %s, line %d",
			    master, lineno);
		}
	}
}

void
parse_master(struct node *root, const char *master)
{

	log_debugx("parsing auto_master file at \"%s\"", master);

	yyin = fopen(master, "r");
	if (yyin == NULL)
		err(1, "unable to open %s", master);

	parse_master_yyin(root, master);

	fclose(yyin);
	yyin = NULL;

	log_debugx("done parsing \"%s\"", master);

	node_expand_includes(root, true);
	node_expand_direct_maps(root);
}

/*
 * Two things daemon(3) does, that we actually also want to do
 * when running in foreground, is closing the stdin and chdiring
 * to "/".  This is what we do here.
 */
void
lesser_daemon(void)
{
	int error, fd;

	error = chdir("/");
	if (error != 0)
		log_warn("chdir");

	fd = open(_PATH_DEVNULL, O_RDWR, 0);
	if (fd < 0) {
		log_warn("cannot open %s", _PATH_DEVNULL);
		return;
	}

	error = dup2(fd, STDIN_FILENO);
	if (error != 0)
		log_warn("dup2");

	error = close(fd);
	if (error != 0) {
		/* Bloody hell. */
		log_warn("close");
	}
}

int
main(int argc, char **argv)
{
	char *cmdname;

	if (argv[0] == NULL)
		log_errx(1, "NULL command name");

	cmdname = basename(argv[0]);

	if (strcmp(cmdname, "automount") == 0)
		return (main_automount(argc, argv));
	else if (strcmp(cmdname, "automountd") == 0)
		main_automountd(argc, argv);
	else if (strcmp(cmdname, "autounmountd") == 0)
		main_autounmountd(argc, argv);
	else
		log_errx(1, "binary name should be either \"automount\", "
		    "\"automountd\", or \"autounmountd\"");
}