kea/src/bin/dhcp6/config_parser.cc

// Copyright (C) 2010  Internet Systems Consortium, Inc. ("ISC")
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
// AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
// PERFORMANCE OF THIS SOFTWARE.

#include <stdint.h>
#include <iostream>
#include <vector>
#include <map>
#include <boost/foreach.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string.hpp>
#include <cc/data.h>
#include <asiolink/io_address.h>
#include <dhcp6/config_parser.h>
#include <dhcp/triplet.h>
#include <dhcp/pool.h>
#include <dhcp/subnet.h>
#include <dhcp/cfgmgr.h>

using namespace std;
using namespace isc::data;
using namespace isc::asiolink;

namespace isc {
namespace dhcp {

typedef boost::shared_ptr<Dhcp6ConfigParser> ParserPtr;
typedef pair<string, ConstElementPtr> ConfigPair;
typedef std::vector<ParserPtr> ParserCollection;
typedef Dhcp6ConfigParser* ParserFactory(const std::string& config_id);

typedef std::map<std::string, ParserFactory*> FactoryMap;

typedef std::map<string, uint32_t> Uint32Storage;
/// @brief That is a map with global parameters that will be used as defaults
Uint32Storage uint32_defaults;

typedef std::map<string, string> StringStorage;
StringStorage string_defaults;

typedef std::vector<Pool6Ptr> PoolStorage;
PoolStorage pool_defaults;

/// @brief a dummy configuration parser
///
/// It is a debugging parser. It does not configure anything,
/// will accept any configuration and will just print it out
/// on commit.
class DummyParser : public Dhcp6ConfigParser {
public:
    DummyParser(const std::string& param_name)
        :param_name_(param_name) {
    }
    virtual void build(ConstElementPtr new_config) {
        value_ = new_config;
    }
    virtual void commit() {
        // debug message. The whole DummyParser class is used only for parser
        // debugging, and is not used in production code. It is very convenient
        // to keep it around. Please do not turn this cout into logger calls
        std::cout << "Commit for token: [" << param_name_ << "] = ["
                  << value_->str() << "]" << std::endl;
    }

    static Dhcp6ConfigParser* Factory(const std::string& param_name) {
        return (new DummyParser(param_name));
    }

protected:
    std::string param_name_;
    ConstElementPtr value_;
};

class Uint32Parser : public Dhcp6ConfigParser {
public:
    Uint32Parser(const std::string& param_name)
        :storage_(&uint32_defaults), param_name_(param_name) {
    }

    virtual void build(ConstElementPtr value) {
        try {
            value_ = boost::lexical_cast<uint32_t>(value->str());
        } catch (const boost::bad_lexical_cast &) {
            isc_throw(BadValue, "Failed to parse value " << value->str()
                      << " as unsigned 32-bit integer.");
        }
        cout << "### storing " << param_name_ << "=" << value_ <<
          " in " << storage_ << endl;
        storage_->insert(pair<string, uint32_t>(param_name_, value_));
    }

    virtual void commit() {
    }

    static Dhcp6ConfigParser* Factory(const std::string& param_name) {
        return (new Uint32Parser(param_name));
    }

    void setStorage(Uint32Storage* storage) {
        storage_ = storage;
    }

protected:
    Uint32Storage * storage_;
    std::string param_name_;
    uint32_t value_;
};

class StringParser : public Dhcp6ConfigParser {
public:
    StringParser(const std::string& param_name)
        :storage_(&string_defaults), param_name_(param_name) {
    }

    virtual void build(ConstElementPtr value) {
        value_ = value->str();
        boost::erase_all(value_, "\"");
        storage_->insert(pair<string, string>(param_name_, value_));
    }

    virtual void commit() {
    }

    static Dhcp6ConfigParser* Factory(const std::string& param_name) {
        return (new StringParser(param_name));
    }

