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

Changeset 4500


Ignore:
Timestamp:
Sep 29, 2009, 6:06:00 PM (8 years ago)
Author:
stud-dettling
Message:
  • Added functionality to send and receive EST-Messages from QoS NSLP
Location:
qos-nslp/branches/20090610-qos-nslp-aho
Files:
4 edited

Legend:

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

    r3701 r4500  
    1818#include "nslp_context.h"
    1919#include "mri.h"
     20#include "mri_est.h"
    2021#include "SignalingAppl.h"
    2122#include "apimessage.h"
     
    2829// forward declaration
    2930class SignalingMsg;
    30          /// ProcessingModule module parameters
    31         struct ProcessingModuleParam : public ThreadParam {
    32                         ProcessingModuleParam(
    33                                               uint32 sleep_time,
    34                                               AddressList &addresses,
    35                                               Flowinfo &fi_service,
    36                                               bool see = true,
    37                                               bool sre = true
    38                 );
    39                 const  message::qaddr_t source;
    40                 AddressList &addresses;
    41                 Flowinfo &fi_service;
    42                 const  bool send_error_expedited;
    43                 const  bool send_reply_expedited;
    44         }; // end ProcessingModuleParam
     31class ExplicitSignalingMsg;
     32
     33/// ProcessingModule module parameters
     34struct ProcessingModuleParam : public ThreadParam {
     35        ProcessingModuleParam(
     36                        uint32 sleep_time,
     37                        AddressList &addresses,
     38                        Flowinfo &fi_service,
     39                        bool see = true,
     40                        bool sre = true
     41        );
     42        const  message::qaddr_t source;
     43        AddressList &addresses;
     44        Flowinfo &fi_service;
     45        const  bool send_error_expedited;
     46        const  bool send_reply_expedited;
     47}; // end ProcessingModuleParam
    4548
    4649/// @class ProcessingModule
     
    6063                /// module main loop
    6164                virtual void main_loop(uint32 nr);
    62                 state_manager::error_t SendMessage(uchar* nslp_data, uint32 nslp_data_size, SignalingMsg* sigmsg);
     65                // TODO: remove
     66                //---------------------------------------------------------------------------------------------------------------
     67                //state_manager::error_t SendMessage(uchar* nslp_data, uint32 nslp_data_size, SignalingMsg* sigmsg);
     68                //---------------------------------------------------------------------------------------------------------------
     69                state_manager::error_t SendMessage(uchar* nslp_data, uint32 nslp_data_size, sessionid* sid, mri* mr, uint32 sii_handle=0,
     70                                msghandle_t nslpmsghandle=0, tx_attr_t tx_attr=tx_attr_t(), uint32 timeout=15, uint16 ip_ttl=103, uint32 ghc=100);
    6371        private:
    6472                /// module parameters
     
    6977                void process_queue();
    7078                void process_sig_msg(SignalingMsg* msg);
     79                //---------------------------------------------------------------------------------------------------------------
     80                void process_est_sig_msg(ExplicitSignalingMsg* msg);
     81                //---------------------------------------------------------------------------------------------------------------
    7182                void rcv_appl_messages();
    7283                void process_appl_msg(QoS_Appl_Msg* applmsg);
     
    139150}; // end class SignalingMsg
    140151
     152
     153/// explicit signaling message
     154/** Messages of this type are exchanged between the signaling module and
     155 * the coordination module.
     156 */
     157class ExplicitSignalingMsg : public message {
     158public:
     159        /// constructor
     160        ExplicitSignalingMsg();
     161        /// destructor
     162        virtual ~ExplicitSignalingMsg();
     163
     164        /// mri
     165        const ntlp::mri_explicitsigtarget* get_sig_mri() const { return sig_mri; }
     166        void set_sig_mri(const ntlp::mri_explicitsigtarget* set_mri);
     167
     168        /// set sid
     169        void set_sid(const uint128& r) {
     170          sig_sid.w1 = r.w1;
     171          sig_sid.w2 = r.w2;
     172          sig_sid.w3 = r.w3;
     173          sig_sid.w4 = r.w4;
     174        }
     175        /// get sid
     176        void get_sid(uint128& r) const {
     177          r.w1 = sig_sid.w1;
     178          r.w2 = sig_sid.w2;
     179          r.w3 = sig_sid.w3;
     180          r.w4 = sig_sid.w4;
     181        }
     182
     183        const uint128 get_sid() const { return sig_sid; }
     184
     185        // @{
     186        void set_pdu(known_nslp_pdu* p);
     187        known_nslp_pdu* get_pdu() const { return pdu; }
     188        // @}
     189
     190        void set_sii_handle(uint32 sii) { sii_handle = sii; }
     191        uint32 get_sii_handle() const { return sii_handle; }
     192
     193        /// clear pointers
     194        virtual void clear_pointers();
     195        //@{
     196        /// send message to coordination or signaling module
     197        bool send(bool exp = false);
     198        void send_or_delete(bool exp = false) { if (!send(exp)) delete this; }
     199        //@}
     200
     201private:
     202        known_nslp_pdu* pdu;
     203        uint128 sig_sid;
     204        ntlp::mri_explicitsigtarget* sig_mri;
     205        uint32 sii_handle;
     206}; // end class ExplicitSignalingMsg
     207
    141208} // end namespace qos_nslp
    142209
  • qos-nslp/branches/20090610-qos-nslp-aho/include/QoS_StateModule.h

    r4466 r4500  
    3030#include "address.h"
    3131#include "mri_pc.h"
     32#include "mri_est.h"
    3233#include "flowinfo.h"
    3334#include "apimessage.h"
     
    7576  error_t process_tp_recv_msg(NetMsg& msg, known_nslp_pdu*& respdu, bool down,
    7677                              const ntlp::sessionid* sid, const ntlp::mri_pathcoupled* rcvd_mri);
     78  error_t process_tp_recv_est_msg(NetMsg& msg, known_nslp_pdu*& respdu, const ntlp::sessionid* sid,
     79                              const ntlp::mri_explicitsigtarget* rcvd_mri);
    7780  error_t process_outgoing(known_nslp_pdu& rsppdu, NetMsg*& msg, bool down,
    7881                           const ntlp::sessionid* rcvd_sid, ntlp::mri_pathcoupled** rcvd_mri);
     82  error_t process_outgoing_est_msg(known_nslp_pdu& rsppdu, NetMsg*& msg, const ntlp::sessionid* rcvd_sid,
     83                                ntlp::mri_explicitsigtarget** rcvd_mri);
    7984  error_t create_new_context(known_nslp_pdu& pdu, error_t& nslpres, bool down,
    8085                             const ntlp::sessionid* local_sid, const ntlp::mri_pathcoupled* rcvd_mri,
     
    148153  // return whether this node is a last hop for this data flow
    149154  bool is_last_signaling_hop(const ntlp::mri_pathcoupled* flow_mri, bool down = true) const;
     155  bool is_last_signaling_hop(const ntlp::mri_explicitsigtarget* mri) const;
    150156  static const char *const errstr[];
    151157
  • qos-nslp/branches/20090610-qos-nslp-aho/src/ProcessingModule.cpp

    r4466 r4500  
    142142        message* msg = NULL;
    143143        SignalingMsg* sigmsg = NULL;
     144        ExplicitSignalingMsg* explsigmsg = NULL;
    144145
    145146        FastQueue* fq = QueueManager::instance()->get_queue(param.source);
     
    165166                                ERRLog(param.name, "Cannot cast message from source " <<
    166167                                                msg->get_qaddr_name() << " of type " <<
    167                                                 msg->get_type_name() << " to TPMsg");
     168                                                msg->get_type_name() << " to SignalingMsg");
     169                                delete msg;
     170                        }
     171                        break;
     172                case message::type_explicit_signaling:
     173                        explsigmsg = dynamic_cast<ExplicitSignalingMsg*>(msg);
     174                        if (explsigmsg) {
     175                                // outgoing explicit signaling message, sent to GIST
     176                                process_est_sig_msg(explsigmsg);
     177                        }
     178                        else {
     179                                ERRLog(param.name, "Cannot cast message from source " <<
     180                                                msg->get_qaddr_name() << " of type " <<
     181                                                msg->get_type_name() << " to ExplicitSignalingMsg");
    168182                                delete msg;
    169183                        }
     
    473487                netmsg->encode(nslp_buf, nslp_size);
    474488                netmsg->to_start();
    475                 bool down = rcvd_mri->get_downstream();
    476489
    477490                ntlp::sessionid* my_sid = new ntlp::sessionid(*rcvd_sid);
    478491     
     492
    479493                DLog(param.name, "process_gist_api_msg() - received PDU now parsing...");
    480494
    481                 // process NetMsg by NSLP (generates C++ objects from byte stream)
    482                 nslperror = statemodule.process_tp_recv_msg(*netmsg, result_pdu, down, my_sid, rcvd_mri);
    483                 if (nslperror != state_manager::error_old_pdu) {
    484                         // if the direction of the MRI is downstream, the message came from the upstream peer
    485                         statemodule.process_sii_handle(sii, !down, my_sid, rcvd_mri, APIMsg::error_msg_delivered);
     495                if(r_mri->get_mrm() == mri::mri_t_pathcoupled) {
     496                        // PC-MRI
     497                        bool down = rcvd_mri->get_downstream();
     498
     499                        // process NetMsg by NSLP (generates C++ objects from byte stream)
     500                        nslperror = statemodule.process_tp_recv_msg(*netmsg, result_pdu, down, my_sid, rcvd_mri);
     501                        if (nslperror != state_manager::error_old_pdu) {
     502                                // if the direction of the MRI is downstream, the message came from the upstream peer
     503                                statemodule.process_sii_handle(sii, !down, my_sid, rcvd_mri, APIMsg::error_msg_delivered);
     504                        }
     505                        DLog(param.name, "process_gist_api_msg() - parsed PDU");
     506
     507                        // now result_pdu is returned, check for result/error during decoding
     508                        switch (nslperror) {
     509                        case state_manager::error_old_pdu:
     510                        case state_manager::error_rsn_missing:
     511                        case state_manager::error_no_bandwidth:
     512                                  DLog(param.name, "process_gist_api_msg() - process_tp_recv_msg() returned an error: " << state_manager::error_string(nslperror));
     513                        case state_manager::error_nothing_to_do:
     514                        case state_manager::error_ok_forward:
     515                                {
     516                                  if (result_pdu)
     517                                    delete result_pdu;
     518                                }
     519                                break;
     520
     521                        case state_manager::error_ok:
     522                                {
     523                                        DLog(param.name, "process_gist_api_msg() - process_tp_recv_msg() returned ok");
     524                                        sigmsg = new SignalingMsg;
     525                                        assert(result_pdu != NULL);
     526                                        assert(sigmsg != NULL);
     527                                        DLog(param.name, "process_gist_api_msg() - sending " << result_pdu->get_ie_name() << " to coordination");
     528                                        // send this to the coordinator
     529                                        result_pdu = NULL;
     530                                        if (!sigmsg->send_to(message::qaddr_qos_nslp_coordination, false)) {
     531                                                ERRLog(param.name, "Cannot send a message to " << message::get_qaddr_name(message::qaddr_qos_nslp_coordination));
     532                                                delete sigmsg;
     533                                        } // end if not sent
     534                                }
     535                                break;
     536
     537                        default:
     538                                {
     539                                        ERRLog(param.name, "Received an NSLP error (#"
     540                                               << nslperror << ':' << state_manager::error_string(nslperror) << ") that cannot be handled. Deleting NetMsg");
     541                                        if (result_pdu)
     542                                                delete result_pdu;
     543                                }
     544                                break;
     545                        } // end switch nslperror
     546
    486547                }
    487                 DLog(param.name, "process_gist_api_msg() - parsed PDU");
    488 
    489                 // now result_pdu is returned, check for result/error during decoding
    490                 switch (nslperror) {
    491                 case state_manager::error_old_pdu:
    492                 case state_manager::error_rsn_missing:
    493                 case state_manager::error_no_bandwidth:
    494                           DLog(param.name, "process_gist_api_msg() - process_tp_recv_msg() returned an error: " << state_manager::error_string(nslperror));
    495                 case state_manager::error_nothing_to_do:
    496                 case state_manager::error_ok_forward:
    497                         {
    498                           if (result_pdu)
    499                             delete result_pdu;
    500                         }
    501                         break;
    502 
    503                 case state_manager::error_ok:
    504                         {
    505                                 DLog(param.name, "process_gist_api_msg() - process_tp_recv_msg() returned ok");
    506                                 sigmsg = new SignalingMsg;
    507                                 assert(result_pdu != NULL);
    508                                 assert(sigmsg != NULL);
    509                                 DLog(param.name, "process_gist_api_msg() - sending " << result_pdu->get_ie_name() << " to coordination");
    510                                 // send this to the coordinator
    511                                 result_pdu = NULL;
    512                                 if (!sigmsg->send_to(message::qaddr_qos_nslp_coordination, false)) {
    513                                         ERRLog(param.name, "Cannot send a message to " << message::get_qaddr_name(message::qaddr_qos_nslp_coordination));
    514                                         delete sigmsg;
    515                                 } // end if not sent
    516                         }
    517                         break;
    518 
    519                 default:
    520                         {
    521                                 ERRLog(param.name, "Received an NSLP error (#"
    522                                        << nslperror << ':' << state_manager::error_string(nslperror) << ") that cannot be handled. Deleting NetMsg");
    523                                 if (result_pdu)
    524                                         delete result_pdu;
    525                         }
    526                         break;
    527                 } // end switch nslperror
     548                else if(r_mri->get_mrm() == mri::mri_t_explicitsigtarget) {
     549                        // EST_MRI
     550                        ntlp::mri_explicitsigtarget* rcvd_est_mri = dynamic_cast<ntlp::mri_explicitsigtarget*>(r_mri);
     551                        if(rcvd_est_mri != NULL) {
     552                                statemodule.process_tp_recv_est_msg(*netmsg, result_pdu, my_sid, rcvd_est_mri);
     553                                // TODO: error checking
     554                        }
     555                        else {
     556                                ERRLog(param.name, "Cannot cast MRI of type ntlp::mri to ntlp::mri_explicitsigtarget");
     557                        }
     558                }
     559                else {
     560                        ERRLog(param.name, "Received message with unknown MRI - MRI-ID: " << r_mri->get_mrm());
     561                }
    528562     
    529563                // NetMsg is no longer needed
     
    579613      netmsg->to_start();
    580614      buffer = netmsg->get_buffer();
    581       nslperror = SendMessage(buffer, netmsg->get_size(), sigmsg);
     615
     616      uint128 sid;
     617      sigmsg->get_sid(sid);
     618      ntlp::sessionid* ntlp_sid = new ntlp::sessionid(sid);
     619
     620      uint32 sii_handle = 0;
     621      sii_handle = sigmsg->get_sii_handle();
     622     
     623      if (d != sig_mri->get_downstream()) {
     624              DLog(param.name, "Message should be sent " << (d?"downstream":"upstream") << ", Inverting MRI");
     625              sig_mri->invertDirection();
     626      }
     627
     628      nslperror = SendMessage(buffer, netmsg->get_size(), ntlp_sid, sig_mri, sii_handle);
    582629    }
    583630  }
     
    598645} // end process_sig_msg
    599646
     647
     648/**
     649 * process outgoing EST message that should be transferred by GIST
     650 * (outgoing explicit signaling message, sent subsequently to TP module).
     651 */
     652void
     653ProcessingModule::process_est_sig_msg(ExplicitSignalingMsg* sigmsg)
     654{
     655  known_nslp_pdu* pdu = NULL;
     656  NetMsg* netmsg = NULL;
     657  uchar* buffer;
     658        uint32 buffer_size;
     659        state_manager::error_t nslperror = state_manager::error_ok;
     660
     661
     662  assert(sigmsg!=NULL);
     663
     664  pdu = sigmsg->get_pdu();
     665  if(pdu) {
     666                sessionid* sid = new sessionid(sigmsg->get_sid());
     667
     668                ntlp::mri_explicitsigtarget* sig_mri = sigmsg->get_sig_mri()->copy();
     669
     670                uint32 sii_handle = 0;
     671                sii_handle = sigmsg->get_sii_handle();
     672
     673
     674    nslperror = statemodule->process_outgoing_est_msg(*pdu, netmsg, sid, &sig_mri);
     675    if (nslperror!=state_manager::error_ok) {
     676      delete sigmsg;
     677
     678                        ERRLog(param.name, "process_outgoing_est_msg returned error: " << state_manager::error_string(nslperror));
     679    }
     680    else {
     681                        assert(netmsg!=NULL);
     682
     683                        netmsg->to_start();
     684                        buffer = netmsg->get_buffer();
     685
     686                        buffer_size = netmsg->get_size();
     687               
     688                        SendMessage(buffer, buffer_size, sid, sig_mri, sii_handle);
     689                }
     690        }
     691} // end process_est_sig_msg
     692
     693
     694
    600695/***** class SignalingMsg *****/
    601696
     
    643738        qaddr_t s = get_source();
    644739
     740        // XXX: First if-statement maybe useless, see SignalingMsg::set_msg ~~> set_source(qaddr_qos_nslp_coordination)
    645741        if (s != qaddr_qos_nslp_signaling) {
    646742                if (s != qaddr_unknown) {
     
    653749        }
    654750
     751        // XXX: Maybe dead code, see: SignalingMsg::set_msg ~~> set_source(qaddr_qos_nslp_coordination)
    655752        DLog("SIGNALING", "Sending to qaddr_qos_nslp_coordination");
    656753        return send_to(qaddr_qos_nslp_coordination,exp);
    657754} // end send
    658 
    659755
    660756/** This function sets the direction of the flow.
     
    664760        down = d;
    665761} // end set_downstream
     762
     763
     764// TODO:
     765// * Merge classes SignalingMsg and ExplicitSignalingMsg
     766// * Remove type_explicit_signaling
     767
     768/***** class ExplicitSignalingMsg *****/
     769
     770/** Default constructor for ExplicitSignalingMsg. */
     771ExplicitSignalingMsg::ExplicitSignalingMsg()
     772  : message(type_explicit_signaling), pdu(NULL), sig_mri(NULL), sii_handle(0)
     773{
     774}
     775
     776/** Destructor for ExplicitSignalingMsg. */
     777ExplicitSignalingMsg::~ExplicitSignalingMsg() {
     778        if (pdu) delete pdu;
     779        if (sig_mri) delete sig_mri;
     780} // end destructor
     781
     782/** This function sets the EST-MRI of the current ExplicitSignalingMsg.
     783  * @param set_mri the EST-MRI of the current ExplicitSignalingMsg.
     784  */
     785void ExplicitSignalingMsg::set_sig_mri(const ntlp::mri_explicitsigtarget* set_mri)
     786{
     787  delete sig_mri;
     788  sig_mri = set_mri->copy();
     789}
     790
     791/* Set signaling message.
     792 */
     793
     794void ExplicitSignalingMsg::set_pdu(known_nslp_pdu* p) {
     795        set_source(qaddr_qos_nslp_coordination);
     796        pdu = p;
     797} // end set_msg
     798
     799
     800/** Clear all pointers. */
     801void ExplicitSignalingMsg::clear_pointers() {
     802        pdu = NULL;
     803        sig_mri = NULL;
     804} // end clear_pointers
     805
     806/** This function sends the current ExplicitSignalingMsg to the appropriate queue.  */
     807bool ExplicitSignalingMsg::send(bool exp)
     808{
     809        qaddr_t s = get_source();
     810
     811        if (s != qaddr_unknown) {
     812                DLog("EXPL-SIGNALING", "Sending to qaddr_qos_nslp_signaling");
     813                return send_to(qaddr_qos_nslp_signaling, exp);
     814        } else {
     815                ERRLog("EXPL-SIGNALING", "Unknown qaddr");
     816                return false;
     817        }
     818} // end send
     819
    666820
    667821bool done = false;
     
    9681122 * @param sigmsg the internal message with extra parameters for sending a message via NTLP.
    9691123 */
     1124/*
    9701125state_manager::error_t
    9711126ProcessingModule::SendMessage(uchar* nslp_data, uint32 nslp_data_size, SignalingMsg* sigmsg)
     
    9871142            netmsg->encode32(size/4);
    9881143            netmsg->encode(nslp_data, nslp_data_size);
    989             /*
     1144
    9901145              ostringstream hexdump;
    9911146              netmsg->hexdump(hexdump,netmsg->get_buffer(), nslp_data_size+4);
    9921147              Log(DEBUG_LOG,LOG_NORMAL,param.name,"PDU debugging enabled:" << hexdump.str());
    993             */
    9941148           
    9951149            ntlp::APIMsg* msg = new ntlp::APIMsg();
     
    10291183        return nslpres;
    10301184}
    1031 
     1185*/
     1186
     1187/** Function to send a message via NTLP.
     1188 * @param nslp_data NSLP data in form of unsigned char.
     1189 * @param nslp_data_size the size of NSLP data.
     1190 */
     1191state_manager::error_t
     1192ProcessingModule::SendMessage(uchar* nslp_data, uint32 nslp_data_size, sessionid* sid, mri* mr, uint32 sii_handle,
     1193                msghandle_t nslpmsghandle, tx_attr_t tx_attr, uint32 timeout, uint16 ip_ttl, uint32 ghc)
     1194{
     1195        state_manager::error_t nslpres = state_manager::error_ok;
     1196
     1197        uint32 size = nslp_data_size + sizeof(size);
     1198        NetMsg* netmsg = NULL;
     1199
     1200        if(size > NetMsg::max_size) {
     1201                ERRLog(param.name, "state_manager::generate_pdu() cannot allocate " << size << " bytes NetMsg, PDU too big for NetMsg maxsize " << NetMsg::max_size);
     1202                nslpres = state_manager::error_pdu_too_big;
     1203        }
     1204        else {
     1205                // allocate a netmsg with the corresponding buffer size
     1206                netmsg = new(nothrow) NetMsg(size);
     1207                if(netmsg) {
     1208                        netmsg->encode32(size/4);
     1209                        netmsg->encode(nslp_data, nslp_data_size);
     1210
     1211                        /*
     1212                        ostringstream hexdump;
     1213                        netmsg->hexdump(hexdump, netmsg->get_buffer(), nslp_data_size+4);
     1214                        Log(DEBUG_LOG,LOG_NORMAL,param.name,"PDU debugging enabled:" << hexdump.str());
     1215                        */
     1216                       
     1217                        ntlp::nslpdata* data = new ntlp::nslpdata(nslp_data, nslp_data_size);
     1218                        const uint32 nslpid = 1;
     1219
     1220//                      uint128 sid;
     1221//                      sigmsg->get_sid(sid);
     1222//                      ntlp::sessionid* ntlp_sid = new ntlp::sessionid(sid);
     1223
     1224//                      uint32 nslpmsghandle = 0;
     1225//                      uint32 sii_handle = 0;
     1226//                      sii_handle = sigmsg->get_sii_handle();
     1227//                      uint8 ttl = 103;
     1228//                      uint32 timeout = 15;
     1229//                      uint32 hop_count = 100;
     1230//                      uint32 nslpid = 1;
     1231//                      ntlp::tx_attr_t tx_attr;
     1232//                      tx_attr.reliable = false;
     1233//                      tx_attr.secure =false;
     1234
     1235////                    bool downstream = sigmsg->get_downstream();
     1236////                    ntlp::mri_pathcoupled* nslp_mri = NULL;
     1237////                    nslp_mri = sigmsg->get_sig_mri()->copy();
     1238////                    if (downstream != nslp_mri->get_downstream()) {
     1239////                            DLog(param.name, "Message should be sent " << (downstream?"downstream":"upstream") << ", Inverting MRI");
     1240////                            nslp_mri->invertDirection();
     1241////                    }
     1242
     1243                        ntlp::APIMsg* msg = new ntlp::APIMsg();
     1244                        msg->set_sendmessage(data, nslpmsghandle, nslpid, sid, mr, sii_handle, tx_attr, timeout, ip_ttl, ghc);
     1245
     1246                        // set sender
     1247                        msg->set_source(message::qaddr_api_1);
     1248
     1249                        // send the message
     1250                        DLog(param.name, "Sending message to GIST");
     1251//                      sigmsg = NULL;
     1252                        msg->send_to(message::qaddr_coordination);
     1253                }
     1254
     1255                // TODO: Logging if memory allocation (new) failed
     1256        }
     1257
     1258        return nslpres;
     1259}
    10321260
    10331261}  //end namespace qos_nslp
  • qos-nslp/branches/20090610-qos-nslp-aho/src/QoS_StateModule.cpp

    r4466 r4500  
    9898}
    9999
     100
     101/** returns whether this Entity is the last hop for QoS NSLP signaling
     102 * this is true if the signaling destination is one of my addresses
     103 * or if I'm acting as proxy for the signaling destination address
     104 * @param recv_mri EST-MRI
     105 */
     106bool
     107state_manager::is_last_signaling_hop(const ntlp::mri_explicitsigtarget* mri) const
     108{
     109  // choose own address for comparison
     110  const hostaddress& sig_dest = mri->get_dest_sig_address();
     111
     112  if (addresses->addr_is(sig_dest, AddressList::ConfiguredAddr_P) ||
     113      addresses->addr_is(sig_dest, AddressList::LocalAddr_P)) {
     114                return true;
     115        }
     116        else {
     117                return false;
     118        }
     119}
     120
     121
    100122/** process/parse received incoming message from network.
    101123* This method parses the netmsg and returns the parsed PDU
     
    179201        }
    180202
     203        return state_manager::error_wrong_pdu_type;
     204}
     205
     206/** process/parse received incoming EST-MRM message from network.
     207* This method parses the netmsg and returns the parsed PDU
     208* in respdu.
     209* @param netmsg Incoming Network message (byte buffer).
     210* @retval resultpdu Result PDU (or errormsg case of error).
     211* @param sid the session id the current message belongs to.
     212* @param rcvd_mri the EST-MRI of the current session.
     213*/
     214state_manager::error_t
     215state_manager::process_tp_recv_est_msg(NetMsg& msg, known_nslp_pdu*& respdu, const ntlp::sessionid* sid,
     216                                  const ntlp::mri_explicitsigtarget* rcvd_mri)
     217{
    181218        return state_manager::error_wrong_pdu_type;
    182219}
     
    317354  return nslpres;
    318355} // end process_outgoing
     356
     357
     358/** prepares sending of a NSLP PDUs via the network.
     359* @param pdu NSLP PDU to be sent.
     360* @param netbuffer NetMsg buffer for serialization of the PDU into a bytes stream (is returned).
     361* @return internal NSLP_error_t errorcode, usually error_ok for success.
     362* @param rcvd_sid the session id the current message belongs to.
     363* @param rcvd_mri the MRI of the current session.
     364*/
     365state_manager::error_t state_manager::process_outgoing_est_msg(known_nslp_pdu& pdu, NetMsg*& netbuffer,
     366                const ntlp::sessionid* rcvd_sid, ntlp::mri_explicitsigtarget** rcvd_mri)
     367{
     368  error_t nslpres = error_ok;
     369
     370  /*
     371  error_t ret_nslpres = error_ok;
     372  netbuffer = NULL;
     373  bool updated = false;
     374  bool processing = false;
     375  bool is_tear = false;
     376        Flowstatus *fs = NULL;
     377
     378  NSLP_Context* context = rcvd_sid ? contextmap.find(*rcvd_sid) : 0;
     379        */
     380
     381  if(rcvd_sid) {
     382    ILog(state_manager::modname, "process_outgoing_est_msg(). SID [" <<  rcvd_sid->to_string() << "]");
     383        }
     384  else {
     385    ILog(state_manager::modname, "process_outgoing_est_msg(). SID [undefined]");
     386        }
     387
     388        // check if MRI state is valid
     389  if(!(*rcvd_mri)->check()) {
     390    ERRLog(state_manager::modname, "Invalid EST-MRI state!");
     391
     392    return error_nothing_to_do;
     393  }
     394
     395        /*
     396  hostaddress orig_a, source_a, dest_a;
     397  source_a = (*rcvd_mri)->get_sourceaddress();
     398  dest_a = (*rcvd_mri)->get_destaddress();
     399        */
     400
     401  if(pdu.is_notify()) {
     402    ILog(state_manager::modname, color[magenta] << "Outgoing NOTIFY message!" << color[off]);
     403        }
     404
     405  if(pdu.is_response()) {
     406    ILog(state_manager::modname, color[magenta] << "Outgoing RESPONSE message!" << color[off]);
     407        }
     408
     409  if(pdu.is_reserve()) {
     410    ILog(state_manager::modname, color[magenta] << "Outgoing RESERVE message!" << color[off]);
     411//    reservereq* reserve = dynamic_cast<reservereq*>(&pdu);
     412//    processing = reserve->get_originator();
     413  }
     414
     415        /*
     416  if ((!context) &&  pdu.is_tear_flag()) {
     417    is_tear = true;
     418    ERRLog(state_manager::modname, "TEAR FLAG is set to TRUE!");
     419  }
     420
     421  if ((processing) && (!is_tear)) {
     422    if (pdu.is_reserve()) {
     423      updated = find_and_update_context(&pdu, nslpres, down, rcvd_sid, *rcvd_mri, fs);
     424      if (!updated)
     425        ret_nslpres = create_new_context(pdu, nslpres, down, rcvd_sid, *rcvd_mri, fs);
     426    }
     427    if ((ret_nslpres!=error_ok) &&
     428        (ret_nslpres != error_ok_send_response) &&
     429        (ret_nslpres != error_ok_forward)) {
     430      if (netbuffer)
     431        delete netbuffer;
     432      netbuffer = NULL;
     433      return ret_nslpres;
     434    } // end if error
     435  }
     436        */
     437
     438  if(pdu.is_query()) {
     439    ILog(state_manager::modname, color[magenta] << "Outgoing QUERY message!" << color[off]);
     440                /*
     441    ret_nslpres = error_ok;
     442    querymsg* query = dynamic_cast<querymsg*>(&pdu);
     443               
     444    bool continue_it = true;
     445    bool i_am_originator = query->get_originator();
     446    if (i_am_originator) {
     447      rii* check_rii = query->get_rii();
     448      if (check_rii) {
     449        if ( ( down && is_last_signaling_hop(*rcvd_mri) )  || ( down == false ) ) {
     450          // this situation should not happen, QNR MAY send QUERY msgs ONLY w/o RII
     451          ret_nslpres = error_nothing_to_do;
     452          ERRLog(state_manager::modname, "QNR attempting to send a QUERY msg with RII or QUERY upstream w/ RII, deleting it!");
     453          continue_it = false;
     454        }
     455      }
     456      else
     457        { // no RII object present
     458          if ( ( down || ((!down) && is_last_signaling_hop(*rcvd_mri) ) )
     459               && query->is_reserve_init_flag() == false ) {
     460            // this situation should not happen, QNI MAY send QUERY msgs ONLY with RII
     461            ret_nslpres = error_nothing_to_do;
     462            ERRLog(state_manager::modname, "QNI attempting to send a QUERY msg w/o RII or R-Flag, delete it!");
     463            continue_it = false;
     464          }
     465        } // end else
     466    } // end if I am an originator of this QUERY
     467               
     468    if (i_am_originator && continue_it)
     469      ret_nslpres = process_outgoing_query(pdu, down, rcvd_sid, *rcvd_mri, fs);
     470
     471    if (ret_nslpres!=error_ok) {
     472      if (netbuffer)
     473        delete netbuffer;
     474      netbuffer = NULL;
     475      return ret_nslpres;
     476    } // end if error
     477                */
     478  }
     479
     480  if(is_last_signaling_hop(*rcvd_mri)) {
     481    ERRLog(state_manager::modname, "Trying to send EST-Message to myself - I'll stop right here!");
     482//    if (netbuffer)
     483//      delete netbuffer;
     484//    netbuffer = NULL;
     485    return error_nothing_to_do;
     486  }
     487
     488  // now serialize
     489  nslpres = generate_pdu(pdu, netbuffer);
     490
     491  if(nslpres!=error_ok) {
     492    if (netbuffer) {
     493                        delete netbuffer;
     494                }
     495    netbuffer = NULL;
     496  } // end if error
     497
     498
     499  return nslpres;
     500} // end process_outgoing_est_msg
     501
    319502
    320503/** processes received QUERY message.
     
    37853968
    37863969        // TODO: Anticipated Handover - Phase 1
     3970
     3971// ------------------------------------------------------------------------------------
     3972        reservereq* res = new reservereq();
     3973        //copy_reserve_message(reservemsg, tunnel_res);
     3974
     3975        rsn* new_rsn = new rsn();
     3976        new_rsn->generate_new();
     3977        res->set_rsn(new_rsn);
     3978
     3979        // RII
     3980        //if (reservemsg->get_bool_rii()) {
     3981        //      rii* new_rii = new rii();
     3982        //      new_rii->generate_new();
     3983        //      new_rii->set_own(true);
     3984        //      tunnel_res->set_rii(new_rii);
     3985        //}
     3986
     3987        res->set_originator(true);
     3988
     3989        known_nslp_pdu *pdu = dynamic_cast<known_nslp_pdu*>(res);
     3990
     3991//      ntlp::sessionid* sid = new sessionid();
     3992//      sid->generate_random();
     3993        //tsid = *sid;
     3994
     3995        //bound_sessionid* send_bs = new bound_sessionid();
     3996        //send_bs->set(tsid);
     3997        //reservemsg->set_bound_sid(send_bs);
     3998
     3999//------------------------------------------
     4000//      NetMsg* netmsg = NULL;
     4001//      uchar* buffer;
     4002//      state_manager::error_t nslpres;
     4003
     4004        ntlp::sessionid* sid = new sessionid();
     4005        sid->generate_random();
     4006
     4007//      // now serialize
     4008//      nslpres = generate_pdu(*pdu, netmsg);
     4009
     4010//      if(nslpres == state_manager::error_ok) {
     4011//              netmsg->to_start();
     4012//              buffer = netmsg->get_buffer();
     4013//              nslpres = SendMessage(buffer, netmsg->get_size(), sigmsg);
     4014//      }
     4015
     4016// ------------------------------------------------------------------------------------
     4017
     4018        hostaddress src_pc_mri("10.1.2.2");
     4019        hostaddress dst_pc_mri("10.2.4.4");
     4020        bool downstream = true;
     4021        hostaddress orig_sig_addr("10.1.2.1");
     4022        hostaddress dest_sig_addr("10.1.2.2");
     4023
     4024        mri_pathcoupled pc_mri(src_pc_mri, 32, dst_pc_mri, 32, downstream);
     4025        mri_explicitsigtarget *est_mri = new mri_explicitsigtarget(pc_mri, orig_sig_addr, dest_sig_addr);
     4026
     4027                //ProcessingModule::SendMessage(buffer, netmsg->get_size(), sid, est_mri, 0);
     4028
     4029// ------------------------------------------------------------------------------------
     4030
     4031        ExplicitSignalingMsg* sigmsg = new ExplicitSignalingMsg();
     4032        sigmsg->set_pdu(pdu);
     4033        sigmsg->set_sid(*sid);
     4034        sigmsg->set_sig_mri(est_mri);
     4035        sigmsg->send_or_delete();
     4036//      }
    37874037}
    37884038
Note: See TracChangeset for help on using the changeset viewer.