1371 lines
32 KiB
C
1371 lines
32 KiB
C
/* $NetBSD: conf.c,v 1.1.1.9 2005/09/20 17:14:48 rpaulo Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 1997-2005 Erez Zadok
|
|
* Copyright (c) 1990 Jan-Simon Pendry
|
|
* Copyright (c) 1990 Imperial College of Science, Technology & Medicine
|
|
* Copyright (c) 1990 The Regents of the University of California.
|
|
* All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to Berkeley by
|
|
* Jan-Simon Pendry at Imperial College, London.
|
|
*
|
|
* 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.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgment:
|
|
* This product includes software developed by the University of
|
|
* California, Berkeley and its contributors.
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
|
|
*
|
|
*
|
|
* File: am-utils/amd/conf.c
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* Functions to handle the configuration file.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
# include <config.h>
|
|
#endif /* HAVE_CONFIG_H */
|
|
#include <am_defs.h>
|
|
#include <amd.h>
|
|
|
|
|
|
/*
|
|
* MACROS:
|
|
*/
|
|
/* Turn on to show some info about maps being configured */
|
|
/* #define DEBUG_CONF */
|
|
|
|
/*
|
|
* TYPEDEFS:
|
|
*/
|
|
typedef int (*OptFuncPtr)(const char *);
|
|
|
|
/*
|
|
* STRUCTURES:
|
|
*/
|
|
struct _func_map {
|
|
char *name;
|
|
OptFuncPtr func;
|
|
};
|
|
|
|
/*
|
|
* FORWARD DECLARATIONS:
|
|
*/
|
|
static int gopt_arch(const char *val);
|
|
static int gopt_auto_attrcache(const char *val);
|
|
static int gopt_auto_dir(const char *val);
|
|
static int gopt_autofs_use_lofs(const char *val);
|
|
static int gopt_browsable_dirs(const char *val);
|
|
static int gopt_cache_duration(const char *val);
|
|
static int gopt_cluster(const char *val);
|
|
static int gopt_debug_mtab_file(const char *val);
|
|
static int gopt_debug_options(const char *val);
|
|
static int gopt_dismount_interval(const char *val);
|
|
static int gopt_domain_strip(const char *val);
|
|
static int gopt_exec_map_timeout(const char *val);
|
|
static int gopt_forced_unmounts(const char *val);
|
|
static int gopt_full_os(const char *val);
|
|
static int gopt_fully_qualified_hosts(const char *val);
|
|
static int gopt_hesiod_base(const char *val);
|
|
static int gopt_karch(const char *val);
|
|
static int gopt_ldap_base(const char *val);
|
|
static int gopt_ldap_cache_maxmem(const char *val);
|
|
static int gopt_ldap_cache_seconds(const char *val);
|
|
static int gopt_ldap_hostports(const char *val);
|
|
static int gopt_ldap_proto_version(const char *val);
|
|
static int gopt_local_domain(const char *val);
|
|
static int gopt_localhost_address(const char *val);
|
|
static int gopt_log_file(const char *val);
|
|
static int gopt_log_options(const char *val);
|
|
static int gopt_map_defaults(const char *val);
|
|
static int gopt_map_options(const char *val);
|
|
static int gopt_map_reload_interval(const char *val);
|
|
static int gopt_map_type(const char *val);
|
|
static int gopt_mount_type(const char *val);
|
|
static int gopt_pid_file(const char *val);
|
|
static int gopt_portmap_program(const char *val);
|
|
static int gopt_preferred_amq_port(const char *val);
|
|
static int gopt_nfs_allow_insecure_port(const char *val);
|
|
static int gopt_nfs_proto(const char *val);
|
|
static int gopt_nfs_retransmit_counter(const char *val);
|
|
static int gopt_nfs_retransmit_counter_tcp(const char *val);
|
|
static int gopt_nfs_retransmit_counter_udp(const char *val);
|
|
static int gopt_nfs_retry_interval(const char *val);
|
|
static int gopt_nfs_retry_interval_udp(const char *val);
|
|
static int gopt_nfs_retry_interval_tcp(const char *val);
|
|
static int gopt_nfs_vers(const char *val);
|
|
static int gopt_nis_domain(const char *val);
|
|
static int gopt_normalize_hostnames(const char *val);
|
|
static int gopt_normalize_slashes(const char *val);
|
|
static int gopt_os(const char *val);
|
|
static int gopt_osver(const char *val);
|
|
static int gopt_plock(const char *val);
|
|
static int gopt_print_pid(const char *val);
|
|
static int gopt_print_version(const char *val);
|
|
static int gopt_restart_mounts(const char *val);
|
|
static int gopt_search_path(const char *val);
|
|
static int gopt_selectors_in_defaults(const char *val);
|
|
static int gopt_show_statfs_entries(const char *val);
|
|
static int gopt_truncate_log(const char *val);
|
|
static int gopt_unmount_on_exit(const char *val);
|
|
static int gopt_use_tcpwrappers(const char *val);
|
|
static int gopt_vendor(const char *val);
|
|
static int process_global_option(const char *key, const char *val);
|
|
static int process_one_regular_map(const cf_map_t *cfm);
|
|
static int process_regular_option(const char *section, const char *key, const char *val, cf_map_t *cfm);
|
|
static int ropt_browsable_dirs(const char *val, cf_map_t *cfm);
|
|
static int ropt_map_name(const char *val, cf_map_t *cfm);
|
|
static int ropt_map_defaults(const char *val, cf_map_t *cfm);
|
|
static int ropt_map_options(const char *val, cf_map_t *cfm);
|
|
static int ropt_map_type(const char *val, cf_map_t *cfm);
|
|
static int ropt_mount_type(const char *val, cf_map_t *cfm);
|
|
static int ropt_search_path(const char *val, cf_map_t *cfm);
|
|
static int ropt_tag(const char *val, cf_map_t *cfm);
|
|
static void init_cf_map(cf_map_t *cfm);
|
|
|
|
|
|
/*
|
|
* STATIC VARIABLES:
|
|
*/
|
|
static cf_map_t *head_map, *cur_map;
|
|
|
|
static struct _func_map glob_functable[] = {
|
|
{"arch", gopt_arch},
|
|
{"auto_attrcache", gopt_auto_attrcache},
|
|
{"auto_dir", gopt_auto_dir},
|
|
{"autofs_use_lofs", gopt_autofs_use_lofs},
|
|
{"browsable_dirs", gopt_browsable_dirs},
|
|
{"cache_duration", gopt_cache_duration},
|
|
{"cluster", gopt_cluster},
|
|
{"debug_mtab_file", gopt_debug_mtab_file},
|
|
{"debug_options", gopt_debug_options},
|
|
{"dismount_interval", gopt_dismount_interval},
|
|
{"domain_strip", gopt_domain_strip},
|
|
{"exec_map_timeout", gopt_exec_map_timeout},
|
|
{"forced_unmounts", gopt_forced_unmounts},
|
|
{"fully_qualified_hosts", gopt_fully_qualified_hosts},
|
|
{"full_os", gopt_full_os},
|
|
{"hesiod_base", gopt_hesiod_base},
|
|
{"karch", gopt_karch},
|
|
{"ldap_base", gopt_ldap_base},
|
|
{"ldap_cache_maxmem", gopt_ldap_cache_maxmem},
|
|
{"ldap_cache_seconds", gopt_ldap_cache_seconds},
|
|
{"ldap_hostports", gopt_ldap_hostports},
|
|
{"ldap_proto_version", gopt_ldap_proto_version},
|
|
{"local_domain", gopt_local_domain},
|
|
{"localhost_address", gopt_localhost_address},
|
|
{"log_file", gopt_log_file},
|
|
{"log_options", gopt_log_options},
|
|
{"map_defaults", gopt_map_defaults},
|
|
{"map_options", gopt_map_options},
|
|
{"map_reload_interval", gopt_map_reload_interval},
|
|
{"map_type", gopt_map_type},
|
|
{"mount_type", gopt_mount_type},
|
|
{"pid_file", gopt_pid_file},
|
|
{"portmap_program", gopt_portmap_program},
|
|
{"preferred_amq_port", gopt_preferred_amq_port},
|
|
{"nfs_allow_insecure_port", gopt_nfs_allow_insecure_port},
|
|
{"nfs_proto", gopt_nfs_proto},
|
|
{"nfs_retransmit_counter", gopt_nfs_retransmit_counter},
|
|
{"nfs_retransmit_counter_udp", gopt_nfs_retransmit_counter_udp},
|
|
{"nfs_retransmit_counter_tcp", gopt_nfs_retransmit_counter_tcp},
|
|
{"nfs_retry_interval", gopt_nfs_retry_interval},
|
|
{"nfs_retry_interval_udp", gopt_nfs_retry_interval_udp},
|
|
{"nfs_retry_interval_tcp", gopt_nfs_retry_interval_tcp},
|
|
{"nfs_vers", gopt_nfs_vers},
|
|
{"nis_domain", gopt_nis_domain},
|
|
{"normalize_hostnames", gopt_normalize_hostnames},
|
|
{"normalize_slashes", gopt_normalize_slashes},
|
|
{"os", gopt_os},
|
|
{"osver", gopt_osver},
|
|
{"plock", gopt_plock},
|
|
{"print_pid", gopt_print_pid},
|
|
{"print_version", gopt_print_version},
|
|
{"restart_mounts", gopt_restart_mounts},
|
|
{"search_path", gopt_search_path},
|
|
{"selectors_on_default", gopt_selectors_in_defaults},
|
|
{"selectors_in_defaults", gopt_selectors_in_defaults},
|
|
{"show_statfs_entries", gopt_show_statfs_entries},
|
|
{"truncate_log", gopt_truncate_log},
|
|
{"unmount_on_exit", gopt_unmount_on_exit},
|
|
{"use_tcpwrappers", gopt_use_tcpwrappers},
|
|
{"vendor", gopt_vendor},
|
|
{NULL, NULL}
|
|
};
|
|
|
|
|
|
/*
|
|
* Initialize a map from [global] defaults.
|
|
*/
|
|
static void
|
|
init_cf_map(cf_map_t *cfm)
|
|
{
|
|
if (!cfm)
|
|
return;
|
|
|
|
/*
|
|
* Initialize a regular map's flags and other variables from the
|
|
* global ones, so that they are applied to all maps. Of course, each map
|
|
* can then override the flags individually.
|
|
*
|
|
* NOTES:
|
|
* (1): Will only work for maps that appear after [global].
|
|
* (2): I'm assigning pointers directly from the global map.
|
|
*/
|
|
|
|
/* initialize map_type from [global] */
|
|
cfm->cfm_type = gopt.map_type;
|
|
|
|
/* initialize map_defaults from [global] */
|
|
cfm->cfm_defaults = gopt.map_defaults;
|
|
|
|
/* initialize map_opts from [global] */
|
|
cfm->cfm_opts = gopt.map_options;
|
|
|
|
/* initialize search_path from [global] */
|
|
cfm->cfm_search_path = gopt.search_path;
|
|
|
|
/*
|
|
* Initialize flags that are common both to [global] and a local map.
|
|
*/
|
|
cfm->cfm_flags = gopt.flags & (CFM_BROWSABLE_DIRS |
|
|
CFM_BROWSABLE_DIRS_FULL |
|
|
CFM_MOUNT_TYPE_AUTOFS |
|
|
CFM_SELECTORS_IN_DEFAULTS);
|
|
}
|
|
|
|
|
|
/*
|
|
* Process configuration file options (called from YACC parser).
|
|
* Return 0 if OK, 1 otherwise.
|
|
*/
|
|
int
|
|
set_conf_kv(const char *section, const char *key, const char *val)
|
|
{
|
|
int ret;
|
|
|
|
#ifdef DEBUG_CONF
|
|
fprintf(stderr, "set_conf_kv: section=%s, key=%s, val=%s\n",
|
|
section, key, val);
|
|
#endif /* DEBUG_CONF */
|
|
|
|
/*
|
|
* If global section, process kv pairs one at a time.
|
|
*/
|
|
if (STREQ(section, "global")) {
|
|
/*
|
|
* Check if a regular map was configured before "global",
|
|
* and warn about it.
|
|
*/
|
|
if (cur_map && cur_map->cfm_dir) {
|
|
static short printed_this_error;
|
|
if (!printed_this_error) {
|
|
fprintf(stderr, "found regular map \"%s\" before global one.\n",
|
|
cur_map->cfm_dir);
|
|
printed_this_error = 1;
|
|
}
|
|
}
|
|
|
|
/* process the global option first */
|
|
ret = process_global_option(key, val);
|
|
|
|
/* return status from the processing of the global option */
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Otherwise we found a non-global option: store it after some testing.
|
|
*/
|
|
|
|
/* initialize (static) global list head and current map pointer */
|
|
if (!head_map && !cur_map) {
|
|
cur_map = CALLOC(cf_map_t);
|
|
if (!cur_map) {
|
|
perror("calloc");
|
|
exit(1);
|
|
}
|
|
/* initialize first head map from global defaults */
|
|
init_cf_map(cur_map);
|
|
head_map = cur_map;
|
|
}
|
|
|
|
/* check if we found a new map, then allocate and initialize it */
|
|
if (cur_map->cfm_dir && !STREQ(cur_map->cfm_dir, section)) {
|
|
/* allocate new map struct */
|
|
cf_map_t *tmp_map = CALLOC(cf_map_t);
|
|
if (!tmp_map) {
|
|
perror("calloc");
|
|
exit(1);
|
|
}
|
|
/* initialize it from global defaults */
|
|
init_cf_map(tmp_map);
|
|
/* append it to end of linked list */
|
|
cur_map->cfm_next = tmp_map;
|
|
cur_map = tmp_map;
|
|
}
|
|
|
|
/* now process a single entry of a regular map */
|
|
return process_regular_option(section, key, val, cur_map);
|
|
}
|
|
|
|
|
|
/*
|
|
* Process global section of configuration file options.
|
|
* Return 0 upon success, 1 otherwise.
|
|
*/
|
|
static int
|
|
process_global_option(const char *key, const char *val)
|
|
{
|
|
struct _func_map *gfp;
|
|
|
|
/* ensure that val is valid */
|
|
if (!val || val[0] == '\0')
|
|
return 1;
|
|
|
|
/*
|
|
* search for global function.
|
|
*/
|
|
for (gfp = glob_functable; gfp->name; gfp++)
|
|
if (FSTREQ(gfp->name, key))
|
|
return (gfp->func)(val);
|
|
|
|
fprintf(stderr, "conf: unknown global key: \"%s\"\n", key);
|
|
return 1; /* failed to match any command */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_arch(const char *val)
|
|
{
|
|
gopt.arch = strdup((char *)val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_auto_attrcache(const char *val)
|
|
{
|
|
gopt.auto_attrcache = atoi(val);
|
|
if (gopt.auto_attrcache < 0) {
|
|
fprintf(stderr, "conf: bad attrcache value: \"%s\"\n", val);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_auto_dir(const char *val)
|
|
{
|
|
gopt.auto_dir = strdup((char *)val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_autofs_use_lofs(const char *val)
|
|
{
|
|
if (STREQ(val, "yes")) {
|
|
gopt.flags |= CFM_AUTOFS_USE_LOFS;
|
|
return 0;
|
|
} else if (STREQ(val, "no")) {
|
|
gopt.flags &= ~CFM_AUTOFS_USE_LOFS;
|
|
return 0;
|
|
}
|
|
|
|
fprintf(stderr, "conf: unknown value to autofs_use_lofs \"%s\"\n", val);
|
|
return 1; /* unknown value */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_browsable_dirs(const char *val)
|
|
{
|
|
if (STREQ(val, "full")) {
|
|
gopt.flags |= CFM_BROWSABLE_DIRS_FULL;
|
|
return 0;
|
|
} else if (STREQ(val, "yes")) {
|
|
gopt.flags |= CFM_BROWSABLE_DIRS;
|
|
return 0;
|
|
} else if (STREQ(val, "no")) {
|
|
gopt.flags &= ~CFM_BROWSABLE_DIRS;
|
|
return 0;
|
|
}
|
|
|
|
fprintf(stderr, "conf: unknown value to browsable_dirs \"%s\"\n", val);
|
|
return 1; /* unknown value */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_cache_duration(const char *val)
|
|
{
|
|
gopt.am_timeo = atoi(val);
|
|
if (gopt.am_timeo <= 0)
|
|
gopt.am_timeo = AM_TTL;
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_cluster(const char *val)
|
|
{
|
|
gopt.cluster = strdup((char *)val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_debug_mtab_file(const char *val)
|
|
{
|
|
gopt.debug_mtab_file = strdup((char*)val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_debug_options(const char *val)
|
|
{
|
|
#ifdef DEBUG
|
|
usage += debug_option((char *)val);
|
|
return 0;
|
|
#else /* not DEBUG */
|
|
fprintf(stderr, "%s: not compiled with DEBUG option -- sorry.\n",
|
|
am_get_progname());
|
|
return 1;
|
|
#endif /* not DEBUG */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_dismount_interval(const char *val)
|
|
{
|
|
gopt.am_timeo_w = atoi(val);
|
|
if (gopt.am_timeo_w <= 0)
|
|
gopt.am_timeo_w = AM_TTL_W;
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_domain_strip(const char *val)
|
|
{
|
|
if (STREQ(val, "yes")) {
|
|
gopt.flags |= CFM_DOMAIN_STRIP;
|
|
return 0;
|
|
} else if (STREQ(val, "no")) {
|
|
gopt.flags &= ~CFM_DOMAIN_STRIP;
|
|
return 0;
|
|
}
|
|
|
|
fprintf(stderr, "conf: unknown value to domain_strip \"%s\"\n", val);
|
|
return 1; /* unknown value */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_exec_map_timeout(const char *val)
|
|
{
|
|
gopt.exec_map_timeout = atoi(val);
|
|
if (gopt.exec_map_timeout <= 0)
|
|
gopt.exec_map_timeout = AMFS_EXEC_MAP_TIMEOUT; /* default exec map timeout */
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_forced_unmounts(const char *val)
|
|
{
|
|
if (STREQ(val, "yes")) {
|
|
#if !defined(MNT2_GEN_OPT_DETACH) && !defined(MNT2_GEN_OPT_FORCE)
|
|
fprintf(stderr, "conf: forced_unmounts unsupported on this system.\n");
|
|
return 1;
|
|
#else /* defined(MNT2_GEN_OPT_DETACH) || defined(MNT2_GEN_OPT_FORCE) */
|
|
# ifdef __linux__
|
|
/*
|
|
* HACK ALERT: Linux has had MNT_FORCE since 2.2, but it hasn't gotten
|
|
* stable until 2.4. And it had MNT_DETACH since 2.4, but it hasn't
|
|
* gotten stable since 2.6. So alert users if they're trying to use a
|
|
* feature that may not work well on their older kernel.
|
|
*/
|
|
{
|
|
struct utsname un;
|
|
if (uname(&un) >= 0) {
|
|
# ifdef MNT2_GEN_OPT_FORCE
|
|
if (strcmp(un.release, "2.4.0") < 0)
|
|
fprintf(stderr, "warning: forced-unmounts (MNT_FORCE) may not work well before 2.4.0\n");
|
|
# endif /* MNT2_GEN_OPT_FORCE */
|
|
# ifdef MNT2_GEN_OPT_DETACH
|
|
if (strcmp(un.release, "2.6.0") < 0)
|
|
fprintf(stderr, "warning: lazy-unmounts (MNT_DETACH) may not work well before 2.6.0\n");
|
|
# endif /* MNT2_GEN_OPT_DETACH */
|
|
}
|
|
}
|
|
# endif /* __linux__ */
|
|
gopt.flags |= CFM_FORCED_UNMOUNTS;
|
|
return 0;
|
|
#endif /* defined(MNT2_GEN_OPT_DETACH) || defined(MNT2_GEN_OPT_FORCE) */
|
|
} else if (STREQ(val, "no")) {
|
|
gopt.flags &= ~CFM_FORCED_UNMOUNTS;
|
|
return 0;
|
|
}
|
|
|
|
fprintf(stderr, "conf: unknown value to unmount_on_exit \"%s\"\n", val);
|
|
return 1; /* unknown value */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_full_os(const char *val)
|
|
{
|
|
gopt.op_sys_full = strdup((char *)val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_fully_qualified_hosts(const char *val)
|
|
{
|
|
if (STREQ(val, "yes")) {
|
|
gopt.flags |= CFM_FULLY_QUALIFIED_HOSTS;
|
|
return 0;
|
|
} else if (STREQ(val, "no")) {
|
|
gopt.flags &= ~CFM_FULLY_QUALIFIED_HOSTS;
|
|
return 0;
|
|
}
|
|
|
|
fprintf(stderr, "conf: unknown value to fully_qualified_hosts \"%s\"\n", val);
|
|
return 1; /* unknown value */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_hesiod_base(const char *val)
|
|
{
|
|
#ifdef HAVE_MAP_HESIOD
|
|
gopt.hesiod_base = strdup((char *)val);
|
|
return 0;
|
|
#else /* not HAVE_MAP_HESIOD */
|
|
fprintf(stderr, "conf: hesiod_base option ignored. No Hesiod support available.\n");
|
|
return 1;
|
|
#endif /* not HAVE_MAP_HESIOD */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_karch(const char *val)
|
|
{
|
|
gopt.karch = strdup((char *)val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_pid_file(const char *val)
|
|
{
|
|
gopt.pid_file = strdup((char *)val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_local_domain(const char *val)
|
|
{
|
|
gopt.sub_domain = strdup((char *)val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_localhost_address(const char *val)
|
|
{
|
|
gopt.localhost_address = strdup((char *)val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_ldap_base(const char *val)
|
|
{
|
|
#ifdef HAVE_MAP_LDAP
|
|
gopt.ldap_base = strdup((char *)val);
|
|
return 0;
|
|
#else /* not HAVE_MAP_LDAP */
|
|
fprintf(stderr, "conf: ldap_base option ignored. No LDAP support available.\n");
|
|
return 1;
|
|
#endif /* not HAVE_MAP_LDAP */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_ldap_cache_seconds(const char *val)
|
|
{
|
|
#ifdef HAVE_MAP_LDAP
|
|
char *end;
|
|
|
|
gopt.ldap_cache_seconds = strtol((char *)val, &end, 10);
|
|
if (end == val) {
|
|
fprintf(stderr, "conf: bad LDAP cache (seconds) option: %s\n",val);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
#else /* not HAVE_MAP_LDAP */
|
|
fprintf(stderr, "conf: ldap_cache_seconds option ignored. No LDAP support available.\n");
|
|
return 1;
|
|
#endif /* not HAVE_MAP_LDAP */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_ldap_cache_maxmem(const char *val)
|
|
{
|
|
#ifdef HAVE_MAP_LDAP
|
|
char *end;
|
|
|
|
gopt.ldap_cache_maxmem = strtol((char *)val, &end, 10);
|
|
if (end == val) {
|
|
fprintf(stderr, "conf: bad LDAP cache (maxmem) option: %s\n",val);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
#else /* not HAVE_MAP_LDAP */
|
|
fprintf(stderr, "conf: ldap_cache_maxmem option ignored. No LDAP support available.\n");
|
|
return 1;
|
|
#endif /* not HAVE_MAP_LDAP */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_ldap_hostports(const char *val)
|
|
{
|
|
#ifdef HAVE_MAP_LDAP
|
|
gopt.ldap_hostports = strdup((char *)val);
|
|
return 0;
|
|
#else /* not HAVE_MAP_LDAP */
|
|
fprintf(stderr, "conf: ldap_hostports option ignored. No LDAP support available.\n");
|
|
return 1;
|
|
#endif /* not HAVE_MAP_LDAP */
|
|
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_ldap_proto_version(const char *val)
|
|
{
|
|
#ifdef HAVE_MAP_LDAP
|
|
char *end;
|
|
|
|
gopt.ldap_proto_version = strtol((char *)val, &end, 10);
|
|
if (end == val) {
|
|
fprintf(stderr, "conf: bad ldap_proto_version option: %s\n",val);
|
|
return 1;
|
|
}
|
|
|
|
if (gopt.ldap_proto_version < 0 || gopt.ldap_proto_version > LDAP_VERSION_MAX) {
|
|
fprintf(stderr, "conf: bad ldap_proto_version option value: %s\n",val);
|
|
return 1;
|
|
}
|
|
switch (gopt.ldap_proto_version) {
|
|
/* XXX: what about LDAP_VERSION1? */
|
|
case LDAP_VERSION2:
|
|
#ifdef LDAP_VERSION3
|
|
case LDAP_VERSION3:
|
|
#endif /* LDAP_VERSION3 */
|
|
#ifdef LDAP_VERSION4
|
|
case LDAP_VERSION4:
|
|
#endif /* LDAP_VERSION4 */
|
|
break;
|
|
default:
|
|
fprintf(stderr, "conf: unsupported ldap_proto_version option value: %s\n",val);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
#else /* not HAVE_MAP_LDAP */
|
|
fprintf(stderr, "conf: ldap_proto_version option ignored. No LDAP support available.\n");
|
|
return 1;
|
|
#endif /* not HAVE_MAP_LDAP */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_log_file(const char *val)
|
|
{
|
|
gopt.logfile = strdup((char *)val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_log_options(const char *val)
|
|
{
|
|
usage += switch_option((char *)val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_map_defaults(const char *val)
|
|
{
|
|
gopt.map_defaults = strdup((char *)val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_map_options(const char *val)
|
|
{
|
|
gopt.map_options = strdup((char *)val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_map_reload_interval(const char *val)
|
|
{
|
|
gopt.map_reload_interval = atoi(val);
|
|
if (gopt.map_reload_interval <= 0)
|
|
gopt.map_reload_interval = ONE_HOUR;
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_map_type(const char *val)
|
|
{
|
|
/* check if map type exist */
|
|
if (!mapc_type_exists(val)) {
|
|
fprintf(stderr, "conf: no such map type \"%s\"\n", val);
|
|
return 1;
|
|
}
|
|
gopt.map_type = strdup((char *)val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_mount_type(const char *val)
|
|
{
|
|
if (STREQ(val, "autofs")) {
|
|
#ifdef HAVE_FS_AUTOFS
|
|
gopt.flags |= CFM_MOUNT_TYPE_AUTOFS;
|
|
amd_use_autofs++;
|
|
return 0;
|
|
#else /* not HAVE_FS_AUTOFS */
|
|
fprintf(stderr, "conf: no autofs support available\n");
|
|
return 1;
|
|
#endif /* not HAVE_FS_AUTOFS */
|
|
} else if (STREQ(val, "nfs")) {
|
|
gopt.flags &= ~CFM_MOUNT_TYPE_AUTOFS;
|
|
return 0;
|
|
}
|
|
|
|
fprintf(stderr, "conf: unknown value to mount_type \"%s\"\n", val);
|
|
return 1; /* unknown value */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_portmap_program(const char *val)
|
|
{
|
|
gopt.portmap_program = atol(val);
|
|
/*
|
|
* allow alternate program numbers to be no more than 10 offset from
|
|
* official amd program number (300019).
|
|
*/
|
|
if (gopt.portmap_program < AMQ_PROGRAM ||
|
|
gopt.portmap_program > AMQ_PROGRAM + 10) {
|
|
gopt.portmap_program = AMQ_PROGRAM;
|
|
set_amd_program_number(gopt.portmap_program);
|
|
fprintf(stderr, "conf: illegal amd program number \"%s\"\n", val);
|
|
return 1;
|
|
}
|
|
|
|
set_amd_program_number(gopt.portmap_program);
|
|
return 0; /* all is OK */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_preferred_amq_port(const char *val)
|
|
{
|
|
gopt.preferred_amq_port = atoi(val);
|
|
|
|
/*
|
|
* No need to check value: preferred_amq_port is an unsigned short and 0
|
|
* is a valid number, meaning "any port".
|
|
*/
|
|
return 0; /* all is OK */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_nfs_allow_insecure_port(const char *val)
|
|
{
|
|
if (STREQ(val, "yes")) {
|
|
gopt.flags |= CFM_NFS_INSECURE_PORT;
|
|
return 0;
|
|
} else if (STREQ(val, "no")) {
|
|
gopt.flags &= ~CFM_NFS_INSECURE_PORT;
|
|
return 0;
|
|
}
|
|
|
|
fprintf(stderr, "conf: unknown value to nfs_allow_insecure_port \"%s\"\n", val);
|
|
return 1; /* unknown value */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_nfs_proto(const char *val)
|
|
{
|
|
if (STREQ(val, "udp") || STREQ(val, "tcp")) {
|
|
gopt.nfs_proto = strdup((char *)val);
|
|
return 0;
|
|
}
|
|
fprintf(stderr, "conf: illegal nfs_proto \"%s\"\n", val);
|
|
return 1;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_nfs_retransmit_counter(const char *val)
|
|
{
|
|
int i;
|
|
|
|
for (i=0; i<AMU_TYPE_MAX; ++i)
|
|
gopt.amfs_auto_retrans[i] = atoi(val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_nfs_retransmit_counter_udp(const char *val)
|
|
{
|
|
gopt.amfs_auto_retrans[AMU_TYPE_UDP] = atoi(val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_nfs_retransmit_counter_tcp(const char *val)
|
|
{
|
|
gopt.amfs_auto_retrans[AMU_TYPE_TCP] = atoi(val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_nfs_retry_interval(const char *val)
|
|
{
|
|
int i;
|
|
|
|
for (i=0; i<AMU_TYPE_MAX; ++i)
|
|
gopt.amfs_auto_timeo[i] = atoi(val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_nfs_retry_interval_udp(const char *val)
|
|
{
|
|
gopt.amfs_auto_timeo[AMU_TYPE_UDP] = atoi(val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_nfs_retry_interval_tcp(const char *val)
|
|
{
|
|
gopt.amfs_auto_timeo[AMU_TYPE_TCP] = atoi(val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_nfs_vers(const char *val)
|
|
{
|
|
int i = atoi(val);
|
|
|
|
if (i == 2 || i == 3) {
|
|
gopt.nfs_vers = i;
|
|
return 0;
|
|
}
|
|
fprintf(stderr, "conf: illegal nfs_vers \"%s\"\n", val);
|
|
return 1;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_nis_domain(const char *val)
|
|
{
|
|
#ifdef HAVE_MAP_NIS
|
|
gopt.nis_domain = strdup((char *)val);
|
|
return 0;
|
|
#else /* not HAVE_MAP_NIS */
|
|
fprintf(stderr, "conf: nis_domain option ignored. No NIS support available.\n");
|
|
return 1;
|
|
#endif /* not HAVE_MAP_NIS */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_normalize_hostnames(const char *val)
|
|
{
|
|
if (STREQ(val, "yes")) {
|
|
gopt.flags |= CFM_NORMALIZE_HOSTNAMES;
|
|
return 0;
|
|
} else if (STREQ(val, "no")) {
|
|
gopt.flags &= ~CFM_NORMALIZE_HOSTNAMES;
|
|
return 0;
|
|
}
|
|
|
|
fprintf(stderr, "conf: unknown value to normalize_hostnames \"%s\"\n", val);
|
|
return 1; /* unknown value */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_normalize_slashes(const char *val)
|
|
{
|
|
if (STREQ(val, "yes")) {
|
|
gopt.flags |= CFM_NORMALIZE_SLASHES;
|
|
return 0;
|
|
} else if (STREQ(val, "no")) {
|
|
gopt.flags &= ~CFM_NORMALIZE_SLASHES;
|
|
return 0;
|
|
}
|
|
|
|
fprintf(stderr, "conf: unknown value to normalize_slashes \"%s\"\n", val);
|
|
return 1; /* unknown value */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_os(const char *val)
|
|
{
|
|
gopt.op_sys = strdup((char *)val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_osver(const char *val)
|
|
{
|
|
gopt.op_sys_ver = strdup((char *)val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_plock(const char *val)
|
|
{
|
|
if (STREQ(val, "yes")) {
|
|
gopt.flags |= CFM_PROCESS_LOCK;
|
|
return 0;
|
|
} else if (STREQ(val, "no")) {
|
|
gopt.flags &= ~CFM_PROCESS_LOCK;
|
|
return 0;
|
|
}
|
|
|
|
fprintf(stderr, "conf: unknown value to plock \"%s\"\n", val);
|
|
return 1; /* unknown value */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_print_pid(const char *val)
|
|
{
|
|
if (STREQ(val, "yes")) {
|
|
gopt.flags |= CFM_PRINT_PID;
|
|
return 0;
|
|
} else if (STREQ(val, "no")) {
|
|
gopt.flags &= ~CFM_PRINT_PID;
|
|
return 0;
|
|
}
|
|
|
|
fprintf(stderr, "conf: unknown value to print_pid \"%s\"\n", val);
|
|
return 1; /* unknown value */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_print_version(const char *val)
|
|
{
|
|
if (STREQ(val, "yes")) {
|
|
char *vers = get_version_string();
|
|
fputs(vers, stderr);
|
|
XFREE(vers);
|
|
return 0;
|
|
} else if (STREQ(val, "no")) {
|
|
return 0;
|
|
}
|
|
|
|
fprintf(stderr, "conf: unknown value to print_version \"%s\"\n", val);
|
|
return 1; /* unknown value */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_restart_mounts(const char *val)
|
|
{
|
|
if (STREQ(val, "yes")) {
|
|
gopt.flags |= CFM_RESTART_EXISTING_MOUNTS;
|
|
return 0;
|
|
} else if (STREQ(val, "no")) {
|
|
gopt.flags &= ~CFM_RESTART_EXISTING_MOUNTS;
|
|
return 0;
|
|
}
|
|
|
|
fprintf(stderr, "conf: unknown value to restart_mounts \"%s\"\n", val);
|
|
return 1; /* unknown value */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_search_path(const char *val)
|
|
{
|
|
gopt.search_path = strdup((char *)val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_selectors_in_defaults(const char *val)
|
|
{
|
|
if (STREQ(val, "yes")) {
|
|
gopt.flags |= CFM_SELECTORS_IN_DEFAULTS;
|
|
return 0;
|
|
} else if (STREQ(val, "no")) {
|
|
gopt.flags &= ~CFM_SELECTORS_IN_DEFAULTS;
|
|
return 0;
|
|
}
|
|
|
|
fprintf(stderr, "conf: unknown value to enable_default_selectors \"%s\"\n", val);
|
|
return 1; /* unknown value */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_show_statfs_entries(const char *val)
|
|
{
|
|
if (STREQ(val, "yes")) {
|
|
gopt.flags |= CFM_SHOW_STATFS_ENTRIES;
|
|
return 0;
|
|
} else if (STREQ(val, "no")) {
|
|
gopt.flags &= ~CFM_SHOW_STATFS_ENTRIES;
|
|
return 0;
|
|
}
|
|
|
|
fprintf(stderr, "conf: unknown value to show_statfs_entries \"%s\"\n", val);
|
|
return 1; /* unknown value */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_truncate_log(const char *val)
|
|
{
|
|
if (STREQ(val, "yes")) {
|
|
gopt.flags |= CFM_TRUNCATE_LOG;
|
|
return 0;
|
|
} else if (STREQ(val, "no")) {
|
|
gopt.flags &= ~CFM_TRUNCATE_LOG;
|
|
return 0;
|
|
}
|
|
|
|
fprintf(stderr, "conf: unknown value to truncate_log \"%s\"\n", val);
|
|
return 1; /* unknown value */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_unmount_on_exit(const char *val)
|
|
{
|
|
if (STREQ(val, "yes")) {
|
|
gopt.flags |= CFM_UNMOUNT_ON_EXIT;
|
|
return 0;
|
|
} else if (STREQ(val, "no")) {
|
|
gopt.flags &= ~CFM_UNMOUNT_ON_EXIT;
|
|
return 0;
|
|
}
|
|
|
|
fprintf(stderr, "conf: unknown value to unmount_on_exit \"%s\"\n", val);
|
|
return 1; /* unknown value */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_use_tcpwrappers(const char *val)
|
|
{
|
|
#if defined(HAVE_TCPD_H) && defined(HAVE_LIBWRAP)
|
|
if (STREQ(val, "yes")) {
|
|
gopt.flags |= CFM_USE_TCPWRAPPERS;
|
|
return 0;
|
|
} else if (STREQ(val, "no")) {
|
|
gopt.flags &= ~CFM_USE_TCPWRAPPERS;
|
|
return 0;
|
|
}
|
|
#else /* not defined(HAVE_TCPD_H) && defined(HAVE_LIBWRAP) */
|
|
fprintf(stderr, "conf: no tcpd/libwrap support available\n");
|
|
return 1;
|
|
#endif /* not defined(HAVE_TCPD_H) && defined(HAVE_LIBWRAP) */
|
|
|
|
fprintf(stderr, "conf: unknown value to use_tcpwrappers \"%s\"\n", val);
|
|
return 1; /* unknown value */
|
|
}
|
|
|
|
|
|
static int
|
|
gopt_vendor(const char *val)
|
|
{
|
|
gopt.op_sys_vendor = strdup((char *)val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Collect one entry for a regular map
|
|
*/
|
|
static int
|
|
process_regular_option(const char *section, const char *key, const char *val, cf_map_t *cfm)
|
|
{
|
|
/* ensure that val is valid */
|
|
if (!section || section[0] == '\0' ||
|
|
!key || key[0] == '\0' ||
|
|
!val || val[0] == '\0' ||
|
|
!cfm) {
|
|
fprintf(stderr, "conf: process_regular_option: null entries\n");
|
|
return 1;
|
|
}
|
|
|
|
/* check if initializing a new map */
|
|
if (!cfm->cfm_dir)
|
|
cfm->cfm_dir = strdup((char *)section);
|
|
|
|
/* check for each possible field */
|
|
if (STREQ(key, "browsable_dirs"))
|
|
return ropt_browsable_dirs(val, cfm);
|
|
|
|
if (STREQ(key, "map_name"))
|
|
return ropt_map_name(val, cfm);
|
|
|
|
if (STREQ(key, "map_defaults"))
|
|
return ropt_map_defaults(val, cfm);
|
|
|
|
if (STREQ(key, "map_options"))
|
|
return ropt_map_options(val, cfm);
|
|
|
|
if (STREQ(key, "map_type"))
|
|
return ropt_map_type(val, cfm);
|
|
|
|
if (STREQ(key, "mount_type"))
|
|
return ropt_mount_type(val, cfm);
|
|
|
|
if (STREQ(key, "search_path"))
|
|
return ropt_search_path(val, cfm);
|
|
|
|
if (STREQ(key, "tag"))
|
|
return ropt_tag(val, cfm);
|
|
|
|
fprintf(stderr, "conf: unknown regular key \"%s\" for section \"%s\"\n",
|
|
key, section);
|
|
return 1; /* failed to match any command */
|
|
}
|
|
|
|
|
|
static int
|
|
ropt_browsable_dirs(const char *val, cf_map_t *cfm)
|
|
{
|
|
if (STREQ(val, "full")) {
|
|
cfm->cfm_flags |= CFM_BROWSABLE_DIRS_FULL;
|
|
return 0;
|
|
} else if (STREQ(val, "yes")) {
|
|
cfm->cfm_flags |= CFM_BROWSABLE_DIRS;
|
|
return 0;
|
|
} else if (STREQ(val, "no")) {
|
|
cfm->cfm_flags &= ~CFM_BROWSABLE_DIRS;
|
|
return 0;
|
|
}
|
|
|
|
fprintf(stderr, "conf: unknown value to browsable_dirs \"%s\"\n", val);
|
|
return 1; /* unknown value */
|
|
}
|
|
|
|
|
|
static int
|
|
ropt_map_name(const char *val, cf_map_t *cfm)
|
|
{
|
|
cfm->cfm_name = strdup((char *)val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
ropt_map_defaults(const char *val, cf_map_t *cfm)
|
|
{
|
|
cfm->cfm_defaults = strdup((char *)val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
ropt_map_options(const char *val, cf_map_t *cfm)
|
|
{
|
|
cfm->cfm_opts = strdup((char *)val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
ropt_map_type(const char *val, cf_map_t *cfm)
|
|
{
|
|
/* check if map type exist */
|
|
if (!mapc_type_exists(val)) {
|
|
fprintf(stderr, "conf: no such map type \"%s\"\n", val);
|
|
return 1;
|
|
}
|
|
cfm->cfm_type = strdup((char *)val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
ropt_mount_type(const char *val, cf_map_t *cfm)
|
|
{
|
|
if (STREQ(val, "autofs")) {
|
|
#ifdef HAVE_FS_AUTOFS
|
|
cfm->cfm_flags |= CFM_MOUNT_TYPE_AUTOFS;
|
|
amd_use_autofs++;
|
|
return 0;
|
|
#else /* not HAVE_FS_AUTOFS */
|
|
fprintf(stderr, "conf: no autofs support available\n");
|
|
return 1;
|
|
#endif /* not HAVE_FS_AUTOFS */
|
|
} else if (STREQ(val, "nfs")) {
|
|
cfm->cfm_flags &= ~CFM_MOUNT_TYPE_AUTOFS;
|
|
return 0;
|
|
}
|
|
|
|
fprintf(stderr, "conf: unknown value to mount_type \"%s\"\n", val);
|
|
return 1; /* unknown value */
|
|
}
|
|
|
|
|
|
static int
|
|
ropt_search_path(const char *val, cf_map_t *cfm)
|
|
{
|
|
cfm->cfm_search_path = strdup((char *)val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
ropt_tag(const char *val, cf_map_t *cfm)
|
|
{
|
|
cfm->cfm_tag = strdup((char *)val);
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Process one collected map.
|
|
*/
|
|
static int
|
|
process_one_regular_map(const cf_map_t *cfm)
|
|
{
|
|
if (!cfm->cfm_name) {
|
|
fprintf(stderr, "conf: map_name must be defined for map \"%s\"\n", cfm->cfm_dir);
|
|
return 1;
|
|
}
|
|
/*
|
|
* If map has no tag defined, process the map.
|
|
* If no conf_tag was set in amd -T, process all untagged entries.
|
|
* If a tag is defined, then process it only if it matches the map tag.
|
|
*/
|
|
if (!cfm->cfm_tag ||
|
|
(conf_tag && STREQ(cfm->cfm_tag, conf_tag))) {
|
|
#ifdef DEBUG_CONF
|
|
fprintf(stderr, "processing map %s (flags=0x%x)...\n",
|
|
cfm->cfm_dir, cfm->cfm_flags);
|
|
#endif /* DEBUG_CONF */
|
|
root_newmap(cfm->cfm_dir,
|
|
cfm->cfm_opts ? cfm->cfm_opts : "",
|
|
cfm->cfm_name,
|
|
cfm);
|
|
} else {
|
|
fprintf(stderr, "skipping map %s...\n", cfm->cfm_dir);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Process all regular maps in conf file (if any)
|
|
*/
|
|
int
|
|
process_all_regular_maps(void)
|
|
{
|
|
cf_map_t *tmp_map = head_map;
|
|
|
|
/*
|
|
* If the amd.conf file only has a [global] section (pretty useless
|
|
* IMHO), there's nothing to process
|
|
*/
|
|
if (!tmp_map)
|
|
return 0;
|
|
|
|
while (tmp_map) {
|
|
if (process_one_regular_map(tmp_map) != 0)
|
|
return 1;
|
|
tmp_map = tmp_map->cfm_next;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Find a cf_map_t for a given map name.
|
|
* Return NULL if not found.
|
|
*/
|
|
cf_map_t *
|
|
find_cf_map(const char *name)
|
|
{
|
|
|
|
cf_map_t *tmp_map = head_map;
|
|
|
|
if (!tmp_map || !name)
|
|
return NULL;
|
|
|
|
while (tmp_map) {
|
|
if (STREQ(tmp_map->cfm_dir,name)) {
|
|
return tmp_map;
|
|
}
|
|
tmp_map = tmp_map->cfm_next;
|
|
}
|
|
return NULL;
|
|
}
|