    void setStorage(StringStorage * storage) {
        storage_ = storage;
    }

protected:
    StringStorage * storage_;
    std::string param_name_;
    std::string value_;
};

class InterfaceListConfigParser : public Dhcp6ConfigParser {
public:
    InterfaceListConfigParser(const std::string& param_name) {
        if (param_name != "interface") {
            isc_throw(NotImplemented, "Internal error. Interface configuration "
                      "parser called for the wrong parameter: " << param_name);
        }
    }
    virtual void build(ConstElementPtr value) {
        BOOST_FOREACH(ConstElementPtr iface, value->listValue()) {
            interfaces_.push_back(iface->str());
            cout << "#### Configured to listen on interface " << iface->str() << endl;
        }
    }

    virtual void commit() {
        /// @todo: Implement per interface listening. Currently always listening on all
        /// interfaces.
    }

    static Dhcp6ConfigParser* Factory(const std::string& param_name) {
        return (new InterfaceListConfigParser(param_name));
    }

protected:
    vector<string> interfaces_;
};

class PoolParser : public Dhcp6ConfigParser {
public:
    PoolParser(const std::string& /*param_name*/)
        :pools_(NULL) {
        // ignore parameter name, it is always Dhcp6/subnet6[X]/pool
    }
    void build(ConstElementPtr pools_list) {
        // setStorage() should have been called before build
        if (!pools_) {
          isc_throw(NotImplemented, "Parser logic error. No pool storage set,"
                    " but pool parser asked to parse pools");
        }

        BOOST_FOREACH(ConstElementPtr text_pool, pools_list->listValue()) {



            // That should be a single pool representation. It should contain
            // text is form prefix/len or first - last. Note that spaces
            // are allowed
            string txt = text_pool->stringValue();

            // first let's remove any spaces or tabs
            boost::erase_all(txt, " ");
            boost::erase_all(txt, "\t");

            size_t pos = txt.find("/");
            if (pos != string::npos) {
                IOAddress addr("::");
                uint8_t len = 0;
                try {
                    addr = IOAddress(txt.substr(0, pos));
                    string num = txt.substr(pos+1);

                    // it is lexical cast to int and then downcast to uint8_t
                    // direct cast to uint8_t (which is really an unsigned char)
                    // will result in interpreting the first digit as output
                    // value and throwing exception if length written on two
                    // digits (because there are extra characters left over)
                    len = boost::lexical_cast<int>(num);
                } catch (...)  {
                    isc_throw(Dhcp6ConfigError, "Failed to parse pool "
                              "definition: " << text_pool->stringValue());
                }

                cout << "#### Creating Pool6(TYPE_IA, " <<  addr.toText() << "/"
                     << (int)len << ")" << endl;
                // using prefix/len notation
                Pool6Ptr pool(new Pool6(Pool6::TYPE_IA, addr, len));
                pools_->push_back(pool);
                continue;
            }

            pos = txt.find("-");
            if (pos != string::npos) {
                IOAddress min(txt.substr(0,pos-1));
                IOAddress max(txt.substr(pos+1));

                cout << "#### Creating Pool6(TYPE_IA, " << min.toText() << ","
                     << max.toText() << ")" << endl;

                Pool6Ptr pool(new Pool6(Pool6::TYPE_IA, min, max));

                pools_->push_back(pool);
                continue;
            }

            isc_throw(Dhcp6ConfigError, "Failed to parse pool definition:"
                      << text_pool->stringValue() <<
                      ". Does not contain - (for min-max) nor / (prefix/len)");
        }
    }
    void setStorage(PoolStorage* storage) {
        pools_ = storage;
    }

    void commit() {}

    static Dhcp6ConfigParser* Factory(const std::string& param_name) {
        return (new PoolParser(param_name));
    }

protected:
    PoolStorage * pools_;

};

/// @brief this class parses a single subnet
class Subnet6ConfigParser : public Dhcp6ConfigParser {
public:
    Subnet6ConfigParser(const std::string& param_name) {
    }

