lib/configuration.cc

Go to the documentation of this file.

//
// nis-util - NIS Administration Utilities
// Copyright (C) 2012 Peter Miller
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or (at
// your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include <lib/ac/unistd.h>
#include <libexplain/output.h>
#include <libexplain/program_name.h>

#include <lib/boolean.h>
#include <lib/configuration.h>
#include <lib/configuration/item/boolean.h>
#include <lib/configuration/item/integer.h>
#include <lib/configuration/item/string.h>
#include <lib/home.h>
#include <lib/input/file.h>
#include <lib/input/string.h>
#include <lib/libdir.h>
#include <lib/path_join.h>


configuration *configuration::singleton;


configuration::~configuration()
{
}


configuration::configuration()
{
}


configuration &
configuration::get_singleton(void)
{
    if (!singleton)
    {
        singleton = new configuration();
        singleton->load();
    }
    return *singleton;
}


rcstring
configuration::get_string(const rcstring &section_name,
    const rcstring &item_name) const
{
    sections_t::const_iterator it = sections.find(section_name);
    if (it == sections.end())
        return rcstring();
    assert(it->second);
    return it->second->get_string_value(item_name);
}


bool
configuration::get_bool(const rcstring &section_name, const rcstring &item_name)
    const
{
    sections_t::const_iterator it = sections.find(section_name);
    if (it == sections.end())
        return false;
    assert(it->second);
    return it->second->get_bool_value(item_name);
}


long
configuration::get_long(const rcstring &section_name, const rcstring &item_name)
    const
{
    sections_t::const_iterator it = sections.find(section_name);
    if (it == sections.end())
        return 0;
    assert(it->second);
    return it->second->get_long_value(item_name);
}


void
configuration::set(const rcstring &section_name,
    const configuration_item::pointer &item)
{
    assert(section_name.empty() ||
        section_name == canonical_name(section_name));
    assert(item->get_name() == canonical_name(item->get_name()));

    sections_t::iterator it = sections.find(section_name);
    if (it == sections.end())
    {
        configuration_section::pointer sp =
            configuration_section::create(section_name);
        sections.insert(sections_t::value_type(section_name, sp));
        sp->set(item);
    }
    else
    {
        assert(it->second);
        it->second->set(item);
    }
}


static bool
test_mode(void)
{
    const char *cp = getenv("NIS_UTIL_TEST_MODE");
    if (!cp)
        return false;
    bool value = false;
    if (!boolean_from_string(cp, value))
    {
        explain_output_error_and_die
        (
            "the NIS_UTIL_TEST_MODE environment variable must "
                "be either \"true\" or \"false\", not %s",
            rcstring(cp).quote_c().c_str()
        );
        return false;
    }
    return value;
}


void
configuration::load(void)
{
    //
    // some builtin defaults
    //
    {
        // This host's sysconf(_SC_NGROUPS_MAX) may be too generous for
        // all NIS clients.  Be conservative.  The value of 16 is a very
        // well known NFS implimentation limit.
        cfg.set_builtin_long(SECTION_GROUP, "per-user-maximum", 16);

        cfg.set_builtin_bool(SECTION_GLOBAL, "verbose", true);
        cfg.set_builtin_bool(SECTION_GLOBAL, "pedentic", true);
        cfg.set_builtin_bool(SECTION_GLOBAL, ITEM_WARNING, true);
    }

    if (test_mode())
        return;

    //
    // the $SYCONFDIR/nis-util.conf file
    // if it exists
    //
    {
        rcstring path = path_join(configured_sysconfdir(), "nis-util.conf");
        if (access(path.c_str(), F_OK) == 0)
        {
            level_t level = configuration_item::level_etc_nis_util_conf;
            input::pointer ip = input_file::create(path);
            parse(level, ip);
        }
    }

    //
    // the ~/.nis-util.rc file
    // if it exists
    //
    {
        rcstring path = path_join(home(), ".nis-util.rc");
        if (access(path.c_str(), F_OK) == 0)
        {
            level_t level = configuration_item::level_home_nis_util_rc;
            input::pointer ip = input_file::create(path);
            parse(level, ip);
        }
    }

    //
    // the NIS_UTIL evironment variable
    //
    {
        level_t level = configuration_item::level_nis_util_env;
        input::pointer ip = input_string::create_env("NIS_UTIL");
        parse(level, ip);
    }

    //
    // the util-specific environment variable
    //
    {
        level_t level = configuration_item::level_nis_util_prog_env;
        rcstring name(explain_program_name_get());
        name = name.upcase().identifier();
        input::pointer ip = input_string::create_env(name);
        parse(level, ip);
    }
}


void
configuration::load_command_line_file(const rcstring &filename)
{
    level_t level = configuration_item::level_command_line_file;
    input::pointer ip = input_file::create(filename);
    parse(level, ip);
}


void
configuration::set_command_line_string(const source_location &locn,
    const rcstring &section_name, const rcstring &item_name,
    const rcstring &value)
{
    level_t level = configuration_item::level_command_line_option;
    configuration_item::pointer item =
        configuration_item_string::create(locn, level, item_name, value);
    set(section_name, item);
}


void
configuration::set_command_line_long(const source_location &locn,
    const rcstring &section_name, const rcstring &item_name, long value)
{
    level_t level = configuration_item::level_command_line_option;
    configuration_item::pointer item =
        configuration_item_integer::create(locn, level, item_name, value);
    set(section_name, item);
}


void
configuration::set_command_line_bool(const source_location &locn,
    const rcstring &section_name, const rcstring &item_name, bool value)
{
    level_t level = configuration_item::level_command_line_option;
    configuration_item::pointer item =
        configuration_item_boolean::create(locn, level, item_name, value);
    set(section_name, item);
}


void
configuration::set_command_line_bool(const source_location &locn,
    const rcstring &item_name, bool value)
{
    level_t level = configuration_item::level_command_line_option;
    configuration_item::pointer item =
        configuration_item_boolean::create(locn, level, item_name, value);
    set(SECTION_GLOBAL, item);
}


static int bn;


void
configuration::set_builtin_string(const rcstring &section_name,
    const rcstring &item_name, const rcstring &value)
{
    source_location locn("builtin", ++bn);
    level_t level = configuration_item::level_builtin;
    configuration_item::pointer item =
        configuration_item_string::create(locn, level, item_name, value);
    set(section_name, item);
}


void
configuration::set_builtin_long(const rcstring &section_name,
    const rcstring &item_name, long value)
{
    source_location locn("builtin", ++bn);
    level_t level = configuration_item::level_builtin;
    configuration_item::pointer item =
        configuration_item_integer::create(locn, level, item_name, value);
    set(section_name, item);
}


void
configuration::set_builtin_bool(const rcstring &section_name,
    const rcstring &item_name, bool value)
{
    source_location locn("builtin", ++bn);
    level_t level = configuration_item::level_builtin;
    configuration_item::pointer item =
        configuration_item_boolean::create(locn, level, item_name, value);
    set(section_name, item);
}


void
configuration::print(void)
    const
{
    for
    (
        sections_t::const_iterator it = sections.begin();
        it != sections.end();
        ++it
    )
    {
        it->second->print();
    }
}


// vim: set ts=8 sw=4 et :