NSIS-ka
A free C++ implementation of NSIS protocols

Changeset 4118


Ignore:
Timestamp:
Jul 16, 2009, 6:13:10 PM (8 years ago)
Author:
bless
Message:
Location:
natfw-nslp/trunk
Files:
29 edited

Legend:

Unmodified
Added
Removed
  • natfw-nslp/trunk

  • natfw-nslp/trunk/Doxygen.conf

  • natfw-nslp/trunk/Makefile

  • natfw-nslp/trunk/eval

  • natfw-nslp/trunk/eval/benchmark.cpp

    r3844 r4118  
    99#include <ctime>
    1010#include <cstdlib>
     11
     12#include <stdlib.h>
    1113
    1214#include "logfile.h"
     
    3032         * Turn off logging.
    3133         */
    32         if ( getenv("TEST_LOG") == NULL ) {
     34        if ( ::getenv("TEST_LOG") == NULL ) {
    3335                commonlog.set_filter(ERROR_LOG, LOG_EMERG + 1);
    3436                commonlog.set_filter(WARNING_LOG, LOG_EMERG + 1);
  • natfw-nslp/trunk/eval/nf.cpp

    r2302 r4118  
    1212#include "utils.h"
    1313
     14#include "configfile.h"
     15
    1416using namespace natfw;
    1517using namespace natfw::msg;
    1618using namespace protlib;
    17 
    18 
    1919
    2020class nf : public benchmark {
     
    4242
    4343        conf = new natfw_config();
     44        // read all config values from config file
     45        configfile cfgfile(configpar_repository::instance());
    4446
    4547        try {
    46                 conf->load(config_filename);
     48                cfgfile.load(config_filename);
    4749        }
    48         catch ( config_error &e ) {
    49                 std::cerr << "Config error: " << e << std::endl;
    50                 exit(1);
     50        catch(configParException& cfgerr)
     51        {
     52                ERRLog("nf", "Error occurred while reading the configuration file: " << cfgerr.what());
     53                cerr << cfgerr.what() << endl << "Exiting." << endl;
    5154        }
    5255
  • natfw-nslp/trunk/eval/nf2.cpp

    r2303 r4118  
    1515#include "benchmark_journal.h"
    1616#include "utils.h"
     17
     18#include "configfile.h"
    1719
    1820using namespace natfw;
     
    5254        conf = new natfw_config();
    5355
     56        // read all config values from config file
     57        configfile cfgfile(configpar_repository::instance());
     58
    5459        try {
    55                 conf->load(config_filename);
     60                cfgfile.load(config_filename);
    5661        }
    57         catch ( config_error &e ) {
    58                 std::cerr << "Config error: " << e << std::endl;
    59                 exit(1);
     62        catch(configParException& cfgerr)
     63        {
     64                ERRLog("nf", "Error occurred while reading the configuration file: " << cfgerr.what());
     65                cerr << cfgerr.what() << endl << "Exiting." << endl;
    6066        }
    6167
  • natfw-nslp/trunk/eval/nf3.cpp

    r2347 r4118  
    1515#include "benchmark_journal.h"
    1616#include "utils.h"
     17
     18#include "configfile.h"
    1719
    1820using namespace natfw;
     
    5052        NATFW_IEManager::register_known_ies();
    5153
    52         conf = new natfw_config();
     54        // read all config values from config file
     55        configfile cfgfile(configpar_repository::instance());
    5356
    5457        try {
    55                 conf->load(config_filename);
     58                cfgfile.load(config_filename);
    5659        }
    57         catch ( config_error &e ) {
    58                 std::cerr << "Config error: " << e << std::endl;
     60        catch(configParException& cfgerr)
     61        {
     62                ERRLog("nf", "Error occurred while reading the configuration file: " << cfgerr.what());
     63                cerr << cfgerr.what() << endl << "Exiting." << endl;
    5964                exit(1);
    6065        }
     66
    6167
    6268        mgr = new session_manager(conf);
  • natfw-nslp/trunk/eval/nf4.cpp

    r2348 r4118  
    1515#include "benchmark_journal.h"
    1616#include "utils.h"
     17
     18#include "configfile.h"
    1719
    1820using namespace natfw;
     
    5254        conf = new natfw_config();
    5355
     56        // read all config values from config file
     57        configfile cfgfile(configpar_repository::instance());
     58
    5459        try {
    55                 conf->load(config_filename);
     60                cfgfile.load(config_filename);
    5661        }
    57         catch ( config_error &e ) {
    58                 std::cerr << "Config error: " << e << std::endl;
     62        catch(configParException& cfgerr)
     63        {
     64                ERRLog("nf", "Error occurred while reading the configuration file: " << cfgerr.what());
     65                cerr << cfgerr.what() << endl << "Exiting." << endl;
    5966                exit(1);
    6067        }
  • natfw-nslp/trunk/eval/nr.cpp

    r2300 r4118  
    1212#include "utils.h"
    1313
     14#include "configfile.h"
     15
    1416using namespace natfw;
    1517using namespace natfw::msg;
    1618using namespace protlib;
    17 
    1819
    1920
     
    4748        d = new nop_dispatcher(mgr, nat_mgr, installer, conf);
    4849
     50        // read all config values from config file
     51        configfile cfgfile(configpar_repository::instance());
    4952
    5053        try {
    51                 conf->load("../testbed/setup_1_tb21.conf");
     54                cfgfile.load("../testbed/setup_1_tb21.conf");
    5255        }
    53         catch ( config_error &e ) {
    54                 std::cerr << "Config error: " << e << std::endl;
     56        catch(configParException& cfgerr)
     57        {
     58                ERRLog("nf", "Error occurred while reading the configuration file: " << cfgerr.what());
     59                cerr << cfgerr.what() << endl << "Exiting." << endl;
    5560                exit(1);
    5661        }
  • natfw-nslp/trunk/eval/utils.cpp

    r2348 r4118  
    1111#include "session_id.h"
    1212
     13namespace ntlp {
     14// configuration class
     15gistconf gconf;
     16}
    1317
    1418namespace natfw {
  • natfw-nslp/trunk/flush

  • natfw-nslp/trunk/include

  • natfw-nslp/trunk/include/natfw_config.h

    r2558 r4118  
    3030#define NATFW__NATFW_CONFIG_H
    3131
    32 #include <list>
    33 
    3432#include "messages.h"
    3533#include "address.h"
    3634
    37 #include "configuration.h"
    38 
     35#include "configpar.h"
     36#include "configpar_repository.h"
     37
     38// since we re-use some GIST parameter, we need to define them here
     39#include "gist_conf.h"
    3940
    4041namespace natfw {
    4142  using namespace protlib;
     43
     44  // 0 = global realm, 1 = protlib_realm, 2 = gist_realm
     45
     46  const realm_id_t natfw_realm= 4;
     47
     48
     49  enum natfw_configpar_id_t {
     50    natfwconf_invalid,
     51    natfwconf_conffilename,
     52    natfwconf_dispatcher_threads,
     53    /* NI  */
     54    natfwconf_ni_session_lifetime,
     55    natfwconf_ni_response_timeout,
     56    natfwconf_ni_max_session_lifetime,
     57    natfwconf_ni_max_retries,
     58    /* NF  */
     59    natfwconf_nf_max_session_lifetime,
     60    natfwconf_nf_response_timeout,
     61    natfwconf_nf_is_nat,
     62    natfwconf_nf_is_firewall,
     63    natfwconf_nf_is_edge_node,
     64    natfwconf_nf_is_edge_nat,
     65    natfwconf_nf_is_edge_firewall,
     66    natfwconf_nf_private_networks,
     67    natfwconf_nf_nat_public_address,
     68    natfwconf_nf_nat_public_port_begin,
     69    natfwconf_nf_nat_public_port_end,
     70    natfwconf_nf_install_policy_rules,
     71    /* NR  */
     72    natfwconf_nr_max_session_lifetime,
     73    /* NR ext */
     74    natfwconf_nr_ext_session_lifetime,
     75    natfwconf_nr_ext_max_retries,
     76    natfwconf_nr_ext_response_timeout,
     77    natfwconf_maxparno
     78  };
    4279
    4380
     
    4986
    5087  public:
    51         natfw_config();
    52         void load(const std::string &filename) throw (config_error);
    53         void load(std::istream &in) throw (config_error);
    54 
    55         bool has_ipv4_address() const { return has_ipv4_addr; }
    56         const list<hostaddress> &get_ipv4_addresses() const {
    57                 return ipv4_addresses; }
    58 
    59         bool has_ipv6_address() const { return has_ipv6_addr; }
    60         const list<hostaddress> &get_ipv6_addresses() const {
    61                 return ipv6_addresses; }
    62 
    63         uint16 get_gist_port_udp() const { return gist_port_udp; }
    64         uint16 get_gist_port_tcp() const { return gist_port_tcp; }
    65         uint16 get_gist_port_tls() const { return gist_port_tls; }
     88        natfw_config(configpar_repository *cfpgar_rep= NULL) : cfgpar_rep(cfpgar_rep) {};
     89       
     90        void repository_init();
     91
     92        void setRepository(configpar_repository* cfp_rep= configpar_repository::instance());
     93
     94        /// register copy of configuration parameter instance
     95        void registerPar(const configparBase& configparid) { cfgpar_rep->registerPar(configparid); }
     96        /// register instance configuration parameter directly
     97        void registerPar(configparBase* configparid) { cfgpar_rep->registerPar(configparid);  }
     98
     99        // these are just convenience functions
     100        template <class T> void setpar(natfw_configpar_id_t configparid, const T& value);
     101        template <class T> T getpar(natfw_configpar_id_t configparid) const;
     102        template <class T> T& getparref(natfw_configpar_id_t configparid) const;
     103        string getparname(natfw_configpar_id_t configparid);
     104
     105        bool has_ipv4_address() const { return ntlp::gconf.getparref<hostaddresslist_t>(ntlp::gistconf_localaddrv4).size() > 0; }
     106        const hostaddresslist_t &get_ipv4_addresses() const {
     107          return ntlp::gconf.getparref<hostaddresslist_t>(ntlp::gistconf_localaddrv4); }
     108
     109        bool has_ipv6_address() const { return ntlp::gconf.getparref<hostaddresslist_t>(ntlp::gistconf_localaddrv6).size() > 0; }
     110        const hostaddresslist_t &get_ipv6_addresses() const {
     111                return ntlp::gconf.getparref<hostaddresslist_t>(ntlp::gistconf_localaddrv6); }
     112
     113        uint16 get_gist_port_udp() const { return ntlp::gconf.getpar<uint16>(ntlp::gistconf_udpport); }
     114        uint16 get_gist_port_tcp() const { return ntlp::gconf.getpar<uint16>(ntlp::gistconf_tcpport); }
     115        uint16 get_gist_port_tls() const { return ntlp::gconf.getpar<uint16>(ntlp::gistconf_tlsport); }
    66116
    67117        uint32 get_num_dispatcher_threads() const {
    68                 return num_dispatcher_threads; }
    69 
    70         uint32 get_ni_session_lifetime() const { return ni_session_lifetime; }
    71         uint32 get_ni_max_retries() const { return ni_max_retries; }
    72         uint32 get_ni_response_timeout() const { return ni_response_timeout; }
    73 
    74         uint32 get_nf_max_session_lifetime() const {
    75                 return nf_max_session_lifetime; }
    76         uint32 get_nf_response_timeout() const { return nf_response_timeout; }
    77         bool is_nf_nat() const { return nf_is_nat; }
    78         bool is_nf_firewall() const { return nf_is_firewall; }
    79         bool is_nf_edge_node() const { return nf_is_edge_node; }
    80         bool is_nf_edge_nat() const { return nf_is_edge_nat; }
    81         bool is_nf_edge_firewall() const { return nf_is_edge_firewall; }
     118          return getpar<uint32>(natfwconf_dispatcher_threads); }
     119
     120        uint32 get_ni_session_lifetime() const { return getpar<uint32>(natfwconf_ni_max_session_lifetime); }
     121        uint32 get_ni_max_retries() const { return getpar<uint32>(natfwconf_ni_max_retries); }
     122        uint32 get_ni_response_timeout() const { return getpar<uint32>(natfwconf_ni_response_timeout); }
     123
     124        uint32 get_nf_max_session_lifetime() const { return getpar<uint32>(natfwconf_nf_max_session_lifetime); }
     125        uint32 get_nf_response_timeout() const { return getpar<uint32>(natfwconf_nf_response_timeout); }
     126        bool is_nf_nat() const { return getpar<bool>(natfwconf_nf_is_nat); }
     127        bool is_nf_firewall() const { return getpar<bool>(natfwconf_nf_is_firewall); }
     128        bool is_nf_edge_node() const { return getpar<bool>(natfwconf_nf_is_edge_node); }
     129        bool is_nf_edge_nat() const { return getpar<bool>(natfwconf_nf_is_edge_nat); }
     130        bool is_nf_edge_firewall() const { return getpar<bool>(natfwconf_nf_is_edge_firewall); }
    82131
    83132        const std::list<netaddress> &get_nf_private_networks() {
    84                 return nf_private_networks; }
    85 
    86         hostaddress get_nf_nat_public_address() const {
    87                 return nf_nat_public_address; }
     133                return getparref< list<netaddress> >(natfwconf_nf_private_networks); }
     134
     135        const hostaddress& get_nf_nat_public_address() const {
     136                return getparref<hostaddress>(natfwconf_nf_nat_public_address); }
    88137        uint16 get_nf_nat_public_port_begin() const {
    89                 return nf_nat_public_port_begin; }
     138                return getpar<uint16>(natfwconf_nf_nat_public_port_begin); }
    90139        uint16 get_nf_nat_public_port_end() const {
    91                 return nf_nat_public_port_end; }
     140                return getpar<uint16>(natfwconf_nf_nat_public_port_end); }
    92141        bool get_nf_install_policy_rules() const {
    93                 return nf_install_policy_rules; }
     142                return getpar<bool>(natfwconf_nf_install_policy_rules); }
    94143
    95144        uint32 get_nr_max_session_lifetime() const {
    96                 return nr_max_session_lifetime; }
    97 
    98         uint32 get_nr_ext_max_retries() const { return nr_ext_max_retries; }
     145                return getpar<uint32>(natfwconf_nr_max_session_lifetime); }
     146
     147        uint32 get_nr_ext_max_retries() const { return getpar<uint32>(natfwconf_nr_ext_max_retries); }
    99148        uint32 get_nr_ext_response_timeout() const {
    100                 return nr_ext_response_timeout; }
    101 
     149                return getpar<uint32>(natfwconf_nr_ext_response_timeout); }
    102150
    103151
     
    126174
    127175  protected:
    128         configuration conf;
    129 
    130         void setup() throw (config_error);
     176        configpar_repository* cfgpar_rep;
     177
    131178        hostaddress get_hostaddress(const std::string &key);
    132179
    133         bool has_ipv4_addr;
    134         std::list<hostaddress> ipv4_addresses;  // the local IPv4 addresses
    135 
    136         bool has_ipv6_addr;
    137         std::list<hostaddress> ipv6_addresses;  // the local IPv6 addresses
    138 
    139         uint16 gist_port_udp;
    140         uint16 gist_port_tcp;
    141         uint16 gist_port_tls;
    142 
    143         uint32 num_dispatcher_threads;
    144 
    145         uint32 ni_session_lifetime;
    146         int ni_max_retries;
    147         int ni_response_timeout;
    148 
    149         uint32 nf_max_session_lifetime;
    150         uint32 nf_response_timeout;
    151         bool nf_is_nat;
    152         bool nf_is_firewall;
    153         bool nf_is_edge_node;
    154         bool nf_is_edge_nat;
    155         bool nf_is_edge_firewall;
    156         list<netaddress> nf_private_networks;
    157         hostaddress nf_nat_public_address;
    158         uint16 nf_nat_public_port_begin;
    159         uint16 nf_nat_public_port_end;
    160         bool nf_install_policy_rules;
    161 
    162         uint32 nr_max_session_lifetime;
    163         uint32 nr_ext_session_lifetime;
    164         int nr_ext_max_retries;
    165         int nr_ext_response_timeout;
    166 
    167         std::list<hostaddress> read_ipv4_addresslist(const std::string &str);
    168         std::list<hostaddress> read_ipv6_addresslist(const std::string &str);
     180        void registerAllPars();
    169181};
    170182
    171183
     184// this is just a convenience function
     185template <class T>
     186void
     187natfw_config::setpar(natfw_configpar_id_t configparid, const T& value)
     188{
     189        cfgpar_rep->setPar(natfw_realm, configparid, value);
     190}
     191
     192
     193// this is just a convenience function
     194template <class T> T
     195natfw_config::getpar(natfw_configpar_id_t configparid) const
     196{
     197        return cfgpar_rep->getPar<T>(natfw_realm, configparid);
     198}
     199
     200
     201// this is just a convenience function
     202template <class T> T&
     203natfw_config::getparref(natfw_configpar_id_t configparid) const
     204{
     205        return cfgpar_rep->getParRef<T>(natfw_realm, configparid);
     206}
     207
     208
     209// this is just a convenience function
     210inline
     211string
     212natfw_config::getparname(natfw_configpar_id_t configparid)
     213{
     214        // reference to the config repository singleton
     215        return cfgpar_rep->getConfigPar(natfw_realm, configparid)->getName();
     216}
     217
     218
    172219} // namespace natfw
    173220
  • natfw-nslp/trunk/intercept

  • natfw-nslp/trunk/natfw_iptables

  • natfw-nslp/trunk/natfwd.conf

  • natfw-nslp/trunk/src

  • natfw-nslp/trunk/src/Makefile

    r3135 r4118  
    3333INC =  -I../include -I$(PROTLIB_INC) -I$(FQUEUE_INC) -I$(NTLP_INC)
    3434
     35ifdef SCTP_KERN
     36SCTP_LIBLD      = -lsctp
     37SCTP_OPTIONS    = -D_USE_SCTP
     38CFLAGS          += $(SCTP_OPTIONS)
     39PROTLIB_MAKEFLAGS += SCTP_KERN=yo
     40endif
    3541
    3642# The targets to build
  • natfw-nslp/trunk/src/main.cpp

    r2558 r4118  
    3333#include "threads.h"
    3434
     35#include "gist_conf.h"
     36#include "configfile.h"
     37
    3538#include "natfw_config.h"
    3639#include "natfw_daemon.h"
     
    4144using namespace natfw;
    4245
     46namespace ntlp {
     47// configuration class
     48gistconf gconf;
     49}
     50
     51natfw_config conf;
     52
     53using namespace ntlp;
    4354
    4455logfile commonlog("natfwd.log", natfw_config::USE_COLOURS);
     
    6273                switch ( c ) {
    6374                        case 'c':
    64                                 config_filename = optarg;
     75                                conf.getparref<string>(natfwconf_conffilename) = optarg;
    6576                                break;
    6677                        default:
     
    7081        }
    7182
    72         if ( config_filename == "" ) {
     83        if ( conf.getparref<string>(natfwconf_conffilename) == "" ) {
    7384                std::cerr << usage;
    7485                exit(1);
     
    89100
    90101int main(int argc, char *argv[]) {
     102       
     103        // create the global configuration parameter repository
     104        conf.repository_init();
    91105
     106        // register all NATFW configuration parameters at the registry
     107        conf.setRepository();
     108
     109        // register all GIST configuration parameters at the registry
     110        ntlp::gconf.setRepository();
    92111
    93112        /*
     
    98117
    99118
    100         natfw_config conf;
     119
     120        // read all config values from config file
     121        configfile cfgfile(configpar_repository::instance());
    101122
    102123        try {
    103                 conf.load(config_filename);
     124                cfgfile.load(conf.getparref<string>(natfwconf_conffilename));
    104125        }
    105         catch ( config_error &e ) {
    106                 std::cerr << "Config error: " << e << std::endl;
    107                 exit(1);
     126        catch(configParException& cfgerr)
     127        {
     128                ERRLog("natfwd", "Error occurred while reading the configuration file: " << cfgerr.what());
     129                cerr << cfgerr.what() << endl << "Exiting." << endl;
     130                return 1;
    108131        }
    109132
  • natfw-nslp/trunk/src/natfw_config.cpp

    r2558 r4118  
    2727//
    2828// ===========================================================
    29 #include <sstream>
    3029
    3130#include "natfw_config.h"
    3231
    33 
    3432using namespace natfw;
    3533
    36 
    37 static config_entry defaults[] = {
    38 
    39         config_entry("gist.addresses.ipv4", config_entry::T_IPv4_LIST),
    40         config_entry("gist.addresses.ipv6", config_entry::T_IPv6_LIST),
    41         config_entry("gist.port.udp", 40001),
    42         config_entry("gist.port.tcp", 40002),
    43         config_entry("gist.port.tls", 40003),
    44 
    45         config_entry("natfw.dispatcher.threads", 1),
    46 
    47         config_entry("ni.session_lifetime", 30),
    48         config_entry("ni.max_retries", 3),
    49         config_entry("ni.response_timeout", 2),
    50 
    51         config_entry("nf.max_session_lifetime", 60),
    52         config_entry("nf.response_timeout", 5),
    53 
    54         config_entry("nf.is_nat", false),
    55         config_entry("nf.is_firewall", false),
    56         config_entry("nf.is_edge_node", false),
    57         config_entry("nf.is_edge_nat", true),
    58         config_entry("nf.is_edge_firewall", true),
    59         config_entry("nf.private_networks", config_entry::T_STR, false),
    60         config_entry("nf.nat.public_address", config_entry::T_IPv4, false),
    61         config_entry("nf.nat.public_port.begin", 10000),
    62         config_entry("nf.nat.public_port.end", 20000),
    63         config_entry("nf.install_policy_rules", false),
    64 
    65         config_entry("nr.max_session_lifetime", 60),
    66 
    67         config_entry("nr_ext.session_lifetime", 30),
    68         config_entry("nr_ext.max_retries", 3),
    69         config_entry("nr_ext.response_timeout", 2),
    70 
    71         config_entry() // required end marker
    72 };
     34void
     35natfw_config::repository_init()
     36{
     37  DLog("natfw_config", "start - creating configuration parameter singleton");
     38  configpar_repository::create_instance(natfw::natfw_realm+1);
     39} // end namespace
    7340
    7441
    75 /**
    76  * Constructor.
    77  */
    78 natfw_config::natfw_config() : conf(defaults) {
    79         // nothing to do
     42
     43/** sets the repository pointer and registers all parameters
     44 *  (not done in constructor, because of allowing simulation hosts to initialize later)
     45 **/
     46void
     47natfw_config::setRepository(configpar_repository* cfp_rep)
     48{
     49        cfgpar_rep= cfp_rep;
     50
     51        if (cfgpar_rep == 0)
     52                throw  configParExceptionNoRepository();
     53       
     54        // register the realm
     55        cfgpar_rep->registerRealm(natfw_realm, "natfw", natfwconf_maxparno);
     56        DLog("natfw_config", "registered natfw realm with realm id " << (int) natfw_realm);
     57       
     58        // now register all parameters
     59        registerAllPars();
    8060}
    8161
    8262
    83 /**
    84  * Load a configuration file.
    85  *
    86  * If there's a parse error, the file can't be opened, or the file doesn't
    87  * contain all required values, a config_error exception is thrown.
    88  *
    89  * @param filename the file to load
    90  */
    91 void natfw_config::load(const std::string &filename) throw (config_error) {
    92         conf.load(filename);
    93         setup();
     63void
     64natfw_config::registerAllPars()
     65{
     66  DLog("natfw_config::registerAllPars", "starting registering natfw parameters.");
     67
     68  // register all natfw parameters now
     69  registerPar( new configpar<string>(natfw_realm, natfwconf_conffilename, "config", "configuration file name", true, "nsis-ka.conf") );
     70  registerPar( new configpar<uint32>(natfw_realm, natfwconf_dispatcher_threads, "dispatcher-threads", "number of dispatcher threads", true, 1) );
     71  registerPar( new configpar<uint32>(natfw_realm, natfwconf_ni_max_session_lifetime, "ni-max-session-lifetime", "NI session lifetime in seconds", true, 30, "s") );
     72  registerPar( new configpar<uint32>(natfw_realm, natfwconf_ni_max_retries, "ni-max-retries", "NI max retries", true, 3) );
     73  registerPar( new configpar<uint32>(natfw_realm, natfwconf_ni_response_timeout, "ni-response-timeout", "NI response timeout", true, 2, "s") );
     74  registerPar( new configpar<uint32>(natfw_realm, natfwconf_nf_max_session_lifetime, "nf-max-session-lifetime", "NF max session lifetime in seconds", true, 60, "s") );
     75  registerPar( new configpar<uint32>(natfw_realm, natfwconf_nf_response_timeout, "nf-response-timeout", "NF response timeout", true, 2, "s") );
     76  registerPar( new configpar<bool>(natfw_realm, natfwconf_nf_is_nat, "nf-is-nat", "NF is NAT", true, false) );
     77  registerPar( new configpar<bool>(natfw_realm, natfwconf_nf_is_firewall, "nf-is-firewall", "NF is firewall", true, false) );
     78  registerPar( new configpar<bool>(natfw_realm, natfwconf_nf_is_edge_node, "nf-is-edge-node", "NF is edge node", true, false) );
     79  registerPar( new configpar<bool>(natfw_realm, natfwconf_nf_is_edge_nat, "nf-is-edge-nat", "NF is edge NAT", true, true) );
     80  registerPar( new configpar<bool>(natfw_realm, natfwconf_nf_is_edge_firewall, "nf-is-edge-firewall", "NF is edge firewall", true, true) );
     81  registerPar( new configpar<hostaddresslist_t>(natfw_realm, natfwconf_nf_private_networks, "nf-private-networks", "List of private networks inside", true, list<hostaddress>()) );
     82  registerPar( new configpar<hostaddress>(natfw_realm, natfwconf_nf_nat_public_address, "nf-nat-public-address", "External public IPv4 address", true, hostaddress()) );
     83  registerPar( new configpar<uint16>(natfw_realm, natfwconf_nf_nat_public_port_begin, "nf-nat-public-port-begin", "NF NAT public port range low bound", true, 10000) );
     84  registerPar( new configpar<uint16>(natfw_realm, natfwconf_nf_nat_public_port_end, "nf-nat-public-port-end", "NF NAT public port range upper bound", true, 20000) );
     85  registerPar( new configpar<bool>(natfw_realm, natfwconf_nf_install_policy_rules, "nf-install-policy-rules", "NF install policy rules", true, false) );
     86  registerPar( new configpar<uint32>(natfw_realm, natfwconf_nr_max_session_lifetime, "nr-max-session-lifetime", "NR max session lifetime in seconds", true, 60, "s") );
     87  registerPar( new configpar<uint32>(natfw_realm, natfwconf_nr_ext_session_lifetime, "nr-ext-session-lifetime", "NR ext session lifetime in seconds", true, 30, "s") );
     88  registerPar( new configpar<uint16>(natfw_realm, natfwconf_nr_ext_max_retries, "nr-ext-max-retries", "NR ext max retries", true, 3) );
     89  registerPar( new configpar<uint32>(natfw_realm, natfwconf_nr_ext_response_timeout, "nr-ext-response-timeout", "NR ext response timeout", true, 2) );
     90
     91  DLog("natfw_config::registerAllPars", "finished registering natfw parameters.");
    9492}
    9593
    9694
    97 /**
    98  * Load configuration data from a stream.
    99  *
    100  * If there's a parse error, the file can't be opened, or the file doesn't
    101  * contain all required values, a config_error exception is thrown.
    102  *
    103  * This method will read until end of file. It is up to the caller to close
    104  * the stream.
    105  *
    106  * @param in the input stream to read data from
    107  */
    108 void natfw_config::load(std::istream &in) throw (config_error) {
    109         conf.load(in);
    110         setup();
    111 }
    112 
    113 
    114 /**
    115  * Setup the configuration values.
    116  *
    117  * If the configuration is invalid or incomplete, a config_error is thrown.
    118  */
    119 void natfw_config::setup() throw (config_error) {
    120 
    121         if ( conf.is_defined("gist.addresses.ipv4") ) {
    122                 ipv4_addresses
    123                         = conf.get_ipv4_address_list("gist.addresses.ipv4");
    124 
    125                 if ( ipv4_addresses.size() > 0 )
    126                         has_ipv4_addr = true;
    127         }
    128 
    129         if ( conf.is_defined("gist.addresses.ipv6") ) {
    130                 ipv6_addresses
    131                         = conf.get_ipv6_address_list("gist.addresses.ipv6");
    132 
    133                 if ( ipv6_addresses.size() > 0 )
    134                         has_ipv6_addr = true;
    135         }
    136 
    137 
    138         gist_port_udp = conf.get_int("gist.port.udp");
    139         gist_port_tcp = conf.get_int("gist.port.tcp");
    140         gist_port_tls = conf.get_int("gist.port.tls");
    141 
    142         num_dispatcher_threads = conf.get_int("natfw.dispatcher.threads");
    143 
    144         ni_session_lifetime = conf.get_int("ni.session_lifetime");
    145         ni_max_retries = conf.get_int("ni.max_retries");
    146         ni_response_timeout = conf.get_int("ni.response_timeout");
    147 
    148         nf_max_session_lifetime = conf.get_int("nf.max_session_lifetime");
    149         nf_response_timeout = conf.get_int("nf.response_timeout");
    150 
    151         nf_is_edge_node = conf.get_bool("nf.is_edge_node");
    152         nf_is_nat = conf.get_bool("nf.is_nat");
    153         nf_is_firewall = conf.get_bool("nf.is_firewall");
    154         nf_is_edge_nat = conf.get_bool("nf.is_edge_nat");
    155         nf_is_edge_firewall = conf.get_bool("nf.is_edge_firewall");
    156 
    157         if ( nf_is_edge_node && ! nf_is_edge_nat && ! nf_is_edge_firewall )
    158                 throw config_error("nf_is_edge_node is true, so nf.is_edge_nat "
    159                         "or nf.is_edge_firewall have to be true");
    160 
    161         if ( ! nf_is_nat )
    162                 nf_is_edge_nat = false;
    163 
    164         if ( ! nf_is_firewall )
    165                 nf_is_edge_firewall = false;
    166 
    167         bool success;
    168         std::istringstream in(conf.get_string("nf.private_networks"));
    169 
    170         std::string tmp;
    171         while ( in >> tmp ) {
    172                 netaddress net(tmp.c_str(), &success);
    173 
    174                 if ( success )
    175                         nf_private_networks.push_back(net);
    176                 else
    177                         throw config_error("invalid value `" + tmp
    178                                 + "' for nf.private_networks");
    179         }
    180 
    181 
    182         if ( conf.is_defined("nf.nat.public_address") ) {
    183                 nf_nat_public_address
    184                         = conf.get_ipv4_address("nf.nat.public_address");
    185         }
    186         else if ( nf_is_nat )
    187                 throw config_error("you have to set nf.nat.public_address");
    188 
    189 
    190         nf_nat_public_port_begin = conf.get_int("nf.nat.public_port.begin");
    191         nf_nat_public_port_end = conf.get_int("nf.nat.public_port.end");
    192 
    193         if ( nf_nat_public_port_begin > nf_nat_public_port_end )
    194                 throw config_error("nf.nat.public.port.begin must be smaller "
    195                         "than nf.nat.public.port.end");
    196 
    197         nf_install_policy_rules = conf.get_bool("nf.install_policy_rules");
    198 
    199 
    200         nr_max_session_lifetime = conf.get_int("nr.max_session_lifetime");
    201 
    202         nr_ext_session_lifetime = conf.get_int("nr_ext.session_lifetime");
    203         nr_ext_max_retries = conf.get_int("nr_ext.max_retries");
    204 
    205         nr_ext_response_timeout = conf.get_int("nr_ext.response_timeout");
    206 }
    207 
    20895// EOF
  • natfw-nslp/trunk/src/natfw_daemon.cpp

    r2558 r4118  
    108108         * Start the GIST thread.
    109109         */
    110         NTLPStarterParam param(
    111                 config.get_gist_port_udp(),
    112                 config.get_gist_port_tcp(),
    113                 config.get_gist_port_tls(),
    114                 0                               // SCTP port. Disabled.
    115         );
    116         param.refreshtime = 5000;       // in milliseconds
    117         param.debug_tp = false;
    118         param.latestate = true;
    119 
    120         if ( config.has_ipv4_address() )
    121                 param.localaddrv4 = config.get_ipv4_addresses();
    122 
    123         if ( config.has_ipv6_address() )
    124                 param.localaddrv6 = config.get_ipv6_addresses();
    125 
    126         ntlp_starter
    127                 = new ThreadStarter<NTLPStarter, NTLPStarterParam>(1, param);
     110        NTLPStarterParam ntlpparam;
     111        ntlp_starter= new ThreadStarter<NTLPStarter, NTLPStarterParam>(1, ntlpparam);
    128112        ntlp_starter->start_processing();
    129113
  • natfw-nslp/trunk/src/test_client.cpp

    r2800 r4118  
    3636#include "events.h"
    3737
     38#include "gist_conf.h"
     39#include "configfile.h"
     40
     41namespace ntlp {
     42// configuration class
     43gistconf gconf;
     44}
    3845
    3946using namespace protlib;
    4047using namespace protlib::log;
    4148using namespace natfw;
     49using namespace ntlp;
    4250
    4351
     
    202210
    203211        natfw_config conf;
     212       
     213        // create the global configuration parameter repository
     214        conf.repository_init();
     215
     216        // register all NATFW configuration parameters at the registry
     217        conf.setRepository();
     218
     219        // register all GIST configuration parameters at the registry
     220        ntlp::gconf.setRepository();
     221
     222        // read all config values from config file
     223        configfile cfgfile(configpar_repository::instance());
    204224
    205225        try {
    206                 conf.load(config_filename);
    207         }
    208         catch ( config_error &e ) {
    209                 std::cerr << "Config error: " << e << std::endl;
    210                 exit(1);
    211         }
    212 
     226                cfgfile.load(conf.getparref<string>(natfwconf_conffilename));
     227        }
     228        catch(configParException& cfgerr)
     229        {
     230                ERRLog("natfwd", "Error occurred while reading the configuration file: " << cfgerr.what());
     231                cerr << cfgerr.what() << endl << "Exiting." << endl;
     232                return 1;
     233        }
    213234
    214235        /*
  • natfw-nslp/trunk/src/test_stress.cpp

    r2800 r4118  
    3636#include "events.h"
    3737
     38#include "gist_conf.h"
     39#include "configfile.h"
     40
     41namespace ntlp {
     42// configuration class
     43gistconf gconf;
     44}
    3845
    3946using namespace protlib;
     
    160167
    161168        natfw_config conf;
     169       
     170        // create the global configuration parameter repository
     171        conf.repository_init();
     172
     173        // register all NATFW configuration parameters at the registry
     174        conf.setRepository();
     175
     176        // register all GIST configuration parameters at the registry
     177        ntlp::gconf.setRepository();
     178
     179        // read all config values from config file
     180        configfile cfgfile(configpar_repository::instance());
    162181
    163182        try {
    164                 conf.load(config_filename);
    165         }
    166         catch ( config_error &e ) {
    167                 std::cerr << "Config error: " << e << std::endl;
    168                 exit(1);
     183                cfgfile.load(conf.getparref<string>(natfwconf_conffilename));
     184        }
     185        catch(configParException& cfgerr)
     186        {
     187                ERRLog("natfwd", "Error occurred while reading the configuration file: " << cfgerr.what());
     188                cerr << cfgerr.what() << endl << "Exiting." << endl;
     189                return 1;
    169190        }
    170191
  • natfw-nslp/trunk/src/test_stress2.cpp

    r3165 r4118  
    4646#include <openssl/ssl.h>
    4747
     48
    4849using namespace protlib;
     50
     51#include "gist_conf.h"
     52
     53namespace ntlp {
     54// configuration class
     55gistconf gconf;
     56}
    4957
    5058
     
    113121         * Start the GIST thread.
    114122         */
    115         NTLPStarterParam param(
    116                 CONFIG_PORT_UDP,
    117                 CONFIG_PORT_TCP,
    118                 CONFIG_PORT_TLS,
    119                 CONFIG_PORT_SCTP
    120         );
    121         param.refreshtime = 5000;       // in milliseconds
    122         //param.debug_tp = true;
    123         param.latestate = true;
    124 
    125         std::list<hostaddress> ipv4addr;
    126         if ( config_sender_addr.is_ipv4() )
    127                 ipv4addr.push_back(config_sender_addr);
    128         param.localaddrv4 = ipv4addr;
    129 
    130         std::list<hostaddress> ipv6addr;
    131         if ( config_sender_addr.is_ipv6() )
    132                 ipv6addr.push_back(config_sender_addr);
    133         param.localaddrv6 = ipv6addr;
    134 
    135         ntlp_starter
    136                 = new ThreadStarter<NTLPStarter, NTLPStarterParam>(1, param);
     123        NTLPStarterParam param;
     124
     125        ntlp_starter = new ThreadStarter<NTLPStarter, NTLPStarterParam>(1, param);
    137126        ntlp_starter->start_processing();
    138127
  • natfw-nslp/trunk/test

  • natfw-nslp/trunk/test/utils.cpp

    r1842 r4118  
    1717using namespace natfw::msg;
    1818
     19namespace ntlp {
     20// configuration class
     21gistconf gconf;
     22}
    1923
    2024/**
  • natfw-nslp/trunk/test/utils.h

    r2438 r4118  
    1313#include "protlib_types.h"
    1414#include "dispatcher.h"
    15 
     15#include "gist_conf.h"
    1616
    1717class mock_config;
    1818class mock_dispatcher;
    1919class mock_policy_rule_installer;
     20
    2021
    2122#define ASSERT_STATE(session, state) \
     
    5657class mock_natfw_config : public natfw_config {
    5758  public:
    58         mock_natfw_config() { setup(); }
     59        mock_natfw_config() {
     60                repository_init();
     61                setRepository();       
     62                // register all GIST configuration parameters at the registry
     63                ntlp::gconf.setRepository();
     64        }
    5965
    60         void set_nf_is_nat(bool val) { nf_is_nat = val; }
    61         void set_nf_is_firewall(bool val) { nf_is_firewall = val; }
    62         void set_nf_is_edge_nat(bool val) { nf_is_edge_nat = val; }
    63         void set_nf_is_edge_firewall(bool val) { nf_is_edge_firewall = val; }
     66        void set_nf_is_nat(bool val) { setpar(natfwconf_nf_is_nat,val); }
     67        void set_nf_is_firewall(bool val) { setpar(natfwconf_nf_is_firewall, val); }
     68        void set_nf_is_edge_nat(bool val) { setpar(natfwconf_nf_is_edge_nat, val); }
     69        void set_nf_is_edge_firewall(bool val) { setpar(natfwconf_nf_is_edge_firewall,val); }
    6470};
    6571
  • natfw-nslp/trunk/testbed

Note: See TracChangeset for help on using the changeset viewer.