    void build(ConstElementPtr subnet) {

        cout << "#### Subnet6ConfigParser::build(): parsing: [" << subnet->str() << "]" << endl;
        BOOST_FOREACH(ConfigPair param, subnet->mapValue()) {

            ParserPtr parser(createSubnet6ConfigParser(param.first));

            // if this is an Uint32 parser, tell it to store the values
            // in values_, rather than in global storage
            boost::shared_ptr<Uint32Parser> uintParser =
                boost::dynamic_pointer_cast<Uint32Parser>(parser);
            if (uintParser) {
                uintParser->setStorage(&uint32_values_);
            }

            boost::shared_ptr<StringParser> stringParser =
                boost::dynamic_pointer_cast<StringParser>(parser);
            if (stringParser) {
                stringParser->setStorage(&string_values_);
            }

            boost::shared_ptr<PoolParser> poolParser =
                boost::dynamic_pointer_cast<PoolParser>(parser);
            if (poolParser) {
                poolParser->setStorage(&pools_);
            }

            parser->build(param.second);
            parsers_.push_back(parser);
        }

        // Ok, we now have subnet parsed
    }

    void commit() {

        StringStorage::const_iterator it = string_values_.find("subnet");
        cout << "#### Subnet6ConfigParser::commit() string_values_.size()="
             << string_values_.size() << endl;
        if (it == string_values_.end()) {
            isc_throw(Dhcp6ConfigError,
                      "Mandatory subnet definition in subnet missing");
        }
        string subnet_txt = it->second;
        boost::erase_all(subnet_txt, " ");
        boost::erase_all(subnet_txt, "\t");

        size_t pos = subnet_txt.find("/");
        if (pos == string::npos) {
            isc_throw(Dhcp6ConfigError,
                      "Invalid subnet syntax (prefix/len expected):" << it->second);
        }
        IOAddress addr(subnet_txt.substr(0, pos));
        uint8_t len = boost::lexical_cast<unsigned int>(subnet_txt.substr(pos + 1));

        Triplet<uint32_t> t1 = getParam("renew-timer");
        Triplet<uint32_t> t2 = getParam("rebind-timer");
        Triplet<uint32_t> pref = getParam("preferred-lifetime");
        Triplet<uint32_t> valid = getParam("valid-lifetime");

        cout << "#### Adding subnet " << addr.toText() << "/" << (int)len
             << " with params t1=" << t1 << ", t2=" << t2 << ", pref="
             << pref << ", valid=" << valid << endl;

        Subnet6Ptr subnet(new Subnet6(addr, len, t1, t2, pref, valid));



        CfgMgr::instance().addSubnet6(subnet);
    }

protected:
    Dhcp6ConfigParser* createSubnet6ConfigParser(const std::string& config_id) {
        FactoryMap factories;

        factories.insert(pair<string, ParserFactory*>(
                             "preferred-lifetime", Uint32Parser::Factory));
        factories.insert(pair<string, ParserFactory*>(
                             "valid-lifetime", Uint32Parser::Factory));
        factories.insert(pair<string, ParserFactory*>(
                             "renew-timer", Uint32Parser::Factory));
        factories.insert(pair<string, ParserFactory*>(
                             "rebind-timer", Uint32Parser::Factory));

        factories.insert(pair<string, ParserFactory*>(
                             "subnet", StringParser::Factory));

        factories.insert(pair<string, ParserFactory*>(
                             "pool", PoolParser::Factory));

        FactoryMap::iterator f = factories.find(config_id);
        if (f == factories.end()) {
            // Used for debugging only.
            // return new DummyParser(config_id);

            isc_throw(NotImplemented,
                      "Parser error: Subnet6 parameter not supported: "
                      << config_id);
        }
        return (f->second(config_id));
    }

