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

Changeset 4567


Ignore:
Timestamp:
Oct 16, 2009, 12:16:48 PM (8 years ago)
Author:
stud-dettling
Message:
  • Refactored methods send_response_with_rii and send_response_with_rsn
  • Added X-Flag to InitQuery? and InitReserve? for Hard Handover
  • Extended NSLP_AHO_Context
  • Continued implementation of AHO phase 2 / 2a
  • Corrected processing of received RESPONSE-AHO message
  • Code beautification
  • Implemented Hard Handover
  • Refactored method process_gist_api_msg
Location:
qos-nslp/branches/20090610-qos-nslp-aho
Files:
6 edited

Legend:

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

    r4546 r4567  
    3333#include "flowinfo.h"
    3434#include "apimessage.h"
     35#include "nslp_aho_context.h"
    3536
    3637#include <pthread.h>
     
    7677  error_t process_tp_recv_msg(NetMsg& msg, known_nslp_pdu*& respdu, bool down,
    7778                              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);
     79  void process_tp_recv_est_msg(NetMsg& msg, const ntlp::sessionid* sid, const ntlp::mri_explicitsigtarget* rcvd_mri);
    8080  error_t process_outgoing(known_nslp_pdu& rsppdu, NetMsg*& msg, bool down,
    8181                           const ntlp::sessionid* rcvd_sid, ntlp::mri_pathcoupled** rcvd_mri);
     
    9595                                 bool is_qni, bool is_qnr, bool& forw, const ntlp::sessionid* local_sid, const ntlp::mri_pathcoupled* rcvd_mri,
    9696                                 bool down);
    97   void send_response_with_rii(rii* rcvd_rii, bool is_qnr, bool down, const ntlp::sessionid* sid, const ntlp::mri_pathcoupled* rcvd_mri,
    98                               info_spec::errorclass_t e_class, info_spec::errorcode_t e_code);
    99   void send_response_with_rsn(rsn* rcvd_rsn, bool down, const ntlp::sessionid* sid, const ntlp::mri_pathcoupled* rcvd_mri,
    100                               info_spec::errorclass_t e_class, info_spec::errorcode_t e_code);
     97//  void send_response_with_rii(rii* rcvd_rii, bool down, const ntlp::sessionid* sid, const ntlp::mri_pathcoupled* rcvd_mri,
     98//                            info_spec::errorclass_t e_class, info_spec::errorcode_t e_code);
     99  void send_response_with_rii(rii* rii, const ntlp::sessionid* sid, const ntlp::mri* mri, bool down,
     100                  info_spec::errorclass_t err_class, info_spec::errorcode_t err_code);
     101//  void send_response_with_rsn(rsn* rcvd_rsn, bool down, const ntlp::sessionid* sid, const ntlp::mri_pathcoupled* rcvd_mri,
     102//                            info_spec::errorclass_t e_class, info_spec::errorcode_t e_code);
     103  void send_response_with_rsn(rsn* rsn, const ntlp::sessionid* sid, const ntlp::mri* mri, bool down,
     104                  info_spec::errorclass_t err_class, info_spec::errorcode_t err_code);
    101105  void send_refresh_reserve(NSLP_Context* context);
    102106  void process_response_msg(known_nslp_pdu* known_pdu, bool down,
     
    138142  void ho_phase_3_2a(NSLP_Context* context, void *param1, void *param2);
    139143  void forward_message_if_new_access_router(known_nslp_pdu* known_pdu, const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri);
     144  void activate_or_create_new_reservation_with_phase3(NSLP_Context* context, const ntlp::sessionid *sid, ntlp::mri_pathcoupled* mri,
     145                  NSLP_Context::qn_type_t qn_type, const hostaddress &l3_mn, bool is_flow_sender, bool is_flow_receiver);
    140146#endif
    141147  void create_reserve_message_from_context(NSLP_Context *context, reservereq *res, rii *send_rii=NULL);
  • qos-nslp/branches/20090610-qos-nslp-aho/include/nslp_aho_context.h

    r4556 r4567  
    1111#include "mri_pc.h"
    1212#include "rii.h"
     13#include "rsn.h"
     14#include "qspec.h"
    1315
    1416
     
    4648  const hostaddress &get_addr_new_access_router() const;
    4749
    48   void set_is_flow_sender(bool is_sender);
    49   bool get_is_flow_sender() const;
    50 
    51   void set_is_flow_receiver(bool is_receiver);
    52   bool get_is_flow_receiver() const;
    53 
    5450  void set_mri_new_flow(const ntlp::mri_pathcoupled &mri);
    5551  const ntlp::mri_pathcoupled &get_mri_new_flow() const;
     
    6056  void set_anticipated_reservation_success(bool success);
    6157  bool get_anticipated_reservation_success() const;
     58
     59  void set_predecessor_rsn(const rsn &pred_rsn);
     60  const rsn &get_predecessor_rsn() const;
     61
     62  void set_qspec_anticipated_reservation(qspec_object *qspec_obj);
     63  qspec_object *get_qspec_anticipated_reservation() const;
    6264
    6365  /// lock mutex
     
    7173  hostaddress mn;
    7274  hostaddress ar_n;
    73   bool is_flow_sender;
    74   bool is_flow_receiver;
    7575  ntlp::mri_pathcoupled* mri_new_flow;
    7676  rii *rii_obj;
    7777  bool anticipated_reservation_successful;
     78  rsn predecessor_rsn;
     79  qspec_object *qspec_obj;
    7880
    7981  /// This mutex is used to lock the NSLP_AHO_Context
  • qos-nslp/branches/20090610-qos-nslp-aho/include/nslp_pdu.h

    r4543 r4567  
    7474        static const uint8 RESP_FLAG_BREAK                      = (1<<0);
    7575
     76        /* NOTIFY specific flags (8bit) */
     77        static const uint8 NOTIFY_FLAG_X                        = (1<<0);       // see Anticipated Handover
     78
    7679
    7780        static const uint8 specific_not_set = 0;
     
    117120        void set_req_reduced_refresh_flag();
    118121        void set_break_flag(); // XXX: should this be namespaced?
    119         void set_x_flag();
    120122
    121123        bool is_replace_flag() const;
     
    127129        bool is_req_reduced_refresh_flag() const;
    128130        bool is_break_flag() const;
    129         bool is_x_flag() const;
    130131
    131132// @{
     
    263264        bool is_response() const;
    264265        bool is_notify() const;
     266
     267        void set_x_flag();
     268        bool is_x_flag() const;
    265269}; // end class known_nslp_pdu
    266270
     
    337341inline void nslp_pdu::set_req_reduced_refresh_flag() { specific_flags |= RESV_FLAG_REQ_REDUCED_REFRESH; }
    338342inline void nslp_pdu::set_break_flag() { break_flag_set = true; }
    339 inline void nslp_pdu::set_x_flag() { specific_flags |= QUERY_FLAG_X; }
     343//inline void nslp_pdu::set_x_flag() { specific_flags |= QUERY_FLAG_X; }
    340344inline bool nslp_pdu::is_replace_flag() const { return (specific_flags & RESV_FLAG_REPLACE); }
    341345inline bool nslp_pdu::is_acknowledge_flag() const { return (generic_flags & GEN_FLAG_ACKNOWLEDGE); }
     
    346350inline bool nslp_pdu::is_req_reduced_refresh_flag() const { return (specific_flags & RESV_FLAG_REQ_REDUCED_REFRESH); }
    347351inline bool nslp_pdu::is_break_flag() const { return break_flag_set; }
    348 inline bool nslp_pdu::is_x_flag() const { return (specific_flags & QUERY_FLAG_X); }
     352//inline bool nslp_pdu::is_x_flag() const { return (is_query() ? (specific_flags & QUERY_FLAG_X) : false); }
    349353
    350354/** true if this is a RESERVE PDU. */
     
    360364inline bool known_nslp_pdu::is_notify() const { return (type == NOTIFY); }
    361365
     366
     367inline void known_nslp_pdu::set_x_flag() { if(is_query()) { specific_flags |= QUERY_FLAG_X; }
     368                                           if(is_notify()) { specific_flags |= NOTIFY_FLAG_X; } }
     369inline bool known_nslp_pdu::is_x_flag() const { return ( is_query() ? (specific_flags & QUERY_FLAG_X) : (is_notify() ? specific_flags & NOTIFY_FLAG_X : false) ); }
    362370//@}
    363371
  • qos-nslp/branches/20090610-qos-nslp-aho/src/ProcessingModule.cpp

    r4529 r4567  
    322322
    323323        ntlp::mri* r_mri = apimsg->get_mri();
     324        if(r_mri == NULL) {
     325                ERRLog(param.name, "process_gist_api_msg() - r_mri == NULL");
     326                return;
     327        }
     328
    324329        ntlp::mri_pathcoupled* rcvd_mri = dynamic_cast<ntlp::mri_pathcoupled*>(r_mri);
    325330        ntlp::nslpdata* nslp_data = apimsg->get_data();
     
    466471                                delete apimsg;
    467472                                DLog(param.name,"process_gist_api_msg() - done.");
    468                         }
     473                        } // end anticipated_handover_event || handover_event
    469474#endif
    470                 } else {
     475                } // end NetworkNotification
     476                else {
    471477                        DLog(param.name,"SID is NULL");
    472478                }
     
    475481        }
    476482
    477         if (nslp_data == NULL) {
    478 // TODO: abfrage nach ganz außen verlegen
    479 if(r_mri->get_mrm() == mri::mri_t_pathcoupled) {
    480                 DLog(param.name, "SII handle is " << sii);
    481                 DLog("ProcessingModule", "NN status is: " << apimsg->get_msgstatus());
    482                 if (apimsg_subtype == APIMsg::NetworkNotification) {
    483                         bool down = rcvd_mri->get_downstream();
    484                         statemodule.process_sii_handle(sii, down, rcvd_sid, rcvd_mri, apimsg->get_msgstatus());
     483
     484        // assertion: rcvd_sid != NULL
     485        if(r_mri->get_mrm() == mri::mri_t_pathcoupled) {
     486                if (nslp_data == NULL) {
     487                        DLog(param.name, "SII handle is " << sii);
     488                        DLog("ProcessingModule", "NN status is: " << apimsg->get_msgstatus());
     489                        if (apimsg_subtype == APIMsg::NetworkNotification) {
     490                                bool down = rcvd_mri->get_downstream();
     491                                statemodule.process_sii_handle(sii, down, rcvd_sid, rcvd_mri, apimsg->get_msgstatus());
     492                        }
    485493                }
    486 }
    487         } else {
    488                 uchar* nslp_buf = nslp_data->get_buffer();
    489                 uint32 nslp_size = nslp_data->get_size();
    490                 DLog(param.name, "Size of nslp_data is " << nslp_size);
    491                 NetMsg* netmsg= new NetMsg(nslp_size + 4);
    492                 netmsg->encode32(nslp_size);
    493                 netmsg->encode(nslp_buf, nslp_size);
    494                 netmsg->to_start();
    495 
    496                 ntlp::sessionid* my_sid = new ntlp::sessionid(*rcvd_sid);
    497      
    498 
    499                 DLog(param.name, "process_gist_api_msg() - received PDU now parsing...");
    500 
    501                 if(r_mri->get_mrm() == mri::mri_t_pathcoupled) {
    502                         // PC-MRI
     494                else {
     495                        uchar* nslp_buf = nslp_data->get_buffer();
     496                        uint32 nslp_size = nslp_data->get_size();
     497                        DLog(param.name, "Size of nslp_data is " << nslp_size);
     498
     499                        NetMsg* netmsg= new NetMsg(nslp_size + 4);
     500                        netmsg->encode32(nslp_size);
     501                        netmsg->encode(nslp_buf, nslp_size);
     502                        netmsg->to_start();
     503       
     504                        ntlp::sessionid* my_sid = new ntlp::sessionid(*rcvd_sid);
     505             
     506       
     507                        DLog(param.name, "process_gist_api_msg() - received PDU now parsing...");
     508       
    503509                        bool down = rcvd_mri->get_downstream();
    504510
     
    551557                        } // end switch nslperror
    552558
    553                 }
    554                 else if(r_mri->get_mrm() == mri::mri_t_explicitsigtarget) {
    555                         // EST_MRI
     559                        // NetMsg is no longer needed
     560                        if (netmsg) {
     561                                delete netmsg;
     562                        }
     563       
     564                        // because pointers are cleared, objects peer and netmsg
     565                        // are not deleted by calling tpmsg destructor now
     566                        delete apimsg;
     567                        DLog(param.name,"process_gist_api_msg() - done.");
     568                } // end if nslp_data in APIMsg existing
     569        }
     570        else if(r_mri->get_mrm() == mri::mri_t_explicitsigtarget) {
     571                if (nslp_data != NULL) {
     572                        uchar* nslp_buf = nslp_data->get_buffer();
     573                        uint32 nslp_size = nslp_data->get_size();
     574                        DLog(param.name, "Size of nslp_data is " << nslp_size);
     575
     576                        NetMsg* netmsg= new NetMsg(nslp_size + 4);
     577                        netmsg->encode32(nslp_size);
     578                        netmsg->encode(nslp_buf, nslp_size);
     579                        netmsg->to_start();
     580       
     581                        ntlp::sessionid* my_sid = new ntlp::sessionid(*rcvd_sid);
     582             
     583       
     584                        DLog(param.name, "process_gist_api_msg() - received PDU now parsing...");
     585       
     586
    556587                        ntlp::mri_explicitsigtarget* rcvd_est_mri = dynamic_cast<ntlp::mri_explicitsigtarget*>(r_mri);
    557588                        if(rcvd_est_mri != NULL) {
    558                                 statemodule.process_tp_recv_est_msg(*netmsg, result_pdu, my_sid, rcvd_est_mri);
    559                                 // TODO: error checking
     589                                statemodule.process_tp_recv_est_msg(*netmsg, my_sid, rcvd_est_mri);
    560590                        }
    561591                        else {
    562592                                ERRLog(param.name, "Cannot cast MRI of type ntlp::mri to ntlp::mri_explicitsigtarget");
    563593                        }
    564                 }
    565                 else {
    566                         ERRLog(param.name, "Received message with unknown MRI - MRI-ID: " << r_mri->get_mrm());
    567                 }
    568      
    569                 // NetMsg is no longer needed
    570                 if (netmsg)
    571                         delete netmsg;
    572 
    573                 // because pointers are cleared, objects peer and netmsg
    574                 // are not deleted by calling tpmsg destructor now
    575                 delete apimsg;
    576                 DLog(param.name,"process_gist_api_msg() - done.");
    577         } // end if nslp_data in APIMsg existing
     594             
     595                        // NetMsg is no longer needed
     596                        if (netmsg) {
     597                                delete netmsg;
     598                        }
     599       
     600                        // because pointers are cleared, objects peer and netmsg
     601                        // are not deleted by calling tpmsg destructor now
     602                        delete apimsg;
     603                        DLog(param.name,"process_gist_api_msg() - done.");
     604                } // end if nslp_data in APIMsg existing
     605        }
     606        else {
     607                ERRLog(param.name, "Received message with unknown MRI - MRI-ID: " << r_mri->get_mrm());
     608        }
    578609} // end process_api_msg
    579610
     
    11661197                        msg->send_to(message::qaddr_coordination);
    11671198                }
    1168 
    1169                 // TODO: Logging if memory allocation (new) failed
     1199                else {
     1200                        ERRLog(param.name, "state_manager::SendMessage() memory allocation failed for NetMsg");
     1201                }
    11701202        }
    11711203
  • qos-nslp/branches/20090610-qos-nslp-aho/src/QoS_StateModule.cpp

    r4559 r4567  
    260260}
    261261
    262 /** process/parse received incoming EST-MRM message from network.
    263 * This method parses the netmsg and returns the parsed PDU
    264 * in respdu.
     262/** process / parse received incoming EST-MRM message from network.
    265263* @param netmsg Incoming Network message (byte buffer).
    266 * @retval resultpdu Result PDU (or errormsg case of error).
    267264* @param sid the session id the current message belongs to.
    268265* @param rcvd_mri the EST-MRI of the current session.
    269266*/
    270 state_manager::error_t
    271 state_manager::process_tp_recv_est_msg(NetMsg& netmsg, known_nslp_pdu*& resultpdu, const ntlp::sessionid* sid,
    272                                   const ntlp::mri_explicitsigtarget* rcvd_mri)
    273 {
    274         // initialize result variables
    275         resultpdu = NULL;
    276 
     267void state_manager::process_tp_recv_est_msg(NetMsg& netmsg, const ntlp::sessionid* sid, const ntlp::mri_explicitsigtarget* rcvd_mri) {
    277268        // parse NetMsg
    278269        IEErrorList errorlist;
     
    288279        assert(pdu != NULL);
    289280        assert(known_pdu != NULL);
     281
     282        assert(rcvd_mri != NULL);
    290283
    291284        DLog(state_manager::modname, "process_tp_recv_est_msg() - " << color[blue] << "received " << known_pdu->get_name() << color[off]);
     
    318311                NSLP_AHO_Context::node_role_t role = NSLP_AHO_Context::OTHER;
    319312                hostaddress mn, ar_n;
     313                ntlp::mri_pathcoupled mri_new_flow;
    320314                NSLP_AHO_Context *aho_context = aho_contextmap.find(*sid);
    321315                if(aho_context != NULL) {
    322316                        aho_context->lock();
    323317                        role = aho_context->get_aho_node_role();
     318                        mri_new_flow = aho_context->get_mri_new_flow();
    324319                        if(role == NSLP_AHO_Context::ARN) {
    325320                                mn = aho_context->get_addr_mobile_node();
     
    382377                else if(role == NSLP_AHO_Context::MN) {
    383378                        // we are MN and go on with AHO phase 2a
    384                         // TODO
     379
     380                        mri_pathcoupled pc_mri = rcvd_mri->get_mri_pc();
     381
     382                        // prepare mri for possible RESPONSE message
     383                        mri_pathcoupled *pc_mri_send = pc_mri.copy();
     384                        pc_mri_send->invertDirection();
     385                        const hostaddress orig_sig_addr = rcvd_mri->get_dest_sig_address();
     386                        const hostaddress dest_sig_addr = rcvd_mri->get_origin_sig_address();
     387                        mri_explicitsigtarget *est_mri_send = new mri_explicitsigtarget(*pc_mri_send, orig_sig_addr, dest_sig_addr);
     388                        delete pc_mri_send;
     389
     390                        reservereq* res = dynamic_cast<reservereq *>(known_pdu);
     391                        assert(res != NULL);
     392
     393                        // only flows for which we have done an anticipated reservation
     394                        // previously, were interesting for us
     395                        if(pc_mri == mri_new_flow) {
     396                                uint32 rcvd_pred_rsn, saved_pred_rsn;
     397                                rsn *rcvd_rsn = res->get_rsn();
     398                                rii* rii_obj = res->get_rii();
     399
     400                                if(rcvd_rsn == NULL) {
     401                                        // Error can only be send if RII object present
     402                                        if(rii_obj != NULL) {
     403                                                send_response_with_rii(rii_obj, sid, est_mri_send, false,
     404                                                                info_spec::protocol, info_spec::MandatoryObjectMissing);
     405                                        }
     406                                        return;
     407                                }
     408                                rcvd_rsn->get(rcvd_pred_rsn);
     409
     410                                // Note that aho_context is surly != NULL, even though not checked here!
     411                                // See assignment of variable role.
     412                                aho_context->lock();
     413                                aho_context->get_predecessor_rsn().get(saved_pred_rsn);
     414                                aho_context->unlock();
     415
     416                                if(saved_pred_rsn == 0) {
     417                                        // this is the first received RESERVE-AHO message for the current
     418                                        // flow, save RSN of predecessor node in NSLP_AHO_Context.
     419                                        aho_context->lock();
     420                                        aho_context->set_predecessor_rsn(*rcvd_rsn);
     421                                        aho_context->unlock();
     422
     423                                        saved_pred_rsn = rcvd_pred_rsn;
     424                                }
     425
     426                                // check RSN
     427                                if(rcvd_pred_rsn == saved_pred_rsn) {
     428                                        // TODO refresh --> update lifetime of aho_context
     429                                }
     430                                else if(rcvd_pred_rsn > saved_pred_rsn) {
     431                                        qspec_object *qspec_obj = res->get_qspec();
     432                                        if(qspec_obj != NULL) {
     433                                                // TODO update lifetime of aho_context
     434                                       
     435                                                aho_context->lock();
     436                                                // update saved_pred_rsn
     437                                                aho_context->set_predecessor_rsn(*rcvd_rsn);
     438
     439                                                // TODO Should here processing of QSPEC take place?
     440                                                // I think no, since reservation isn't yet active.
     441                                                aho_context->set_qspec_anticipated_reservation(qspec_obj);
     442                                                aho_context->set_anticipated_reservation_success(true);
     443                                                aho_context->unlock();
     444                                        }
     445                                        else {
     446                                                // Send RESPONSE with RSN because this message must not be forwarded futher as one hop.
     447                                                send_response_with_rsn(rcvd_rsn, sid, est_mri_send, false,
     448                                                                info_spec::transient, info_spec::FullQSPECrequired);
     449                                        }
     450
     451                                        rii* rii_obj = res->get_rii();
     452                                        if(rii_obj != NULL) {
     453                                                send_response_with_rii(rii_obj, sid, est_mri_send, false,
     454                                                                info_spec::success, info_spec::ReservationSuccessful);
     455                                        }
     456                                        else {
     457                                                send_response_with_rsn(rcvd_rsn, sid, est_mri_send, false,
     458                                                                info_spec::success, info_spec::ReservationSuccessful);
     459                                        }
     460                                }
     461                        }
     462                        else {
     463                                ILog(state_manager::modname, "I am MN and received a RESERVE-AHO message, with an unexpected Flow ID!");
     464                                return;
     465                        }
    385466                }
    386467                else {
    387                         //
    388468                        ILog(state_manager::modname, "Received RESERVE-AHO, but don't know what to do because I'm neither MN nor ARN!");
    389                         return error_nothing_to_do;
    390                 }
    391 
    392 
    393                 return error_nothing_to_do;
     469                        return;
     470                }
     471
     472
     473                return;
    394474        }
    395475
     
    423503                                        if((*context_rii) != (*resp_rii)) {
    424504                                                ILog(state_manager::modname, "Received RESPONSE-AHO message, but RII object doesn't match.");
    425                                                 return error_nothing_to_do;
     505                                                return;
    426506                                        }
    427507
     
    431511                                                info_spec::errorcode_t err_code = (info_spec::errorcode_t) err_obj->get_errorcode();
    432512
     513                                                // retrieve commited QSPEC if available
     514                                                qspec_object *qspec_obj = resp->get_qspec();
     515
    433516                                                if((err_class == info_spec::success) &&
    434517                                                   ((err_code == info_spec::ReservationSuccessful) || (err_code == info_spec::RefreshSuccessful))) {
    435                                                         if(aho_context != NULL) {
    436                                                                 aho_context->lock();
    437                                                                 aho_context->set_anticipated_reservation_success(true);
    438                                                                 aho_context->unlock();
     518                                                        // Note that aho_context is surly != NULL, even though not checked here!
     519                                                        // See assignment of variable role.
     520                                                        aho_context->lock();
     521                                                        // update QSPEC in NSLP_AHO_Context
     522                                                        if(qspec_obj != NULL) {
     523                                                                aho_context->set_qspec_anticipated_reservation(qspec_obj);
    439524                                                        }
     525                                                        aho_context->set_anticipated_reservation_success(true);
     526                                                        aho_context->unlock();
    440527                                                }
    441528                                        }
    442529                                        else {
    443530                                                ILog(state_manager::modname, "Missing mandatory INFO_SPEC object in RESPONSE-AHO message.");
    444                                                 return error_nothing_to_do;
     531                                                return;
    445532                                        }
    446533                                }
    447534                                else {
    448535                                        ILog(state_manager::modname, "Received RESPONSE-AHO message w/o RII object, but RII was expected.");
    449                                         return error_nothing_to_do;
     536                                        return;
    450537                                }
    451538                        }
    452539                }
    453 
    454                 if(role == NSLP_AHO_Context::ARN) {
    455                         //
    456                 }
    457 
    458                 return error_nothing_to_do;
     540                else if(role == NSLP_AHO_Context::ARN) {
     541                        mri_pathcoupled pc_mri = rcvd_mri->get_mri_pc();
     542                        bool down = pc_mri.get_downstream();
     543
     544                        // TODO
     545                        // activate processing of this message on ARN, just as
     546                        // we had received this message (incoming processing)
     547                        //known_pdu->set_incoming_processing();
     548
     549                        // send RESPONSE message with PC-MRM downstream / upstream
     550                        SignalingMsg* sigmsg = new SignalingMsg();
     551                        sigmsg->set_msg(known_pdu);
     552                        sigmsg->set_sid(*sid);
     553                        sigmsg->set_sig_mri(&pc_mri);
     554                        sigmsg->set_downstream(down);
     555                        sigmsg->send_or_delete();
     556                }
     557                else {
     558                        ILog(state_manager::modname, "Received RESPONSE-AHO, but don't know what to do because I'm neither MN nor ARN!");
     559                        return;
     560                }
     561
     562                return;
    459563        }
    460564
     
    526630                }
    527631
    528                 return error_nothing_to_do;
     632                return;
    529633        }
    530634
     
    542646                if(err_class != info_spec::information) {
    543647                        ILog(state_manager::modname, "Received NOTIFY message with error class " << err_obj->get_errorclass_string() << ", ending here!");
    544                         return error_nothing_to_do;
     648                        return;
    545649                }
    546650
     
    554658                        // Reserve-Init-Flag
    555659                        query->set_reserve_init_flag();
     660                        if(notify->is_x_flag()) {
     661                                query->set_x_flag();
     662                        }
     663                        else {
     664                                query->set_x_flag();
     665                        }
    556666       
    557667                        known_nslp_pdu *query_pdu = dynamic_cast<known_nslp_pdu*>(query);
     
    579689                        if(context == NULL) {
    580690                                ERRLog(state_manager::modname, "Unable to retrieve context for Session with SID [" << sid->to_string() << "], ending here!");
    581                                 return error_nothing_to_do;
     691                                return;
    582692                        }
    583693
     
    589699
    590700                        create_reserve_message_from_context(context, reserve, rii_obj);
    591                         reserve->set_proxy_flag();
     701                        if(notify->is_x_flag()) {
     702                                reserve->set_replace_flag();
     703                        }
     704                        else {
     705                                reserve->set_proxy_flag();
     706                        }
    592707
    593708                        known_nslp_pdu *reserve_pdu = dynamic_cast<known_nslp_pdu*>(reserve);
     
    610725                        ILog(state_manager::modname, "Received NOTIFY message with error class " << err_obj->get_errorclass_string()
    611726                                        << ", but unexpected error code, ending here!");
    612                         return error_nothing_to_do;
    613                 }
    614 
    615                 return error_nothing_to_do;
    616         }
    617 
    618         return state_manager::error_nothing_to_do;
     727                        return;
     728                }
     729
     730                return;
     731        }
    619732}
    620733
     
    768881  error_t nslpres = error_ok;
    769882
    770   /*
    771   error_t ret_nslpres = error_ok;
    772   netbuffer = NULL;
    773   bool updated = false;
    774   bool processing = false;
    775   bool is_tear = false;
    776         Flowstatus *fs = NULL;
    777 
    778   NSLP_Context* context = rcvd_sid ? contextmap.find(*rcvd_sid) : 0;
    779         */
    780883
    781884  if(rcvd_sid) {
     
    786889        }
    787890
    788         // check if MRI state is valid
     891  // check if MRI state is valid
    789892  if(!(*rcvd_mri)->check()) {
    790893    ERRLog(state_manager::modname, "Invalid EST-MRI state!");
     
    793896  }
    794897
    795         /*
    796   hostaddress orig_a, source_a, dest_a;
    797   source_a = (*rcvd_mri)->get_sourceaddress();
    798   dest_a = (*rcvd_mri)->get_destaddress();
    799         */
    800898
    801899  if(pdu.is_notify()) {
     
    809907  if(pdu.is_reserve()) {
    810908    ILog(state_manager::modname, color[magenta] << "Outgoing RESERVE message!" << color[off]);
    811 //    reservereq* reserve = dynamic_cast<reservereq*>(&pdu);
    812 //    processing = reserve->get_originator();
    813909  }
    814 
    815         /*
    816   if ((!context) &&  pdu.is_tear_flag()) {
    817     is_tear = true;
    818     ERRLog(state_manager::modname, "TEAR FLAG is set to TRUE!");
    819   }
    820 
    821   if ((processing) && (!is_tear)) {
    822     if (pdu.is_reserve()) {
    823       updated = find_and_update_context(&pdu, nslpres, down, rcvd_sid, *rcvd_mri, fs);
    824       if (!updated)
    825         ret_nslpres = create_new_context(pdu, nslpres, down, rcvd_sid, *rcvd_mri, fs);
    826     }
    827     if ((ret_nslpres!=error_ok) &&
    828         (ret_nslpres != error_ok_send_response) &&
    829         (ret_nslpres != error_ok_forward)) {
    830       if (netbuffer)
    831         delete netbuffer;
    832       netbuffer = NULL;
    833       return ret_nslpres;
    834     } // end if error
    835   }
    836         */
    837910
    838911  if(pdu.is_query()) {
    839912    ILog(state_manager::modname, color[magenta] << "Outgoing QUERY message!" << color[off]);
    840                 /*
    841     ret_nslpres = error_ok;
    842     querymsg* query = dynamic_cast<querymsg*>(&pdu);
    843                
    844     bool continue_it = true;
    845     bool i_am_originator = query->get_originator();
    846     if (i_am_originator) {
    847       rii* check_rii = query->get_rii();
    848       if (check_rii) {
    849         if ( ( down && is_last_signaling_hop(*rcvd_mri) )  || ( down == false ) ) {
    850           // this situation should not happen, QNR MAY send QUERY msgs ONLY w/o RII
    851           ret_nslpres = error_nothing_to_do;
    852           ERRLog(state_manager::modname, "QNR attempting to send a QUERY msg with RII or QUERY upstream w/ RII, deleting it!");
    853           continue_it = false;
    854         }
    855       }
    856       else
    857         { // no RII object present
    858           if ( ( down || ((!down) && is_last_signaling_hop(*rcvd_mri) ) )
    859                && query->is_reserve_init_flag() == false ) {
    860             // this situation should not happen, QNI MAY send QUERY msgs ONLY with RII
    861             ret_nslpres = error_nothing_to_do;
    862             ERRLog(state_manager::modname, "QNI attempting to send a QUERY msg w/o RII or R-Flag, delete it!");
    863             continue_it = false;
    864           }
    865         } // end else
    866     } // end if I am an originator of this QUERY
    867                
    868     if (i_am_originator && continue_it)
    869       ret_nslpres = process_outgoing_query(pdu, down, rcvd_sid, *rcvd_mri, fs);
    870 
    871     if (ret_nslpres!=error_ok) {
    872       if (netbuffer)
    873         delete netbuffer;
    874       netbuffer = NULL;
    875       return ret_nslpres;
    876     } // end if error
    877                 */
    878913  }
    879914
     
    9671002            if (found_context_rii->get_own()) {
    9681003              ERRLog(state_manager::modname, "Another node has sent a message with the duplicated RII!!!");
    969               send_response_with_rii(r, type == NSLP_Context::QNR, !down, rcvd_sid, rcvd_mri,
    970                                     info_spec::transient, info_spec::RIIconflict);
     1004//            send_response_with_rii(r, !down, rcvd_sid, rcvd_mri, info_spec::transient, info_spec::RIIconflict);
     1005              send_response_with_rii(r, rcvd_sid, rcvd_mri, !down, info_spec::transient, info_spec::RIIconflict);
    9711006              return;
    9721007            }
     
    13761411      }
    13771412//
    1378 //XXX: Why should there be any saved BOUND_SESSIONID, if we are present to create one??
     1413//XXX: Why should there be any saved BOUND_SESSIONID, if we are present to create a new context??
    13791414//
    13801415      else {
     
    16171652                          forward_reserve(reservemsg, local_context, down, rcvd_mri);
    16181653                  nslpres = error_nothing_to_do;
     1654                  // XXX: maybe delete local_context forgotten??
    16191655                  local_context = NULL;
    16201656                  return nslpres;
     
    16771713                  nslpres = error_rsn_missing;
    16781714                  if (rcvd_rii)
    1679                           send_response_with_rii(rcvd_rii, type == NSLP_Context::QNR, !down, local_sid, rcvd_mri,
    1680                                           info_spec::protocol, info_spec::MandatoryObjectMissing);
     1715//                        send_response_with_rii(rcvd_rii, !down, local_sid, rcvd_mri, info_spec::protocol, info_spec::MandatoryObjectMissing);
     1716                          send_response_with_rii(rcvd_rii, local_sid, rcvd_mri, !down, info_spec::protocol, info_spec::MandatoryObjectMissing);
    16811717                  // cannot forward RESERVE msg w/o RSN, delete msg
    16821718                  return nslpres;
     
    16951731                          if (type != NSLP_Context::QNI) {
    16961732                                  if (rcvd_rii) {
    1697                                           send_response_with_rii(rcvd_rii, false, !down, local_sid, rcvd_mri,
     1733//                                        send_response_with_rii(rcvd_rii, !down, local_sid, rcvd_mri,
     1734                                          send_response_with_rii(rcvd_rii, local_sid, rcvd_mri, !down,
    16981735                                                          info_spec::transient,
    16991736#ifdef QOS_NSLP_13
     
    17051742                                  }
    17061743                                  else {
    1707                                           send_response_with_rsn(rsn_up, !down, local_sid, rcvd_mri,
     1744//                                        send_response_with_rsn(rsn_up, !down, local_sid, rcvd_mri,
     1745                                          send_response_with_rsn(rsn_up, local_sid, rcvd_mri, !down,
    17081746                                                          info_spec::transient,
    17091747#ifdef QOS_NSLP_13
     
    17261764          else {
    17271765                  ILog(state_manager::modname, "NO QSPEC!");
    1728                   send_response_with_rsn(rsn_up, !down, local_sid, rcvd_mri, info_spec::transient, info_spec::FullQSPECrequired);
     1766//                send_response_with_rsn(rsn_up, !down, local_sid, rcvd_mri, info_spec::transient, info_spec::FullQSPECrequired);
     1767                  send_response_with_rsn(rsn_up, local_sid, rcvd_mri, !down, info_spec::transient, info_spec::FullQSPECrequired);
    17291768          }
    17301769          local_context->lock();
     
    17521791#endif
    17531792                          }
    1754                           send_response_with_rii(rcvd_rii, type == NSLP_Context::QNR, !down, local_sid, rcvd_mri, info_spec::success, er_code);
     1793//                        send_response_with_rii(rcvd_rii, !down, local_sid, rcvd_mri, info_spec::success, er_code);
     1794                          send_response_with_rii(rcvd_rii, local_sid, rcvd_mri, !down, info_spec::success, er_code);
    17551795                          if (reservemsg->is_scoping_flag()) {
    17561796                                  send = false;
     
    17691809                          if ((reservemsg->is_acknowledge_flag()) || (reservemsg->is_scoping_flag())) {
    17701810                                  Log(INFO_LOG,LOG_NORMAL,state_manager::modname, "QNE or QNR, A-Flag set, send RESPONSE");
    1771                                   send_response_with_rsn(rsn_up, !down, local_sid, rcvd_mri,
     1811//                                send_response_with_rsn(rsn_up, !down, local_sid, rcvd_mri,
     1812                                  send_response_with_rsn(rsn_up, local_sid, rcvd_mri, !down,
    17721813                                                  info_spec::success,
    17731814#ifdef QOS_NSLP_13
     
    18461887
    18471888                  // insert current state into hashmap with states
    1848                   contextmap.insert(*local_sid,local_context);
     1889                  contextmap.insert(*local_sid, local_context);
    18491890
    18501891                  // if the node is QNI or QNE and the SCOPING flag is not set -> start timer for refresh RESERVE
     
    20182059/** This function sends a RESPONSE message triggered by RII.
    20192060 * @param rcvd_rii this RII object is from the received message and will be copied into RESPONSE message.
    2020  * @param is_qnr set to TRUE if the current node is QNR.
    20212061 * @param down set to TRUE, if the direction is downstream, otherwise set to FALSE.
    20222062 * @param sid the session id the current message belongs to.
     
    20252065 * @param e_code this is the error code for the INFO_SPEC object in the RESPONSE message.
    20262066 */
    2027   void state_manager::send_response_with_rii(rii* rcvd_rii, bool is_qnr, bool down, const ntlp::sessionid* sid, const ntlp::mri_pathcoupled* rcvd_mri,
     2067/*
     2068  void state_manager::send_response_with_rii(rii* rcvd_rii, bool down, const ntlp::sessionid* sid, const ntlp::mri_pathcoupled* rcvd_mri,
    20282069                  info_spec::errorclass_t e_class, info_spec::errorcode_t e_code)
    20292070  {
     
    20602101          ILog(state_manager::modname, "END send_response_ok_with_rii()");
    20612102  }
     2103*/
     2104
     2105
     2106/**
     2107 * This function sends a RESPONSE message triggered by RII.
     2108 * @param rii the RII object from the received message that will be copied into the RESPONSE message.
     2109 * @param sid the session id the current message belongs to.
     2110 * @param mri the MRI used to send the RESPONSE message.
     2111 * @param down set to TRUE, if the direction is downstream, otherwise set to FALSE.
     2112 * @param err_class this is the error class for the INFO_SPEC object in the RESPONSE message.
     2113 * @param err_code this is the error code for the INFO_SPEC object in the RESPONSE message.
     2114 */
     2115// TODO: maybe remove parameter "down"
     2116void state_manager::send_response_with_rii(rii* rii, const ntlp::sessionid* sid, const ntlp::mri* mri, bool down,
     2117                info_spec::errorclass_t err_class, info_spec::errorcode_t err_code)
     2118{
     2119        ILog(state_manager::modname, "send_response_with_rii()");
     2120
     2121        known_nslp_pdu *pdu = NULL;
     2122        responsemsg *resp = new responsemsg();
     2123        resp->set_rii(rii->copy());
     2124
     2125        if(mri == NULL) {
     2126                ERRLog(state_manager::modname, "send_response_with_rii() - mri == NULL");
     2127                return;
     2128        }
     2129
     2130        if(mri->get_mrm() == mri::mri_t_pathcoupled) {
     2131                const ntlp::mri_pathcoupled* pc_mri = dynamic_cast<const ntlp::mri_pathcoupled *>(mri);
     2132                assert(pc_mri != NULL);
     2133
     2134                // For simplicity, extract v4-mapped address for v4 case
     2135                in6_addr addr6;
     2136                netaddress *na = addresses->get_first(AddressList::ConfiguredAddr_P, pc_mri->get_destaddress().is_ipv4());
     2137                na->get_ip(addr6);
     2138                delete(na);
     2139
     2140                info_spec* info_spec_obj = new info_spec(&addr6, err_class, err_code, 0);
     2141                resp->set_errorobject(info_spec_obj);
     2142
     2143                pdu = dynamic_cast<known_nslp_pdu*>(resp);
     2144                assert(pdu != NULL);
     2145
     2146                SignalingMsg* sigmsg = new SignalingMsg;
     2147                sigmsg->set_msg(pdu);
     2148                sigmsg->set_sig_mri(pc_mri);
     2149                // maybe pc_mri->get_downstream() would be also adequate?
     2150                sigmsg->set_downstream(down);
     2151                sigmsg->set_sid(*sid);
     2152                sigmsg->send_or_delete();
     2153        }
     2154        else if(mri->get_mrm() == mri::mri_t_explicitsigtarget) {
     2155                const ntlp::mri_explicitsigtarget *est_mri = dynamic_cast<const ntlp::mri_explicitsigtarget *>(mri);
     2156                assert(est_mri != NULL);
     2157
     2158                info_spec* info_spec_obj = new info_spec(NULL, err_class, err_code, 0);
     2159                resp->set_errorobject(info_spec_obj);
     2160               
     2161                pdu = dynamic_cast<known_nslp_pdu*>(resp);
     2162                assert(pdu != NULL);
     2163               
     2164                ExplicitSignalingMsg* sigmsg = new ExplicitSignalingMsg();
     2165                sigmsg->set_pdu(pdu);
     2166                sigmsg->set_sig_mri(est_mri);
     2167                sigmsg->set_sid(*sid);
     2168                sigmsg->send_or_delete();
     2169        }
     2170        else {
     2171                ERRLog(state_manager::modname, "send_response_with_rii() - Unknown MRI with MRI-ID: " << mri->get_mrm());
     2172        }
     2173
     2174        ILog(state_manager::modname, "END send_response_with_rii()");
     2175}
     2176
    20622177
    20632178/** This function sends a RESPONSE message with RSN.
     
    20692184 * @param e_code this is the error code for the INFO_SPEC object in the RESPONSE message.
    20702185 */
     2186/*
    20712187  void state_manager::send_response_with_rsn(rsn* rcvd_rsn, bool down, const ntlp::sessionid* sid, const ntlp::mri_pathcoupled* rcvd_mri,
    20722188                  info_spec::errorclass_t e_class, info_spec::errorcode_t e_code)
     
    21002216          ILog(state_manager::modname, "END send_response_with_rsn()");
    21012217  }
     2218*/
     2219
     2220
     2221/** This function sends a RESPONSE message with RSN.
     2222 * @param rsn the RSN object from the received message that will be copied into the RESPONSE message.
     2223 * @param sid the session id the current message belongs to.
     2224 * @param mri the MRI used to send the RESPONSE message.
     2225 * @param down set to TRUE, if the direction is downstream, otherwise set to FALSE.
     2226 * @param err_class this is the error class for the INFO_SPEC object in the RESPONSE message.
     2227 * @param err_code this is the error code for the INFO_SPEC object in the RESPONSE message.
     2228 */
     2229// TODO: maybe remove parameter "down"
     2230void state_manager::send_response_with_rsn(rsn* rsn, const ntlp::sessionid* sid, const ntlp::mri* mri, bool down,
     2231                info_spec::errorclass_t err_class, info_spec::errorcode_t err_code)
     2232{
     2233        ILog(state_manager::modname, "send_response_with_rsn()");
     2234
     2235        known_nslp_pdu *pdu = NULL;
     2236        responsemsg *resp = new responsemsg();
     2237        resp->set_rsn(rsn->copy());
     2238
     2239        if(mri == NULL) {
     2240                ERRLog(state_manager::modname, "send_response_with_rsn() - mri == NULL");
     2241                return;
     2242        }
     2243
     2244        if(mri->get_mrm() == mri::mri_t_pathcoupled) {
     2245                const ntlp::mri_pathcoupled* pc_mri = dynamic_cast<const ntlp::mri_pathcoupled *>(mri);
     2246                assert(pc_mri != NULL);
     2247
     2248                // For simplicity, extract v4-mapped address for v4 case
     2249                in6_addr addr6;
     2250                netaddress *na = addresses->get_first(AddressList::ConfiguredAddr_P, pc_mri->get_destaddress().is_ipv4());
     2251                na->get_ip(addr6);
     2252                delete(na);
     2253
     2254                info_spec* info_spec_obj = new info_spec(&addr6, err_class, err_code, 0);
     2255                resp->set_errorobject(info_spec_obj);
     2256
     2257                pdu = dynamic_cast<known_nslp_pdu*>(resp);
     2258                assert(pdu != NULL);
     2259
     2260                SignalingMsg* sigmsg = new SignalingMsg;
     2261                sigmsg->set_msg(pdu);
     2262                sigmsg->set_sig_mri(pc_mri);
     2263                // maybe pc_mri->get_downstream() would be also adequate?
     2264                sigmsg->set_downstream(down);
     2265                sigmsg->set_sid(*sid);
     2266                sigmsg->send_or_delete();
     2267        }
     2268        else if(mri->get_mrm() == mri::mri_t_explicitsigtarget) {
     2269                const ntlp::mri_explicitsigtarget *est_mri = dynamic_cast<const ntlp::mri_explicitsigtarget *>(mri);
     2270                assert(est_mri != NULL);
     2271
     2272                info_spec* info_spec_obj = new info_spec(NULL, err_class, err_code, 0);
     2273                resp->set_errorobject(info_spec_obj);
     2274               
     2275                pdu = dynamic_cast<known_nslp_pdu*>(resp);
     2276                assert(pdu != NULL);
     2277               
     2278                ExplicitSignalingMsg* sigmsg = new ExplicitSignalingMsg();
     2279                sigmsg->set_pdu(pdu);
     2280                sigmsg->set_sig_mri(est_mri);
     2281                sigmsg->set_sid(*sid);
     2282                sigmsg->send_or_delete();
     2283        }
     2284        else {
     2285                ERRLog(state_manager::modname, "send_response_with_rsn() - Unknown MRI with MRI-ID: " << mri->get_mrm());
     2286        }
     2287
     2288        ILog(state_manager::modname, "END send_response_with_rsn()");
     2289}
     2290
    21022291
    21032292/** This function forwards the received QUERY message.
     
    23412530            if (!rcvd_rii->get_own()) {
    23422531              Log(ERROR_LOG,LOG_NORMAL,state_manager::modname, "Another node has sent a message with the duplicated RII!!!");
    2343               send_response_with_rii(rcvd_rii, is_qnr, !down, local_sid, rcvd_mri,
    2344                                     info_spec::transient, info_spec::RIIconflict);
     2532//            send_response_with_rii(rcvd_rii, !down, local_sid, rcvd_mri, info_spec::transient, info_spec::RIIconflict);
     2533              send_response_with_rii(rcvd_rii, local_sid, rcvd_mri, !down, info_spec::transient, info_spec::RIIconflict);
    23452534              check_it_again = false;
    23462535              nslpres = error_nothing_to_do;
     
    27592948            // no QSPEC. Send RESPONSE with RSN because this message must not be forwarded futher as one hop.
    27602949            Log(ERROR_LOG,LOG_NORMAL,state_manager::modname, "no qspec found!");
    2761             send_response_with_rsn(send_rsn, false, local_sid, rcvd_mri, info_spec::transient, info_spec::FullQSPECrequired);
     2950//          send_response_with_rsn(send_rsn, false, local_sid, rcvd_mri, info_spec::transient, info_spec::FullQSPECrequired);
     2951            send_response_with_rsn(send_rsn, local_sid, rcvd_mri, false, info_spec::transient, info_spec::FullQSPECrequired);
    27622952        }
    27632953    }  // end if received rsn > saved rsn
     
    29243114              if (type != NSLP_Context::QNI) {
    29253115                if (rcvd_rii) {
    2926                   send_response_with_rii(rcvd_rii, false, !down, rcvd_sid, rcvd_mri,
     3116//                send_response_with_rii(rcvd_rii, !down, rcvd_sid, rcvd_mri,
     3117                  send_response_with_rii(rcvd_rii, rcvd_sid, rcvd_mri, !down,
    29273118                                         info_spec::transient,
    29283119#ifdef QOS_NSLP_13
     
    29343125                }
    29353126                else {
    2936                   send_response_with_rsn(send_rsn, false, rcvd_sid, rcvd_mri,
     3127//                send_response_with_rsn(send_rsn, false, rcvd_sid, rcvd_mri,
     3128                  send_response_with_rsn(send_rsn, rcvd_sid, rcvd_mri, false,
    29373129                                         info_spec::transient,
    29383130#ifdef QOS_NSLP_13
     
    29593151            nslpres = error_rsn_missing;
    29603152            if (rcvd_rii) {
    2961               send_response_with_rii(rcvd_rii, type == NSLP_Context::QNR, !down, rcvd_sid, rcvd_mri,
    2962                                     info_spec::protocol, info_spec::MandatoryObjectMissing);
     3153//            send_response_with_rii(rcvd_rii, !down, rcvd_sid, rcvd_mri, info_spec::protocol, info_spec::MandatoryObjectMissing);
     3154              send_response_with_rii(rcvd_rii, rcvd_sid, rcvd_mri, !down, info_spec::protocol, info_spec::MandatoryObjectMissing);
    29633155            }
    29643156            // cannot forward RESERVE msg w/o RSN, delete msg
     
    29763168            if (nslpres == error_ok_send_response) {
    29773169              if (type == NSLP_Context::QNR) {
    2978                 send_response_with_rii(rcvd_rii, type == NSLP_Context::QNR, !down, rcvd_sid, rcvd_mri,
     3170//              send_response_with_rii(rcvd_rii, !down, rcvd_sid, rcvd_mri,
     3171                send_response_with_rii(rcvd_rii, rcvd_sid, rcvd_mri, !down,
    29793172                                       info_spec::success,
    29803173#ifdef QOS_NSLP_13
     
    29913184                        ; //TODO: Not quite sure yet!
    29923185#else
    2993                   send_response_with_rii(rcvd_rii, false, !down, rcvd_sid, rcvd_mri,
     3186//                send_response_with_rii(rcvd_rii, !down, rcvd_sid, rcvd_mri,
     3187                  send_response_with_rii(rcvd_rii, rcvd_sid, rcvd_mri, !down,
    29943188                                         info_spec::success, info_spec::StateInstallationOK);
    29953189#endif
     
    30073201            if (type != NSLP_Context::QNI) {
    30083202                if (reservemsg->is_acknowledge_flag()) {
    3009                  send_response_with_rsn(send_rsn, false, rcvd_sid, rcvd_mri, info_spec::success,
     3203//               send_response_with_rsn(send_rsn, false, rcvd_sid, rcvd_mri, info_spec::success,
     3204                 send_response_with_rsn(send_rsn, rcvd_sid, rcvd_mri, false, info_spec::success,
    30103205#ifdef QOS_NSLP_13
    30113206                     info_spec::Acknowledgement
     
    44834678        known_nslp_pdu *pdu;
    44844679        rii *rii_obj;
    4485 
    4486         bool is_flow_sender=false;
    4487         bool is_flow_receiver=false;
    4488         bool is_flow_sender2=false;
    4489         bool is_flow_receiver2=false;
     4680        bool is_flow_sender;
     4681        bool is_flow_receiver;
    44904682
    44914683
     
    45024694                qn_type = context->get_qn_type();
    45034695                pc_mri = context->get_mri()->copy();
    4504 
    4505                 is_flow_sender2 = context->get_is_flow_sender();
    4506                 is_flow_receiver2 = context->get_is_flow_receiver();
     4696                is_flow_sender = context->get_is_flow_sender();
     4697                is_flow_receiver = context->get_is_flow_receiver();
    45074698                context->unlock();
    45084699
    45094700                ntlp::sessionid sid(tmp_sid);
    4510                 is_flow_sender = is_flow_source(pc_mri);
    4511                 is_flow_receiver = is_flow_destination(pc_mri);
    45124701
    45134702
     
    45214710                ILog(state_manager::modname, "PC-MRI src address: " << pc_mri->get_sourceaddress());
    45224711                ILog(state_manager::modname, "PC-MRI dst address: " << pc_mri->get_destaddress());
    4523 
    4524                 ILog(state_manager::modname, "is_flow_sender: " << (is_flow_sender2 ? "true" : "false"));
    4525                 ILog(state_manager::modname, "is_flow_receiver: " << (is_flow_receiver2 ? "true" : "false"));
    45264712
    45274713
     
    45854771                // save mri of new flow
    45864772                aho_context->set_mri_new_flow(*pc_mri);
    4587                 // save is_flow_sender / is_flow_receiver
    4588                 aho_context->set_is_flow_sender(is_flow_sender);
    4589                 aho_context->set_is_flow_receiver(is_flow_receiver);
    45904773                if(qn_type == NSLP_Context::QNI) {
    45914774                        // save RII object to match RESPONSE message
     
    46374820        NSLP_Context::qn_type_t qn_type;
    46384821        ntlp::mri_pathcoupled* pc_mri = NULL;
    4639         known_nslp_pdu *pdu;
    4640 
    4641         bool is_flow_sender=false;
    4642         bool is_flow_receiver=false;
     4822        bool is_flow_sender;
     4823        bool is_flow_receiver;
    46434824
    46444825        bool hard_handover=false;
     
    46634844                qn_type = context->get_qn_type();
    46644845                pc_mri = context->get_mri()->copy();
     4846                is_flow_sender = context->get_is_flow_sender();
     4847                is_flow_receiver = context->get_is_flow_receiver();
    46654848                context->unlock();
    46664849
     
    46734856                        aho_context->lock();
    46744857                        NSLP_AHO_Context::node_role_t role = aho_context->get_aho_node_role();
    4675                         is_flow_sender = aho_context->get_is_flow_sender();
    4676                         is_flow_receiver = aho_context->get_is_flow_receiver();
    46774858                        bool anticipated_reservation_successful = aho_context->get_anticipated_reservation_success();
    46784859       
     
    47024883                                                << ") for Reservation with SID [" << sid.to_string() << "]");
    47034884       
    4704 // TODO: in eigene Methode verschieben
    4705                                 // build RESERVE or QUERY message depending
    4706                                 // on the role of the mobile node
    4707                                 if(qn_type == NSLP_Context::QNI) {
    4708                                         // create RESERVE message
    4709                                         reservereq* res = new reservereq();
    4710                
    4711                                         // generate new rii object
    4712 //                                      rii *send_rii = new rii();
    4713 //                                      send_rii->generate_new();
    4714 //                                      send_rii->set_own(true);
    4715 //                                      send_rii->set_is_reserve(true);
    4716                
    4717                                         create_reserve_message_from_context(context, res, NULL);
    4718                                         res->set_replace_flag();
    4719                                
    4720                                         pdu = dynamic_cast<known_nslp_pdu*>(res);
    4721                                 }
    4722                                 else if(qn_type == NSLP_Context::QNR) {
    4723                                         // create QUERY message
    4724                                         querymsg* query = new querymsg();
    4725                
    4726                                         create_query_message_from_context(context, query);
    4727                                         query->set_reserve_init_flag();
    4728                                         query->set_x_flag();
    4729                
    4730                                         pdu = dynamic_cast<known_nslp_pdu*>(query);
    4731                                 }
    4732                                 else {
    4733                                         ERRLog(state_manager::modname, "AHO not implemented for case where mobile node is QNE of a reservation!");
    4734                                         return;
    4735                                 }
    4736                
    4737                                 assert(pdu != NULL);
    4738        
    4739        
    4740                                 // build mri
    4741                                 if(is_flow_sender) {
    4742                                         pc_mri->set_sourceaddress(*l3_mn);
    4743                                         pc_mri->set_downstream(true);
    4744                                 }
    4745                                 else if(is_flow_receiver) {
    4746                                         pc_mri->set_destaddress(*l3_mn);
    4747                                         pc_mri->set_downstream(false);
    4748                                 }
    4749        
    4750        
    4751                                 // send message with PC-MRM
    4752                                 SignalingMsg* sigmsg = new SignalingMsg();
    4753                                 sigmsg->set_msg(pdu);
    4754                                 sigmsg->set_sid(sid);
    4755                                 sigmsg->set_sig_mri(pc_mri);
    4756                                 sigmsg->set_downstream(pc_mri->get_downstream());
    4757                                 sigmsg->send_or_delete();
    4758 // TODO: Ende in eigene Methode verschieben
     4885                                activate_or_create_new_reservation_with_phase3(context, &sid, pc_mri, qn_type, *l3_mn, is_flow_sender, is_flow_receiver);
     4886
     4887                                // delete AHO_Context
     4888                                aho_contextmap.erase(sid);
    47594889                        }
    47604890                        else {
     
    47634893                                hard_handover = true;
    47644894                        }
    4765        
    4766        
    4767                         // delete AHO_Context
    4768                         aho_contextmap.erase(sid);
    47694895                }
    47704896                else {
     
    47794905                        ILog(state_manager::modname, "Starting AHO-Phase 3 / 2a (" <<  color[magenta] << "Hard Handover" <<  color[off]
    47804906                                        << ") for Reservation with SID [" << sid.to_string() << "]");
    4781 // TODO: is_flow_sender, is_flow_receiver kann nicht verwendet werden, wenn kein context existiert!!
     4907
    47824908                        if(is_flow_sender) {
    4783                                 //
     4909                                activate_or_create_new_reservation_with_phase3(context, &sid, pc_mri, qn_type, *l3_mn, is_flow_sender, is_flow_receiver);
     4910
     4911                                // delete AHO_Context if existing
     4912                                aho_contextmap.erase(sid);
    47844913                        }
    47854914                        else if(is_flow_receiver) {
    4786                                 //TODO
     4915                                // create NOTIFY message
     4916                                notifymsg* notify = new notifymsg();
     4917                                known_nslp_pdu *notify_pdu = NULL;
     4918
     4919                                if(qn_type == NSLP_Context::QNI) {
     4920                                        info_spec* err_obj = new info_spec(NULL, info_spec::information, info_spec::InitQuery, 0);
     4921                                        notify->set_errorobject(err_obj);
     4922                                        // set X-Flag, which causes the subsequent RESERVE to have the Replace-Flag set
     4923                                        notify->set_x_flag();
     4924               
     4925                                        notify_pdu = dynamic_cast<known_nslp_pdu*>(notify);
     4926                                }
     4927                                else if(qn_type == NSLP_Context::QNR) {
     4928                                        info_spec* err_obj = new info_spec(NULL, info_spec::information, info_spec::InitReserve, 0);
     4929                                        notify->set_errorobject(err_obj);
     4930                                        // set X-Flag, which causes the subsequent RESERVE to have the Replace-Flag set
     4931                                        notify->set_x_flag();
     4932               
     4933                                        notify_pdu = dynamic_cast<known_nslp_pdu*>(notify);
     4934                                }
     4935                                else {
     4936                                        ERRLog(state_manager::modname, "AHO not implemented for case where mobile node is QNE of a reservation!");
     4937                                        return;
     4938                                }
     4939
     4940                                assert(notify_pdu != NULL);
     4941
     4942                                // build mri, note that we are the flow receiver
     4943                                pc_mri->set_destaddress(*l3_mn);
     4944                                pc_mri->set_downstream(false);
     4945       
     4946                                // send NOTIFY message with EST-MRM
     4947                                hostaddress orig_sig_addr = *l3_mn;
     4948                                hostaddress dest_sig_addr = pc_mri->get_sourceaddress();
     4949                                mri_explicitsigtarget *est_mri = new mri_explicitsigtarget(*pc_mri, orig_sig_addr, dest_sig_addr);
     4950       
     4951                                ExplicitSignalingMsg* sigmsg = new ExplicitSignalingMsg();
     4952                                sigmsg->set_pdu(notify_pdu);
     4953                                sigmsg->set_sid(sid);
     4954                                sigmsg->set_sig_mri(est_mri);
     4955                                sigmsg->send_or_delete();
    47874956                        }
    47884957                        else {
     
    47944963
    47954964        ILog(state_manager::modname, "aho_phase_3_2a() - done");
     4965}
     4966
     4967
     4968void state_manager::activate_or_create_new_reservation_with_phase3(NSLP_Context* context, const ntlp::sessionid *sid, ntlp::mri_pathcoupled* mri,
     4969        NSLP_Context::qn_type_t qn_type, const hostaddress &l3_mn, bool is_flow_sender, bool is_flow_receiver)
     4970{
     4971        known_nslp_pdu *pdu;
     4972
     4973
     4974        assert(sid != NULL);
     4975        assert(mri != NULL);
     4976
     4977        if(context != NULL) {
     4978                // build RESERVE or QUERY message depending
     4979                // on the role of the mobile node
     4980                if(qn_type == NSLP_Context::QNI) {
     4981                        // create RESERVE message
     4982                        reservereq* res = new reservereq();
     4983       
     4984                        // generate new rii object
     4985//                      rii *send_rii = new rii();
     4986//                      send_rii->generate_new();
     4987//                      send_rii->set_own(true);
     4988//                      send_rii->set_is_reserve(true);
     4989       
     4990                        create_reserve_message_from_context(context, res, NULL);
     4991                        res->set_replace_flag();
     4992               
     4993                        pdu = dynamic_cast<known_nslp_pdu*>(res);
     4994                }
     4995                else if(qn_type == NSLP_Context::QNR) {
     4996                        // create QUERY message
     4997                        querymsg* query = new querymsg();
     4998       
     4999                        create_query_message_from_context(context, query);
     5000                        query->set_reserve_init_flag();
     5001                        query->set_x_flag();
     5002       
     5003                        pdu = dynamic_cast<known_nslp_pdu*>(query);
     5004                }
     5005                else {
     5006                        ERRLog(state_manager::modname, "AHO not implemented for case where mobile node is QNE of a reservation!");
     5007                        return;
     5008                }
     5009       
     5010                assert(pdu != NULL);
     5011       
     5012       
     5013                // build mri
     5014                if(is_flow_sender) {
     5015                        mri->set_sourceaddress(l3_mn);
     5016                        mri->set_downstream(true);
     5017                }
     5018                else if(is_flow_receiver) {
     5019                        mri->set_destaddress(l3_mn);
     5020                        mri->set_downstream(false);
     5021                }
     5022       
     5023       
     5024                // send message with PC-MRM
     5025                SignalingMsg* sigmsg = new SignalingMsg();
     5026                sigmsg->set_msg(pdu);
     5027                sigmsg->set_sid(*sid);
     5028                sigmsg->set_sig_mri(mri);
     5029                sigmsg->set_downstream(mri->get_downstream());
     5030                sigmsg->send_or_delete();
     5031        }
    47965032}
    47975033
     
    48605096        // * only lock once
    48615097
    4862         // QN-Type
    4863         context->lock();
    4864         NSLP_Context::qn_type_t type = context->get_qn_type();
    4865         context->unlock();
    4866         if (type == NSLP_Context::QNI) {
     5098//      // QN-Type
     5099//      context->lock();
     5100//      NSLP_Context::qn_type_t type = context->get_qn_type();
     5101//      context->unlock();
     5102//      if (type == NSLP_Context::QNI) {
    48675103                res->set_originator(true);
    4868         }
     5104//      }
    48695105
    48705106        // RSN
  • qos-nslp/branches/20090610-qos-nslp-aho/src/nslp_aho_context.cpp

    r4546 r4567  
    1313
    1414
    15 NSLP_AHO_Context::NSLP_AHO_Context() : node_role(NSLP_AHO_Context::OTHER), anticipated_reservation_successful(false)
     15NSLP_AHO_Context::NSLP_AHO_Context() : node_role(NSLP_AHO_Context::OTHER), anticipated_reservation_successful(false), predecessor_rsn(0)
    1616{
    1717  pthread_mutexattr_init(&mutex_attr);
     
    2626  mri_new_flow = NULL;
    2727  rii_obj = NULL;
     28  qspec_obj = NULL;
    2829} // end constructor
    2930
     
    4142  if(rii_obj != NULL) {
    4243    delete rii_obj;
     44  }
     45
     46  if(qspec_obj != NULL) {
     47    delete qspec_obj;
    4348  }
    4449}
     
    100105
    101106
    102 /** This function is used by the mobile node and sets whether the mobile
    103   * node is the sender of the flow.
    104   * @param true if sender of the flow.
    105   */
    106 void NSLP_AHO_Context::set_is_flow_sender(bool is_sender) {
    107   is_flow_sender = is_sender;
    108 }
    109 
    110 
    111 /** This function returns whether the mobile node is the sender of the flow.
    112   * @return true if sender of the flow.
    113   */
    114 bool NSLP_AHO_Context::get_is_flow_sender() const {
    115   return is_flow_sender;
    116 }
    117 
    118 
    119 /** This function is used by the mobile node and sets whether the mobile
    120   * node is the receiver of the flow.
    121   * @param true if receiver of the flow
    122   */
    123 void NSLP_AHO_Context::set_is_flow_receiver(bool is_receiver) {
    124   is_flow_receiver = is_receiver;
    125 }
    126 
    127 
    128 /** This function returns whether the mobile node is the receiver of the flow.
    129   * @return true if receiver of the flow.
    130   */
    131 bool NSLP_AHO_Context::get_is_flow_receiver() const {
    132   return is_flow_receiver;
    133 }
    134 
    135 
    136107/** This function is used by the new access router and sets the mri of the new
    137108  * flow, which is needed to match RESERVE / RESPONSE messages, that need to be
     
    191162}
    192163
     164
     165/** This function is used by the mobile node in case it is QNR, and sets the
     166  * RSN of the predecessor to process incoming RESERVE messages.
     167  * @param the new RSN to save in context.
     168  */
     169void NSLP_AHO_Context::set_predecessor_rsn(const rsn &pred_rsn) {
     170  predecessor_rsn = pred_rsn;
     171}
     172
     173
     174/** This function is used by the mobile node in case it is QNR, and returns the
     175  * saved RSN of the predecessor to process incoming RESERVE messages.
     176  * @return the saved RSN.
     177  */
     178const rsn &NSLP_AHO_Context::get_predecessor_rsn() const {
     179  return predecessor_rsn;
     180}
     181
     182
     183/** This function is used by the mobile node  and sets the QSPEC of the
     184  * anticipated reservation.
     185  * @param the QSPEC to save in context.
     186  */
     187void NSLP_AHO_Context::set_qspec_anticipated_reservation(qspec_object *qspec_obj) {
     188  assert(qspec_obj != NULL);
     189  this->qspec_obj = qspec_obj->copy();
     190}
     191
     192
     193/** This function is used by the mobile node  and sets the QSPEC of the
     194  * anticipated reservation.
     195  * @return the saved QSPEC.
     196  */
     197qspec_object *NSLP_AHO_Context::get_qspec_anticipated_reservation() const {
     198  return qspec_obj;
     199}
     200
    193201} // end namespace qos_nslp
    194202
Note: See TracChangeset for help on using the changeset viewer.