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

Changeset 4116


Ignore:
Timestamp:
Jul 16, 2009, 6:08:20 PM (8 years ago)
Author:
bless
Message:
Location:
qos-nslp/trunk
Files:
6 edited
2 copied

Legend:

Unmodified
Added
Removed
  • qos-nslp/trunk

  • qos-nslp/trunk/include/qosnslp_starter.h

    r3673 r4116  
    3535
    3636        NTLPStarterParam *ntlppar;
    37         list<hostaddress> ntlpv4addr;
    38         list<hostaddress> ntlpv6addr;
    3937};
    4038
  • qos-nslp/trunk/src/Makefile

    r3673 r4116  
    4141                info_spec.o nslp_object.o nslp_pdu.o nslp_context.o aggregate.o \
    4242                rmf.o QoS_StateModule.o QoS_Appl_Msg.o SignalingAppl.o QoS_NSLP_API.o QoS_NSLP_Client_API.o \
    43                 QoS_NSLP_UDS_API.o TestConsole.o session_id_list.o rsn_list.o qosnslp_starter.o
     43                QoS_NSLP_UDS_API.o TestConsole.o session_id_list.o rsn_list.o qos_nslp_conf.o qosnslp_starter.o
    4444
    4545ifdef QT_DIR
  • qos-nslp/trunk/src/qosnslp_starter.cpp

    r3673 r4116  
    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
     
    6668                // start ProcessingModule (will need four threads)
    6769                ProcessingModuleParam sim_cl_par(ThreadParam::default_sleep_time,
    68                                 param.ntlpv4addr.front(), param.ntlpv6addr.front());
     70                                                 ntlp::gconf.getparref< hostaddresslist_t >(gistconf_localaddrv4).front(),
     71                                                 ntlp::gconf.getparref< hostaddresslist_t >(gistconf_localaddrv6).front());
     72
    6973                ThreadStarter<ProcessingModule, ProcessingModuleParam> processing_module(4, sim_cl_par);
    7074
     
    9195                EVLog(param.name, "Aborting ProcessingModule");
    9296                processing_module.abort_processing();
     97
     98                // stop ntlp module(s)
     99                EVLog(param.name, "Stopping NTLP");
     100                ntlpthread.stop_processing();
     101
    93102        } catch (ProtLibException& e) {
    94103                cerr << "Fatal: " << e.getstr() << endl;
  • qos-nslp/trunk/src/qosnslpd.cpp

    r3673 r4116  
    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
     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                catch(configParException& cfgerr)
     146                {
     147                  ERRLog("qosnslpd", "Error occurred while reading the configuration file: " << cfgerr.what());
     148                  cerr << cfgerr.what() << endl << "Exiting." << endl;
     149                  return 1;
     150                }
     151
     152                // override parameters given from command line
     153                // read_cmdline();
     154
    128155                QoSNSLPStarterParam qospar;
    129156
    130                 // fill the parameters from configfile (parameters
    131                 // given by command line will later on override these)
    132 
    133                 if (config["IPV4_ADDR"] != "query") {
    134                         std::stringstream in(config["IPV4_ADDR"]);
    135 
    136                         while (in) {
    137                                 bool success;
    138                                 std::string token;
    139                                 in >> token;
    140 
    141                                 hostaddress addr(token.c_str(), &success);
    142 
    143                                 if (success && addr.is_ipv4())
    144                                         qospar.ntlpv4addr.push_back(addr);
    145                         }
    146                 }
    147 
    148                 if (config["IPV6_ADDR"] != "query") {
    149                         std::stringstream in(config["IPV6_ADDR"]);
    150 
    151                         while (in) {
    152                                 bool success;
    153                                 std::string token;
    154                                 in >> token;
    155 
    156                                 hostaddress addr(token.c_str(), &success);
    157 
    158                                 if (success && addr.is_ipv6())
    159                                         qospar.ntlpv6addr.push_back(addr);
    160                         }
    161                 }
    162 
    163                 port_t udpport = StringToInt(config["UDP_PORT"]);
    164                 port_t tcpport = StringToInt(config["TCP_PORT"]);
    165                 port_t tlsport = StringToInt(config["TLS_PORT"]);
    166 
    167                 uint8 retrycount = StringToInt(config["RETRY_COUNT"]);
    168                 uint32 retryperiod = StringToInt(config["RETRY_PERIOD"]);
    169                 float timingfactor = StringToDouble(config["TIMING_FACTOR"]);
    170                 uint32 statelifetime = StringToInt(config["STATE_LIFETIME"]);
    171                 uint32 refreshlimit = StringToInt(config["REFRESH_LIMIT"]);
    172                 uint32 maholdtime = StringToInt(config["MA_HOLD_TIME"]);
    173                 uint32 rollovertime = StringToInt(config["SECRETS_ROLLOVER_TIME"]);
    174                 uint32 secretscount = StringToInt(config["SECRETS_COUNT"]);
    175                 uint32 secretslength = StringToInt(config["SECRETS_LENGTH"]);
    176                 bool latestate = StringToBool(config["LATE_STATE"]);
    177                 bool handshake = StringToBool(config["REQUIRE_HANDSHAKE"]);
    178                 bool debug_tp = StringToBool(config["DEBUG_TP"]);
    179 
    180157                // give the parameters to NTLP Starter
    181                 ntlp::NTLPStarterParam ntlppar(udpport,
    182                         tcpport,
    183                         tlsport,
    184                         SCTP_PORT,
    185                         retrycount,
    186                         retryperiod,
    187                         timingfactor,
    188                         statelifetime,
    189                         refreshlimit,
    190                         maholdtime,
    191                         rollovertime,
    192                         secretscount,
    193                         secretslength,
    194                         latestate,
    195                         handshake,      // confirm required
    196                         false,          // send data in query
    197                         false,          // echo MA hellos
    198                         true,           // sctp enable
    199                         qospar.ntlpv4addr,
    200                         qospar.ntlpv6addr,
    201                         "./intercept",
    202                         debug_tp);
     158                ntlp::NTLPStarterParam ntlppar;
    203159
    204160                qospar.ntlppar = &ntlppar;
     
    302258} // end main
    303259
    304 // Helper functions for config parsing
    305 int StringToInt(std::string stringValue)
    306 {
    307         std::stringstream ssStream(stringValue);
    308         int iReturn;
    309         ssStream >> iReturn;
    310 
    311         return iReturn;
    312 }
    313 
    314 std::string IntToString(int iValue)
    315 {
    316         std::stringstream ssStream;
    317         ssStream << iValue;
    318         return ssStream.str();
    319 }
    320 
    321 double StringToDouble(std::string stringValue)
    322 {
    323         std::stringstream ssStream(stringValue);
    324         double iReturn;
    325         ssStream >> iReturn;
    326 
    327         return iReturn;
    328 }
    329 
    330 bool StringToBool(std::string stringValue)
    331 {
    332   if (stringValue == "on" || stringValue == "yes" || stringValue == "true" || stringValue == "1")
    333     return true;
    334   else
    335     return false;
    336 }
    337 
    338 /// read in the config from config file
    339 void read_config(map<std::string, std::string> &config)
    340 {
    341 
    342         string temp;
    343 
    344         ifstream configfile;
    345         const size_t max_line_length= 256;
    346         char line[max_line_length];
    347         const size_t pwd_len= 1024;
    348         char pwdstr[pwd_len];
    349        
    350         pwdstr[0]='\0';
    351         if (getcwd(pwdstr,pwd_len-1) == NULL)
    352         {
    353         }
    354         // no hint whether getcwd() always terminates if name fits, but trailing \0 not? better be sure...
    355         pwdstr[pwd_len-1]='\0';
    356 
    357         configfile.open(gist_configfilename, std::ios::in);
    358 
    359         ILog("QoS NSLP Daemon","Reading in Configuration file <" << (char*) pwdstr << "/" << gist_configfilename << ">");
    360 
    361         int linecount= 0;
    362         while (!configfile.eof()) {
    363                 configfile.getline(line, max_line_length);
    364                 linecount++;
    365                 temp = string(line);
    366 
    367                 std::string::size_type pos  = std::string::npos;
    368                 pos = temp.find_first_of("=", 0);
    369 
    370                 if (pos)
    371                         config[temp.substr(0, pos)] = temp.substr(pos + 1, temp.length());
    372         }
    373 
    374         ILog("QoS NSLP Daemon","Configuration file: " << linecount << " lines read.");
    375 
    376 }
  • qos-nslp/trunk/src/start-qosnslp

    r3978 r4116  
    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.