    Triplet<uint32_t> getParam(const std::string& name) {
        uint32_t value = 0;
        bool found = false;
        Uint32Storage::iterator global = uint32_defaults.find(name);
        if (global != uint32_defaults.end()) {
            value = global->second;
            found = true;
        }

        Uint32Storage::iterator local = uint32_values_.find(name);
        if (local != uint32_values_.end()) {
            value = local->second;
            found = true;
        }

        if (found) {
            return (Triplet<uint32_t>(value));
        } else {
            isc_throw(Dhcp6ConfigError, "Mandatory parameter " << name
                      << " missing (no global default and no subnet-"
                      << "specific value)");
        }
    }

    Uint32Storage uint32_values_;
    StringStorage string_values_;
    PoolStorage pools_;
    ParserCollection parsers_;
};

/// @brief this class parses list of subnets
class Subnets6ListConfigParser : public Dhcp6ConfigParser {
public:
    Subnets6ListConfigParser(const std::string& param_name) {
    }

    void build(ConstElementPtr subnets_list) {

        // No need to define FactoryMap here. There's only one type
        // used: Subnet6ConfigParser

        BOOST_FOREACH(ConstElementPtr subnet, subnets_list->listValue()) {

            ParserPtr parser(new Subnet6ConfigParser("subnet"));
            parser->build(subnet);
            subnets_.push_back(parser);
        }

    }

    void commit() {
        BOOST_FOREACH(ParserPtr subnet, subnets_) {
            subnet->commit();
        }

    }

    static Dhcp6ConfigParser* Factory(const std::string& param_name) {
        return (new Subnets6ListConfigParser(param_name));
    }

    ParserCollection subnets_;
};

/// @brief creates global parsers
///
/// This method creates global parsers that parse global parameters, i.e.
/// those that take format of Dhcp6/param1, Dhcp6/param2 and so forth.
Dhcp6ConfigParser* createGlobalDhcp6ConfigParser(const std::string& config_id) {
    FactoryMap factories;

    //
    factories.insert(pair<string, ParserFactory*>(
                         "preferred-lifetime", Uint32Parser::Factory));
    factories.insert(pair<string, ParserFactory*>(
                         "valid-lifetime", Uint32Parser::Factory));
    factories.insert(pair<string, ParserFactory*>(
                         "renew-timer", Uint32Parser::Factory));
    factories.insert(pair<string, ParserFactory*>(
                         "rebind-timer", Uint32Parser::Factory));

    factories.insert(pair<string, ParserFactory*>(
                         "interface", InterfaceListConfigParser::Factory));
    factories.insert(pair<string, ParserFactory*>(
                         "subnet6", Subnets6ListConfigParser::Factory));

    factories.insert(pair<string, ParserFactory*>(
                         "version", StringParser::Factory));

    FactoryMap::iterator f = factories.find(config_id);
    if (f == factories.end()) {
        // Used for debugging only.
        // return new DummyParser(config_id);

        isc_throw(NotImplemented,
                  "Parser error: Global configuration parameter not supported: "
                  << config_id);
    }
    return (f->second(config_id));
}

void
configureDhcp6Server(Dhcpv6Srv& server, ConstElementPtr config_set) {
    if (!config_set) {
        isc_throw(Dhcp6ConfigError,
                  "Null pointer is passed to configuration parser");
    }

    ParserCollection parsers;
    try {
        BOOST_FOREACH(ConfigPair config_pair, config_set->mapValue()) {

            ParserPtr parser(createGlobalDhcp6ConfigParser(config_pair.first));
            parser->build(config_pair.second);
            parsers.push_back(parser);
        }
    } catch (const Dhcp6ConfigError& ex) {
        throw;                  // simply rethrowing it
    } catch (const isc::Exception& ex) {
        isc_throw(Dhcp6ConfigError, "Server configuration failed: " <<
                  ex.what());
    }

    try {
        BOOST_FOREACH(ParserPtr parser, parsers) {
            parser->commit();
        }
    } catch (...) {
        isc_throw(Dhcp6ConfigError, "Unrecoverable error: "
                  "a configuration parser threw in commit");
    }
}

}; // end of isc::dhcp namespace
}; // end of isc namespace