common/cmconfig.cc

Go to the documentation of this file.

//
//
//
// ***** BEGIN LICENSE BLOCK *****
// Version: MPL 1.1/GPL 2.0/LGPL 2.1
// 
// The contents of this file are subject to the Mozilla Public License
// Version 1.1 (the "License"); you may not use this file except in
// compliance with the License. You may obtain a copy of the License at
// http://www.mozilla.org/MPL/
// 
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
// the License for the specific language governing rights and limitations
// under the License.
// 
// The Original Code is the consmgr network/serial-line monitoring package.
// 
// The Initial Developer of the Original Code is Chris P. Ross.
// Portions created by the Initial Developer are Copyright (C) 2000-2008
// the Initial Developer.  All Rights Reserved.
// 
// Contributor(s):
// 
// Alternatively, the contents of this file may be used under the terms of
// either the GNU General Public License Version 2 or later (the "GPL"), or
// the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
// in which case the provisions of the GPL or the LGPL are applicable instead
// of those above. If you wish to allow use of your version of this file only
// under the terms of either the GPL or the LGPL, and not to allow others to
// use your version of this file under the terms of the MPL, indicate your
// decision by deleting the provisions above and replace them with the notice
// and other provisions required by the GPL or the LGPL. If you do not delete
// the provisions above, a recipient may use your version of this file under
// the terms of any one of the MPL, the GPL or the LGPL.
// 
// ***** END LICENSE BLOCK *****

#include "cmconfig.h"
#include "consmgr.h"
#ifdef  HAVE_GETCAP
# include "cfg_getcap.h"
#endif  /* HAVE_GETCAP */
#ifdef  HAVE_LIBCONFIG
# include "cfg_libconfig.h"
#endif  /* HAVE_LIBCONFIG */
#ifdef  HAVE_YAML
# include "cfg_yaml.h"
#endif  /* HAVE_YAML */

#include <sstream>

//
// Constructors & Destructor
//
#if MULTIPLE_CONFIG_FILES
ConfigDB::ConfigDB(void)
{
    this->init();
}

void
ConfigDB::init(void)
{
    // Instantiate the mutex.  The Config::files_mtx mutex controls
    // accesses to the vector, and accesses to things referred to
    // by the vector entries.
    pret = pthread_mutex_init(&files_mtx, NULL);
    PTHREAD_CHECK_AND_THROW(pret, "mutex_init(files_mtx)");

    return;
}

ConfigDB::ConfigDB(const string &file)
{
    this->init();
    this->add_db(file);

    return;
}

ConfigDB::~ConfigDB(void)
{
    pret = pthread_mutex_destroy(&files_mtx);
    PTHREAD_CHECK_AND_THROW(pret, "mutex_destroy(files_mtx)");

    return;
}

//
// Member functions
//

void
ConfigDB::add_db(const string &file)
{
    // Lock the files_mtx mutex.  We're dealing with the std::vector<> of
    // filenames, so we use it for that as well as accessing the underlying
    // database [files].
    pret = pthread_mutex_lock(&files_mtx);
    PTHREAD_CHECK_AND_THROW(pret, "mutex_lock(files_mtx)");

    clog << "ConfigDB::add_db: Adding database '" << file << "'" << endl;

    db_files.push_back(file);

    pret = pthread_mutex_unlock(&files_mtx);
    PTHREAD_CHECK_AND_THROW(pret, "mutex_unlock(files_mtx)");

    return;
}

int
ConfigDB::db_count(void)
{
    int         count;

    // Lock the files_l mutex.  We're dealing with the std::vector<> of
    // filenames, so we use it for that as well as accessing the underlying
    // database [files].
    pret = pthread_mutex_lock(&files_mtx);
    PTHREAD_CHECK_AND_THROW(pret, "mutex_lock(files_mtx)");

    count = db_files.size();

    pret = pthread_mutex_unlock(&files_mtx);
    PTHREAD_CHECK_AND_THROW(pret, "mutex_unlock(files_mtx)");

    return count;
}
#endif  /* MULTIPLE_CONFIG_FILES */

//
// Implementation of the generic Config class
//

Config::Config(const string &filename) : filename(filename)
{
}

Config::~Config()
{
}

