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

Changeset 4169


Ignore:
Timestamp:
Jul 24, 2009, 1:13:11 PM (8 years ago)
Author:
bless
Message:
Files:
9 edited
2 copied

Legend:

Unmodified
Added
Removed
  • ntlp/branches/20081127-merge-mobility-mk3/include/gist_conf.h

    r4147 r4169  
    5050    gistconf_localaddrv4,
    5151    gistconf_localaddrv6,
     52    gistconf_home_netprefix,
     53    gistconf_home_address,
     54    gistconf_coa_interfaces,
     55    gistconf_homeagent_address,
     56    gistconf_homeagent_address_alt,
    5257    gistconf_retrylimit,
    5358    gistconf_retryperiod,
  • ntlp/branches/20081127-merge-mobility-mk3/src/gist_conf.cpp

    r4147 r4169  
    5656  registerPar( new configpar< hostaddresslist_t >(gist_realm, gistconf_localaddrv4, "localaddr-v4", "Local IPv4 listen addresses", true, list<hostaddress>() ) );
    5757  registerPar( new configpar< hostaddresslist_t >(gist_realm, gistconf_localaddrv6, "localaddr-v6", "Local IPv6 listen addresses", true, list<hostaddress>() ) );
     58  registerPar( new configpar< netaddress >(gist_realm, gistconf_home_netprefix, "home-netprefix", "Home Network Prefix (Mobility)", true) );
     59  registerPar( new configpar< hostaddress >(gist_realm, gistconf_home_address, "home-address", "Home Address (Mobility)", true) );
     60  registerPar( new configpar< string >(gist_realm, gistconf_coa_interfaces, "coa-interfaces", "Care-Of Interfaces (Mobility)", true) );
     61  registerPar( new configpar< hostaddress >(gist_realm, gistconf_homeagent_address, "homeagent-address", "Home Agent Address (Mobility)", true) );
     62  registerPar( new configpar< hostaddress >(gist_realm, gistconf_homeagent_address_alt, "homeagent-address-alt", "Home Agent Alternative Address (Mobility)", true) );
    5863  registerPar( new configpar<uint32>(gist_realm, gistconf_retrylimit,  "retry-limit", "Upper limit for retry limit threshold (ms)", true, retrylimit_default, "ms") );
    5964  registerPar( new configpar<uint32>(gist_realm, gistconf_retryperiod, "retry-period", "Retries will be started initially after this period (ms)", true, retryperiod_default, "ms") );
  • qos-nslp/branches/20081127-merge-mobility-mk3

  • qos-nslp/branches/20081127-merge-mobility-mk3/README

    r3180 r4169  
    1818
    1919Please change the file
    20 ../ntlp/src/gist.conf as required, e.g.,
    21 you must specify the IP addresses of your machine.
     20../nsis-ka.conf as required, e.g.,
     21you must specify the IP addresses of your machine
     22in the [gist] configuration part.
    2223
    2324Start the QoS NSLP daemon using the start script
  • qos-nslp/branches/20081127-merge-mobility-mk3/src

    • Property svn:ignore
      •  

        old new  
        44libqosnslp.a
        55qosnslp
         6client
  • qos-nslp/branches/20081127-merge-mobility-mk3/src/Makefile

    r3701 r4169  
    4444                info_spec.o nslp_object.o nslp_pdu.o nslp_context.o aggregate.o \
    4545                rmf.o QoS_StateModule.o QoS_Appl_Msg.o SignalingAppl.o QoS_NSLP_API.o QoS_NSLP_Client_API.o \
    46                 QoS_NSLP_UDS_API.o TestConsole.o session_id_list.o rsn_list.o qosnslp_starter.o
     46                QoS_NSLP_UDS_API.o TestConsole.o session_id_list.o rsn_list.o qos_nslp_conf.o qosnslp_starter.o
    4747
    4848ifdef QT_DIR
  • qos-nslp/branches/20081127-merge-mobility-mk3/src/qosnslp_starter.cpp

    r3701 r4169  
    2626#include "ProcessingModule.h"
    2727#include "queuemanager.h"
     28
     29#include "gist_conf.h"
    2830
    2931using namespace qos_nslp;
     
    5658                // NTLPStarterParam is necessary
    5759                ThreadStarter<ntlp::NTLPStarter, ntlp::NTLPStarterParam> ntlpthread(1, *(param.ntlppar));
    58                 DLog("QoS NSLP Starter", color[red] << "start NTLP Thread" << color[off]);
     60                DLog("QoS NSLP Starter", color[red] << "start NTLP Thread (instance " << n << ')' << color[off]);
    5961                ntlpthread.start_processing();
    6062
     
    6567                       
    6668                // start ProcessingModule (will need four threads)
    67                 ProcessingModuleParam sim_cl_par(ThreadParam::default_sleep_time, *param.addresses, *param.fi_service);
     69                ProcessingModuleParam sim_cl_par(ThreadParam::default_sleep_time,
     70                                                 *param.addresses, *param.fi_service);
     71
    6872                ThreadStarter<ProcessingModule, ProcessingModuleParam> processing_module(4, sim_cl_par);
    6973
     
    9094                EVLog(param.name, "Aborting ProcessingModule");
    9195                processing_module.abort_processing();
     96
     97                // stop ntlp module(s)
     98                EVLog(param.name, "Stopping NTLP");
     99                ntlpthread.stop_processing();
     100
    92101        } catch (ProtLibException& e) {
    93102                cerr << "Fatal: " << e.getstr() << endl;
  • qos-nslp/branches/20081127-merge-mobility-mk3/src/qosnslpd.cpp

    r3703 r4169  
    3939#include "qosnslp_starter.h"
    4040
     41#include "gist_conf.h"
     42#include "qos_nslp_conf.h"
     43#include "configfile.h"
     44
    4145#include <openssl/ssl.h>
    4246
    43 const uint16 SCTP_PORT = 30000;
    4447
    4548using namespace qos_nslp;
    4649using namespace ntlp;
    4750
     51namespace ntlp {
     52// configuration class
     53gistconf gconf;
     54}
     55
     56namespace qos_nslp {
     57// configuration class
     58qos_nslp_conf qosnslpconf;
     59}
     60
    4861logfile commonlog("", true, true);
    4962qos_nslp::log::logfile& qos_nslp::log::DefaultLog(commonlog);
    5063
    51 int StringToInt(std::string);
    52 bool StringToBool(std::string);
    53 std::string IntToString(int);
    54 double StringToDouble(std::string);
    55 void read_config(map<std::string, std::string> &);
    5664
    5765// indicates whether QoS NSLP daemon is stopped
     
    93101}
    94102
     103
    95104/** Main function of the QoS NSLP.  */
    96105int main(int argc, char** argv)
     
    116125                FastQueue* timerchecker_fq = new FastQueue("timerchecker", true);
    117126                QueueManager::instance()->register_queue(timerchecker_fq, message::qaddr_qos_nslp_timerprocessing);
    118 
    119                 ///config array
    120                 map<std::string, std::string> config;
    121 
    122                 // read values from config file
    123                 read_config(config);
    124 
    125                 // fill the parameters given from command line
     127               
     128                // create the global configuration parameter repository
     129                qosnslpconf.repository_init();
     130
     131                // register all QoS NSLP configuration parameters at the registry
     132                qosnslpconf.setRepository();
     133
     134                // register all GIST configuration parameters at the registry
     135                gconf.setRepository();
     136
     137                // TODO check for configuration file name parameter from command line
    126138                // read_cmdline();
    127139
    128                 QoSNSLPStarterParam qospar;
    129 
    130                 // fill the parameters from configfile (parameters
    131                 // given by command line will later on override these)
    132                 list<hostaddress> ntlpv4addr;
    133                 list<hostaddress> ntlpv6addr;
    134 
    135                 if (config["IPV4_ADDR"] != "query") {
    136                         std::stringstream in(config["IPV4_ADDR"]);
    137 
    138                         while (in) {
    139                                 bool success;
    140                                 std::string token;
    141                                 in >> token;
    142 
    143                                 hostaddress addr(token.c_str(), &success);
    144 
    145                                 if (success && addr.is_ipv4())
    146                                         ntlpv4addr.push_back(addr);
    147                         }
    148                 }
    149 
    150                 if (config["IPV6_ADDR"] != "query") {
    151                         std::stringstream in(config["IPV6_ADDR"]);
    152 
    153                         while (in) {
    154                                 bool success;
    155                                 std::string token;
    156                                 in >> token;
    157 
    158                                 hostaddress addr(token.c_str(), &success);
    159 
    160                                 if (success && addr.is_ipv6())
    161                                         ntlpv6addr.push_back(addr);
    162                         }
    163                 }
    164 
     140                // read all config values from config file
     141                configfile cfgfile(configpar_repository::instance());
     142                try {
     143                  cfgfile.load(gconf.getparref<string>(gistconf_conffilename));
     144                }
     145
     146                catch(configParException& cfgerr)
     147                {
     148                  ERRLog("qosnslpd", "Error occurred while reading the configuration file: " << cfgerr.what());
     149                  cerr << cfgerr.what() << endl << "Exiting." << endl;
     150                  return 1;
     151                }
    165152 
    166153                AddressList *addresses = new AddressList();
    167154
    168 #if 1 /* mobility */
    169                 if (config["HOME_NET"] != "") {
    170                         std::stringstream in(config["HOME_NET"]);
    171 
    172                         while (in) {
    173                                 bool success;
    174                                 std::string token;
    175                                 in >> token;
    176 
    177                                 netaddress na(token.c_str(), &success);
    178 
    179                                 if (success && !na.is_ip_unspec()) {
    180                                         addresses->add_property(na,
    181                                             AddressList::HomeNet_P);
    182                                 }
    183                         }
    184                 }
    185 #endif
     155                hostaddresslist_t& ntlpv4addr= gconf.getparref< hostaddresslist_t >(gistconf_localaddrv4);
     156                hostaddresslist_t& ntlpv6addr= gconf.getparref< hostaddresslist_t >(gistconf_localaddrv6);
    186157
    187158                if (ntlpv4addr.size() == 0 && ntlpv6addr.size() == 0) {
     
    190161                        addresses->add_host_prop(NULL, AddressList::ConfiguredAddr_P);
    191162                }
     163
     164                // fill in configured IPv4 addresses
    192165                if (ntlpv4addr.size() != 0) {
    193                         list<hostaddress>::iterator it;
     166                        hostaddresslist_t::const_iterator it;
    194167                        for (it = ntlpv4addr.begin(); it != ntlpv4addr.end(); it++) {
    195168                                netaddress na((*it));
     
    197170                        }
    198171                }
     172
     173                // fill in configured IPv6 addresses
    199174                if (ntlpv6addr.size() != 0) {
    200                         list<hostaddress>::iterator it;
     175                        hostaddresslist_t::const_iterator it;
    201176                        for (it = ntlpv6addr.begin(); it != ntlpv6addr.end(); it++) {
    202177                                netaddress na((*it));
     
    205180                }
    206181
    207 #if 1 /* MOBILITY */
    208                 if (config["HOME_ADDR"] != "") {
    209                         std::stringstream in(config["HOME_ADDR"]);
    210 
    211                         while (in) {
    212                                 bool success;
    213                                 std::string token;
    214                                 in >> token;
    215 
    216                                 hostaddress addr(token.c_str(), &success);
    217 
    218                                 if (success) {
    219                                         netaddress na(addr);
    220                                         addresses->add_property(na,
    221                                             AddressList::HomeAddr_P);
    222                                         addresses->add_property(na,
    223                                             AddressList::ConfiguredAddr_P);
    224                                 }
    225                         }
    226                 }
    227 
    228                 if (config["COA_IFACE"] != "") {
    229                         std::stringstream in(config["COA_IFACE"]);
     182                // MOBILITY (mobility extension): configure net prefix of home network
     183                const netaddress& na= gconf.getparref<netaddress>(gistconf_home_netprefix);
     184                if (!na.is_ip_unspec()) {
     185                        addresses->add_property(na, AddressList::HomeNet_P);
     186                }
     187
     188                // MOBILITY: configure home address
     189                const hostaddress& homeaddr= gconf.getparref< hostaddress >(gistconf_home_address);
     190                if (!homeaddr.is_ip_unspec())
     191                {
     192                        const netaddress na(homeaddr);
     193                        addresses->add_property(na, AddressList::HomeAddr_P);
     194                        addresses->add_property(na, AddressList::ConfiguredAddr_P);
     195                }
     196
     197                // MOBILITY: care-of interfaces
     198                const string& coa_iface= gconf.getparref< string >(gistconf_coa_interfaces);
     199                if (!coa_iface.empty())
     200                {
     201                        std::stringstream in(coa_iface);
    230202
    231203                        while (in) {
    232204                                std::string token;
    233205                                in >> token;
    234 
     206                               
    235207                                addresses->ignore_locals();
    236208                                addresses->by_interface(true);
     
    240212                }
    241213
    242                 if (config["HA_ADDR"] != "") {
    243                         std::stringstream in(config["HA_ADDR"]);
    244 
    245                         while (in) {
    246                                 bool success;
    247                                 std::string token;
    248                                 in >> token;
    249 
    250                                 hostaddress addr(token.c_str(), &success);
    251 
    252                                 if (success) {
    253                                         netaddress na(addr);
    254                                         addresses->add_property(na,
    255                                             AddressList::HAAddr_P);
    256                                         addresses->add_property(na,
    257                                             AddressList::ConfiguredAddr_P);
    258                                 }
    259                         }
    260                 }
    261 
    262                 if (config["ALT_HA_ADDR"] != "") {
    263                         std::stringstream in(config["ALT_HA_ADDR"]);
    264 
    265                         while (in) {
    266                                 bool success;
    267                                 std::string token;
    268                                 in >> token;
    269 
    270                                 hostaddress addr(token.c_str(), &success);
    271 
    272                                 if (success) {
    273                                         netaddress na(addr);
    274                                         addresses->add_property(na,
    275                                             AddressList::AltHAAddr_P);
    276                                         addresses->add_property(na,
    277                                             AddressList::ConfiguredAddr_P);
    278                                 }
    279                         }
    280                 }
    281 
    282 #endif
     214                // MOBILITY: home agent address
     215                const hostaddress& homeagent_addr= gconf.getparref< hostaddress >(gistconf_homeagent_address);
     216                if (!homeagent_addr.is_ip_unspec())
     217                {
     218                        const netaddress na(homeagent_addr);
     219                        addresses->add_property(na, AddressList::HAAddr_P);
     220                        addresses->add_property(na, AddressList::ConfiguredAddr_P);
     221                }
     222
     223                // MOBILITY: home agent address
     224                const hostaddress& alt_homeagent_addr= gconf.getparref< hostaddress >(gistconf_homeagent_address_alt);
     225                if (!alt_homeagent_addr.is_ip_unspec())
     226                {
     227                        const netaddress na(alt_homeagent_addr);
     228                        addresses->add_property(na, AddressList::AltHAAddr_P);
     229                        addresses->add_property(na, AddressList::ConfiguredAddr_P);
     230                }
     231
     232                QoSNSLPStarterParam qospar;
    283233
    284234                qospar.addresses = addresses;
     
    296246#endif
    297247
    298                 port_t udpport = StringToInt(config["UDP_PORT"]);
    299                 port_t tcpport = StringToInt(config["TCP_PORT"]);
    300                 port_t tlsport = StringToInt(config["TLS_PORT"]);
    301 
    302                 uint8 retrycount = StringToInt(config["RETRY_COUNT"]);
    303                 uint32 retryperiod = StringToInt(config["RETRY_PERIOD"]);
    304                 float timingfactor = StringToDouble(config["TIMING_FACTOR"]);
    305                 uint32 statelifetime = StringToInt(config["STATE_LIFETIME"]);
    306                 uint32 refreshlimit = StringToInt(config["REFRESH_LIMIT"]);
    307                 uint32 maholdtime = StringToInt(config["MA_HOLD_TIME"]);
    308                 uint32 rollovertime = StringToInt(config["SECRETS_ROLLOVER_TIME"]);
    309                 uint32 secretscount = StringToInt(config["SECRETS_COUNT"]);
    310                 uint32 secretslength = StringToInt(config["SECRETS_LENGTH"]);
    311                 bool latestate = StringToBool(config["LATE_STATE"]);
    312                 bool handshake = StringToBool(config["REQUIRE_HANDSHAKE"]);
    313                 bool debug_tp = StringToBool(config["DEBUG_TP"]);
    314 
    315                 // give the parameters to NTLP Starter
    316                 ntlp::NTLPStarterParam ntlppar(udpport,
    317                         tcpport,
    318                         tlsport,
    319                         SCTP_PORT,
    320                         retrycount,
    321                         retryperiod,
    322                         timingfactor,
    323                         statelifetime,
    324                         refreshlimit,
    325                         maholdtime,
    326                         rollovertime,
    327                         secretscount,
    328                         secretslength,
    329                         latestate,
    330                         handshake,      // confirm required
    331                         false,          // send data in query
    332                         false,          // echo MA hellos
    333                         true,           // sctp enable
    334                         addresses,
    335                         qospar.fi_service,
    336                         "./intercept",
    337                         debug_tp);
    338 
     248                // override parameters given from command line
     249                // read_cmdline();
     250
     251                ntlp::NTLPStarterParam ntlppar;
    339252                qospar.ntlppar = &ntlppar;
    340253
     
    437350} // end main
    438351
    439 // Helper functions for config parsing
    440 int StringToInt(std::string stringValue)
    441 {
    442         std::stringstream ssStream(stringValue);
    443         int iReturn;
    444         ssStream >> iReturn;
    445 
    446         return iReturn;
    447 }
    448 
    449 std::string IntToString(int iValue)
    450 {
    451         std::stringstream ssStream;
    452         ssStream << iValue;
    453         return ssStream.str();
    454 }
    455 
    456 double StringToDouble(std::string stringValue)
    457 {
    458         std::stringstream ssStream(stringValue);
    459         double iReturn;
    460         ssStream >> iReturn;
    461 
    462         return iReturn;
    463 }
    464 
    465 bool StringToBool(std::string stringValue)
    466 {
    467   if (stringValue == "on" || stringValue == "yes" || stringValue == "true" || stringValue == "1")
    468     return true;
    469   else
    470     return false;
    471 }
    472 
    473 /// read in the config from config file
    474 void read_config(map<std::string, std::string> &config)
    475 {
    476 
    477         string temp;
    478 
    479         ifstream configfile;
    480         const size_t max_line_length= 256;
    481         char line[max_line_length];
    482         const size_t pwd_len= 1024;
    483         char pwdstr[pwd_len];
    484        
    485         pwdstr[0]='\0';
    486         if (getcwd(pwdstr,pwd_len-1) == NULL)
    487         {
    488         }
    489         // no hint whether getcwd() always terminates if name fits, but trailing \0 not? better be sure...
    490         pwdstr[pwd_len-1]='\0';
    491 
    492         configfile.open(gist_configfilename, std::ios::in);
    493 
    494         ILog("QoS NSLP Daemon","Reading in Configuration file <" << (char*) pwdstr << "/" << gist_configfilename << ">");
    495 
    496         int linecount= 0;
    497         while (!configfile.eof()) {
    498                 configfile.getline(line, max_line_length);
    499                 linecount++;
    500                 temp = string(line);
    501 
    502                 std::string::size_type pos  = std::string::npos;
    503                 pos = temp.find_first_of("=", 0);
    504 
    505                 if (pos)
    506                         config[temp.substr(0, pos)] = temp.substr(pos + 1, temp.length());
    507         }
    508 
    509         ILog("QoS NSLP Daemon","Configuration file: " << linecount << " lines read.");
    510 
    511 }
  • qos-nslp/branches/20081127-merge-mobility-mk3/src/start-qosnslp

    r4003 r4169  
    22
    33LOGDIR=testing/logs
    4 LINKEDFILES="loadmodules intercept flush gist.conf"
     4LINKEDFILES="loadmodules intercept flush ../nsis-ka.conf"
    55
    66if [ \! -d $LOGDIR ]; then   mkdir -p $LOGDIR; fi
Note: See TracChangeset for help on using the changeset viewer.