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

Changeset 4503


Ignore:
Timestamp:
Sep 30, 2009, 7:38:49 PM (8 years ago)
Author:
stud-dettling
Message:
  • Added function to traverse "NSLP_Context"s
Location:
qos-nslp/branches/20090610-qos-nslp-aho
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • qos-nslp/branches/20090610-qos-nslp-aho/include/ProcessingModule.h

    r4500 r4503  
    6363                /// module main loop
    6464                virtual void main_loop(uint32 nr);
    65                 // TODO: remove
    66                 //---------------------------------------------------------------------------------------------------------------
    67                 //state_manager::error_t SendMessage(uchar* nslp_data, uint32 nslp_data_size, SignalingMsg* sigmsg);
    68                 //---------------------------------------------------------------------------------------------------------------
    6965                state_manager::error_t SendMessage(uchar* nslp_data, uint32 nslp_data_size, sessionid* sid, mri* mr, uint32 sii_handle=0,
    7066                                msghandle_t nslpmsghandle=0, tx_attr_t tx_attr=tx_attr_t(), uint32 timeout=15, uint16 ip_ttl=103, uint32 ghc=100);
     
    7773                void process_queue();
    7874                void process_sig_msg(SignalingMsg* msg);
    79                 //---------------------------------------------------------------------------------------------------------------
    8075                void process_est_sig_msg(ExplicitSignalingMsg* msg);
    81                 //---------------------------------------------------------------------------------------------------------------
    8276                void rcv_appl_messages();
    8377                void process_appl_msg(QoS_Appl_Msg* applmsg);
  • qos-nslp/branches/20090610-qos-nslp-aho/include/QoS_StateModule.h

    r4500 r4503  
    135135  void process_aho_event(const string iface, macaddress &l2_ap_n, hostaddress &l3_ar_n);
    136136  void process_ho_event(const string iface, macaddress &l2_ap_n, hostaddress &l3_ar_n, hostaddress &l3_mn);
    137         //
     137  void aho_phase_1(const NSLP_Context* context, void *param1, void *param2);
     138//  void ho_phase_2a_3(const NSLP_Context* context, void *param1, void *param2);
    138139#endif
    139140 
  • qos-nslp/branches/20090610-qos-nslp-aho/include/qos_nslp_contextmap.h

    r3406 r4503  
    1010#include "sessionid.h"
    1111#include "mri_pc.h"
     12#include "QoS_StateModule.h"
    1213
    1314using namespace protlib;
     
    5758  bool insert(const sessionid& sid, NSLP_Context* context);
    5859  void erase(const sessionid& sid);
     60  typedef void (state_manager::*proc_func_t)(const NSLP_Context *, void *, void *);
     61  void traverse_contexts(state_manager *sm, proc_func_t func, void *param1, void *param2);
    5962
    6063}; // end class ContextMap
  • qos-nslp/branches/20090610-qos-nslp-aho/src/ProcessingModule.cpp

    r4501 r4503  
    469469                        DLog(param.name,"SID is NULL");
    470470                }
     471
    471472                return;
    472473        }
    473474
    474475        if (nslp_data == NULL) {
     476// TODO: abfrage nach ganz außen verlegen
    475477if(r_mri->get_mrm() == mri::mri_t_pathcoupled) {
    476478                DLog(param.name, "SII handle is " << sii);
     
    655657ProcessingModule::process_est_sig_msg(ExplicitSignalingMsg* sigmsg)
    656658{
    657   known_nslp_pdu* pdu = NULL;
    658   NetMsg* netmsg = NULL;
    659   uchar* buffer;
     659        known_nslp_pdu* pdu = NULL;
     660        NetMsg* netmsg = NULL;
     661        uchar* buffer;
    660662        uint32 buffer_size;
    661663        state_manager::error_t nslperror = state_manager::error_ok;
    662664
    663665
    664   assert(sigmsg!=NULL);
    665 
    666   pdu = sigmsg->get_pdu();
    667   if(pdu) {
     666        assert(sigmsg!=NULL);
     667
     668        pdu = sigmsg->get_pdu();
     669        if(pdu) {
    668670                sessionid* sid = new sessionid(sigmsg->get_sid());
    669671
     
    674676
    675677
    676     nslperror = statemodule->process_outgoing_est_msg(*pdu, netmsg, sid, &sig_mri);
    677     if (nslperror!=state_manager::error_ok) {
    678       delete sigmsg;
     678                nslperror = statemodule->process_outgoing_est_msg(*pdu, netmsg, sid, &sig_mri);
     679                if (nslperror!=state_manager::error_ok) {
     680                        delete sigmsg;
    679681
    680682                        ERRLog(param.name, "process_outgoing_est_msg returned error: " << state_manager::error_string(nslperror));
    681     }
    682     else {
     683                }
     684                else {
    683685                        assert(netmsg!=NULL);
    684686
     
    11221124 * @param nslp_data NSLP data in form of unsigned char.
    11231125 * @param nslp_data_size the size of NSLP data.
    1124  * @param sigmsg the internal message with extra parameters for sending a message via NTLP.
    1125  */
    1126 /*
    1127 state_manager::error_t
    1128 ProcessingModule::SendMessage(uchar* nslp_data, uint32 nslp_data_size, SignalingMsg* sigmsg)
    1129 {
    1130         NetMsg* netmsg = NULL;
    1131         state_manager::error_t nslpres = state_manager::error_ok;
    1132         uint32 size = nslp_data_size + sizeof(size);
    1133         if (size>NetMsg::max_size)
    1134         {
    1135           ERRLog(param.name, "state_manager::generate_pdu() cannot allocate " << size << " bytes NetMsg, PDU too big for NetMsg maxsize " << NetMsg::max_size);
    1136           nslpres = state_manager::error_pdu_too_big;
    1137         }
    1138         else
    1139         {
    1140           // allocate a netmsg with the corresponding buffer size
    1141           netmsg= new(nothrow) NetMsg(size);
    1142           if (netmsg)
    1143           {
    1144             netmsg->encode32(size/4);
    1145             netmsg->encode(nslp_data, nslp_data_size);
    1146 
    1147               ostringstream hexdump;
    1148               netmsg->hexdump(hexdump,netmsg->get_buffer(), nslp_data_size+4);
    1149               Log(DEBUG_LOG,LOG_NORMAL,param.name,"PDU debugging enabled:" << hexdump.str());
    1150            
    1151             ntlp::APIMsg* msg = new ntlp::APIMsg();
    1152             ntlp::nslpdata* data = new ntlp::nslpdata(nslp_data, nslp_data_size);
    1153             uint128 sid;
    1154             sigmsg->get_sid(sid);
    1155             ntlp::sessionid* ntlp_sid = new ntlp::sessionid(sid);
    1156             uint32 nslpmsghandle = 0;
    1157             uint32 sii_handle = 0;
    1158             sii_handle = sigmsg->get_sii_handle();
    1159             uint8 ttl = 103;
    1160             uint32 timeout = 15;
    1161             uint32 hop_count = 100;
    1162             uint32 nslpid = 1;
    1163             ntlp::tx_attr_t tx_attr;
    1164             tx_attr.reliable = false;
    1165             tx_attr.secure =false;
    1166             bool downstream = sigmsg->get_downstream();
    1167             ntlp::mri_pathcoupled* nslp_mri = NULL;
    1168             nslp_mri = sigmsg->get_sig_mri()->copy();
    1169             if (downstream != nslp_mri->get_downstream()) {
    1170               DLog(param.name, "Message should be sent " << (downstream?"downstream":"upstream") << ", Inverting MRI");
    1171               nslp_mri->invertDirection();
    1172             }
    1173             hostaddress s, d;
    1174             s = nslp_mri->get_sourceaddress();
    1175             d = nslp_mri->get_destaddress();
    1176             msg->set_sendmessage(data, nslpmsghandle, nslpid, ntlp_sid, nslp_mri, sii_handle, tx_attr, timeout, ttl, hop_count);
    1177             // set sender
    1178             msg->set_source(message::qaddr_api_1);
    1179             // send the message
    1180             DLog(param.name, "sending message to GIST");
    1181             sigmsg = NULL;
    1182             msg->send_to(message::qaddr_coordination);
    1183           }
    1184         }
    1185         return nslpres;
    1186 }
    1187 */
    1188 
    1189 /** Function to send a message via NTLP.
    1190  * @param nslp_data NSLP data in form of unsigned char.
    1191  * @param nslp_data_size the size of NSLP data.
    11921126 */
    11931127state_manager::error_t
     
    12201154                        const uint32 nslpid = 1;
    12211155
    1222 //                      uint128 sid;
    1223 //                      sigmsg->get_sid(sid);
    1224 //                      ntlp::sessionid* ntlp_sid = new ntlp::sessionid(sid);
    1225 
    1226 //                      uint32 nslpmsghandle = 0;
    1227 //                      uint32 sii_handle = 0;
    1228 //                      sii_handle = sigmsg->get_sii_handle();
    1229 //                      uint8 ttl = 103;
    1230 //                      uint32 timeout = 15;
    1231 //                      uint32 hop_count = 100;
    1232 //                      uint32 nslpid = 1;
    1233 //                      ntlp::tx_attr_t tx_attr;
    1234 //                      tx_attr.reliable = false;
    1235 //                      tx_attr.secure =false;
    1236 
    1237 ////                    bool downstream = sigmsg->get_downstream();
    1238 ////                    ntlp::mri_pathcoupled* nslp_mri = NULL;
    1239 ////                    nslp_mri = sigmsg->get_sig_mri()->copy();
    1240 ////                    if (downstream != nslp_mri->get_downstream()) {
    1241 ////                            DLog(param.name, "Message should be sent " << (downstream?"downstream":"upstream") << ", Inverting MRI");
    1242 ////                            nslp_mri->invertDirection();
    1243 ////                    }
    1244 
    12451156                        ntlp::APIMsg* msg = new ntlp::APIMsg();
    12461157                        msg->set_sendmessage(data, nslpmsghandle, nslpid, sid, mr, sii_handle, tx_attr, timeout, ip_ttl, ghc);
     
    12511162                        // send the message
    12521163                        DLog(param.name, "Sending message to GIST");
    1253 //                      sigmsg = NULL;
    12541164                        msg->send_to(message::qaddr_coordination);
    12551165                }
  • qos-nslp/branches/20090610-qos-nslp-aho/src/QoS_StateModule.cpp

    r4501 r4503  
    40124012
    40134013        // TODO: Anticipated Handover - Phase 1
     4014        // TODO: Locking while Handover
     4015       
     4016        contextmap.traverse_contexts(this, &qos_nslp::state_manager::aho_phase1, NULL, NULL);
    40144017
    40154018// ------------------------------------------------------------------------------------
     
    40944097
    40954098        // TODO: Anticipated Handover - Phase 3 / 2a
     4099}
     4100
     4101void state_manager::aho_phase_1(const NSLP_Context* context, void *param1, void *param2) {
     4102        ILog(state_manager::modname, "aho_phase_1(context)");
    40964103}
    40974104#endif // USE_AHO
  • qos-nslp/branches/20090610-qos-nslp-aho/src/qos_nslp_contextmap.cpp

    r3702 r4503  
    130130}
    131131
     132
     133/*
     134 * Traverses all contexts of the ContextMap executing func on them.
     135 * Because of locking reasons func should run as short as possible.
     136 */
     137void
     138ContextMap::traverse_contexts(state_manager *sm, proc_func_t func, void *param1, void *param2)
     139{
     140  lock();
     141
     142  context_hashmap_const_it_t it=context_hashmap.begin();
     143  while(it != context_hashmap.end()) {
     144          // execute function "func"
     145          (sm->*func)(it->second, param1, param2);
     146
     147          it++;
     148  }
     149
     150  unlock();
     151}
     152
    132153} // end namespace qos_nslp
Note: See TracChangeset for help on using the changeset viewer.