const char* Config::keytexts[] = {
    "host",
    "port",
    "local_socket",
    "logfile",
    "device",
};
const std::vector<std::string>
    Config::config_keys(Config::keytexts,
                        Config::keytexts + (sizeof(Config::keytexts) /
                                            sizeof(Config::keytexts[0])));


//
// Here is the basis of the ConfigException class.  The base class can be
// constructed, for generic cases, but ideally the more-specific subclasses
// should be constructed.
//
ConfigException::ConfigException(const string &r) : reason(r)   {}
ConfigException::ConfigException(const string &r, const string &f, const int l)
        : reason(r), file(f), line(l)   {}

void
ConfigException::set_file(const string &f)
{
    file = f;
    return;
}

void
ConfigException::set_line(const int l)
{
    line = l;
    return;
}

const char *
ConfigException::what() const throw()
{
    std::ostringstream  reason_str;

    reason_str << reason;
    if (file.length() > 0) {
        if (line > 0)
            reason_str << " at " << file << ":" << line;
        else
            reason_str << " in " << file;
    } else {
        if (line > 0)
            reason_str << " on line " << line;
    }

    return(reason_str.str().c_str());
}

const char *
ConfigBadFile::what() const throw()
{
    std::ostringstream  reason_str;

    reason_str << "Cannot read configuration file ";
    if (file.length() > 0)
        reason_str << file;
    if (saved_errno)
        reason_str << ": " << ::strerror(saved_errno);

    return(reason_str.str().c_str());
}

// Subclass constructors, since the base class is not expected to be
// constructed directly...
ConfigParseException::ConfigParseException(const int l, const string &r)
        : ConfigException("Parse error")
{
    line = l;
}

// cmconfig.h declares this such that the second argument to default to ""
ConfigUnfoundException::ConfigUnfoundException(const string &element,
                                               const string &r)
        : ConfigException(r), node(element)
{
}

const char *
ConfigUnfoundException::what(void) const throw()
{
    // If the reason string was set for a ConfigUnfoundException, assume
    // they already took care of the formatting for us...
    if (! reason.empty())
        return(reason.c_str());

    std::ostringstream  reason_str;

    reason_str << "Unable to find element '" << node << "' in configuration";
    if (file.length() > 0) {
        reason_str << " file (" << file << ")";
    }
    reason_str << ".";

    return(reason_str.str().c_str());
}

//
// The factory that will produce the relevant Config subclass based on parameter
//
Config *
ConfigFactory::config_object(const string &filename)
{
    // Return [the correct] subclass of Config based on the filename
    // extension...
    // XXX - Should I scan the *contents* of the file to do this "better"
    size_t      suffix_pos = filename.find_last_of('.');

    // Verify that we have access to the file.
    // XXX - This will need to be removed if there's ever a Config subclass
    // that doesn't treat this string as a name of an actual file in the
    // filesystem...
    if (::access(filename.c_str(), R_OK) < 0)
        throw ConfigBadFile(filename, errno);
#if HAVE_YAML
    // YAML seems like a good idea....
    if ((suffix_pos != string::npos) &&
        (filename.substr(suffix_pos) == ".yaml")) {
#ifdef  CONFIGURATION_DEBUGGING
        cerr << "Returning a YAML config object" << endl;
#endif  /* CONFIGURATION_DEBUGGING */
        return new_config<YAML>(filename);
    } else
#endif
#if HAVE_LIBCONFIG
    if ((suffix_pos != string::npos) &&
        (filename.substr(suffix_pos) == ".cfg")) {
#ifdef  CONFIGURATION_DEBUGGING
        cerr << "Config file is a libconfig config file?" << endl;
#endif  /* CONFIGURATION_DEBUGGING */
        return new_config<LibConfig>(filename);
    } else
#endif
#if HAVE_GETCAP
#ifdef  CONFIGURATION_DEBUGGING
    clog << "Presuming '" << filename << "' is a termcap-style file." << endl;
#endif  /* CONFIGURATION_DEBUGGING */
    return new_config<Getcap>(filename);
#endif  /* HAVE_GETCAP */

    throw string("Unable to instantiate a Config element for file " + filename);
}

template <class CFG_type>
Config *ConfigFactory::new_config(const string &filename)
{
    return new CFG_type(filename);
}

---