dhcp6/parser_context.h

Go to the documentation of this file.

// Copyright (C) 2015-2024 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef PARSER_CONTEXT_H
#define PARSER_CONTEXT_H
#include <string>
#include <map>
#include <vector>
#include <dhcp6/dhcp6_parser.h>
#include <dhcp6/parser_context_decl.h>
#include <exceptions/exceptions.h>
 
// Tell Flex the lexer's prototype ...
#define YY_DECL isc::dhcp::Dhcp6Parser::symbol_type parser6_lex (Parser6Context& driver)
 
// ... and declare it for the parser's sake.
YY_DECL;
 
namespace isc {
namespace dhcp {

class Dhcp6ParseError : public isc::Exception {
public:
    Dhcp6ParseError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { }
};

class Parser6Context
{
public:

    typedef enum {
        PARSER_JSON,

        PARSER_DHCP6,

        SUBPARSER_DHCP6,

        PARSER_INTERFACES,

        PARSER_SUBNET6,

        PARSER_POOL6,

        PARSER_PD_POOL,

        PARSER_HOST_RESERVATION,

        PARSER_OPTION_DEFS,

        PARSER_OPTION_DEF,

        PARSER_OPTION_DATA,

        PARSER_HOOKS_LIBRARY,

        PARSER_DHCP_DDNS,

        PARSER_CONFIG_CONTROL,
    } ParserType;

    Parser6Context();

    virtual ~Parser6Context();

    std::vector<isc::data::ElementPtr> stack_;

    void scanStringBegin(const std::string& str, ParserType type);

    void scanFileBegin(FILE* f, const std::string& filename, ParserType type);

    void scanEnd();

    void includeFile(const std::string& filename);

    isc::data::ElementPtr parseString(const std::string& str,
                                      ParserType parser_type);

    isc::data::ElementPtr parseFile(const std::string& filename,
                                    ParserType parser_type);

    void error(const isc::dhcp::location& loc,
               const std::string& what,
               size_t pos = 0);

    void error(const std::string& what);

    static void fatal(const std::string& what);

    isc::data::Element::Position loc2pos(isc::dhcp::location& loc);

    void require(const std::string& name,
                 isc::data::Element::Position open_loc,
                 isc::data::Element::Position close_loc);

    void unique(const std::string& name,
                isc::data::Element::Position loc);

    void warning(const isc::dhcp::location& loc, const std::string& what);

    void warnAboutExtraCommas(const isc::dhcp::location& loc);

    typedef enum {
        NO_KEYWORD,

        CONFIG,

        DHCP6,

        INTERFACES_CONFIG,

        SANITY_CHECKS,

        LEASE_DATABASE,

        HOSTS_DATABASE,

        DATABASE_ON_FAIL,

        SSL_MODE,

        MAC_SOURCES,

        HOST_RESERVATION_IDENTIFIERS,

        HOOKS_LIBRARIES,

        SUBNET6,

        SHARED_NETWORK,

        OPTION_DEF,

        OPTION_DATA,

        CLIENT_CLASSES,

        EXPIRED_LEASES_PROCESSING,

        SERVER_ID,

        DUID_TYPE,

        CONTROL_SOCKET,

        CONTROL_SOCKET_TYPE,

        AUTHENTICATION,

        AUTH_TYPE,

        CLIENTS,

        HTTP_HEADERS,

        DHCP_QUEUE_CONTROL,

        DHCP_MULTI_THREADING,

        POOLS,

        PD_POOLS,

        RESERVATIONS,

        RELAY,

        LOGGERS,

        OUTPUT_OPTIONS,

        DHCP_DDNS,

        NCR_PROTOCOL,

        NCR_FORMAT,

        REPLACE_CLIENT_NAME,

        CONFIG_CONTROL,

        CONFIG_DATABASE,

        COMPATIBILITY,

        DDNS_CONFLICT_RESOLUTION_MODE,
    } ParserContext;

    std::string file_;

    std::vector<std::string> files_;

    isc::dhcp::location loc_;

    std::vector<isc::dhcp::location> locs_;

    std::vector<struct yy_buffer_state*> states_;

    FILE* sfile_;

    std::vector<FILE*> sfiles_;

    ParserContext ctx_;

    void enter(const ParserContext& ctx);

    void leave();

    const std::string contextName();
 
 private:
    bool trace_scanning_;

    bool trace_parsing_;

    std::vector<ParserContext> cstack_;

    isc::data::ElementPtr parseCommon();
};
 
}  // namespace dhcp
}  // namespace isc
 
#endif