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

Changeset 4592


Ignore:
Timestamp:
Oct 20, 2009, 3:44:03 PM (8 years ago)
Author:
stud-dettling
Message:
  • Updated some existing methods to support the EST-MRM.
  • Extended NSLP_AHO_Context.
  • Corrected processing of messages on the new access router ARN.
  • Fixed some little errors.
Location:
qos-nslp/branches/20090610-qos-nslp-aho
Files:
5 edited

Legend:

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

    r4567 r4592  
    8282  error_t process_outgoing_est_msg(known_nslp_pdu& rsppdu, NetMsg*& msg, const ntlp::sessionid* rcvd_sid,
    8383                                ntlp::mri_explicitsigtarget** rcvd_mri);
    84   error_t create_new_context(known_nslp_pdu& pdu, error_t& nslpres, bool down,
    85                              const ntlp::sessionid* local_sid, const ntlp::mri_pathcoupled* rcvd_mri,
    86                              ntlp::Flowstatus *fs);
    87   bool find_and_update_context(known_nslp_pdu* pdu, error_t& nslpres, bool down,
    88                                const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri,
    89                                ntlp::Flowstatus *fs);
    90   void forward_reserve(const reservereq* reservemsg, NSLP_Context* context, bool down, const ntlp::mri_pathcoupled* rcvd_mri);
     84//  error_t create_new_context(known_nslp_pdu& pdu, error_t& nslpres, bool down,
     85//                           const ntlp::sessionid* local_sid, const ntlp::mri_pathcoupled* rcvd_mri,
     86//                           ntlp::Flowstatus *fs);
     87  error_t create_new_context(known_nslp_pdu& pdu, error_t& nslpres, const ntlp::sessionid *local_sid,
     88                  const ntlp::mri *rcvd_mri, bool down, ntlp::Flowstatus *fs);
     89//  bool find_and_update_context(known_nslp_pdu* pdu, error_t& nslpres, bool down,
     90//                             const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri,
     91//                             ntlp::Flowstatus *fs);
     92  bool find_and_update_context(known_nslp_pdu* pdu, error_t& nslpres, const ntlp::sessionid *rcvd_sid,
     93                  const ntlp::mri *rcvd_mri, bool down, ntlp::Flowstatus *fs);
     94//  void forward_reserve(const reservereq* reservemsg, NSLP_Context* context, bool down, const ntlp::mri_pathcoupled* rcvd_mri);
     95  void forward_reserve(const reservereq* reservemsg, NSLP_Context* context, const ntlp::mri* fwd_mri, bool down=false);
     96//  error_t  process_rii(NSLP_Context* context, reservereq* reservemsg, const ntlp::sessionid* local_sid,
     97//                     TimerMsg* rii_tmsg, bool is_qni, bool is_qnr, bool down, const ntlp::mri_pathcoupled* rcvd_mri);
    9198  error_t  process_rii(NSLP_Context* context, reservereq* reservemsg, const ntlp::sessionid* local_sid,
    92                        TimerMsg* rii_tmsg, bool is_qni, bool is_qnr, bool down, const ntlp::mri_pathcoupled* rcvd_mri);
     99                       TimerMsg* rii_tmsg, bool is_qni, bool is_qnr, const ntlp::mri *rcvd_mri, bool down);
    93100  error_t  process_qspec(NSLP_Context* context, reservereq* reservemsg, rmf* rmf_adm);
    94   error_t  process_rsn_and_qspec(NSLP_Context* context, reservereq* reservemsg, rmf* rmf_admin,
    95                                  bool is_qni, bool is_qnr, bool& forw, const ntlp::sessionid* local_sid, const ntlp::mri_pathcoupled* rcvd_mri,
     101//  error_t  process_rsn_and_qspec(NSLP_Context* context, reservereq* reservemsg, rmf* rmf_admin,
     102//                               bool is_qni, bool is_qnr, bool& forw, const ntlp::sessionid* local_sid, const ntlp::mri_pathcoupled* rcvd_mri,
     103//                               bool down);
     104  error_t  process_rsn_and_qspec(NSLP_Context *context, reservereq *reservemsg, rmf *rmf_admin,
     105                                 bool is_qni, bool is_qnr, bool &forw, const ntlp::sessionid *local_sid, const ntlp::mri *rcvd_mri,
    96106                                 bool down);
    97107//  void send_response_with_rii(rii* rcvd_rii, bool down, const ntlp::sessionid* sid, const ntlp::mri_pathcoupled* rcvd_mri,
     
    104114                  info_spec::errorclass_t err_class, info_spec::errorcode_t err_code);
    105115  void send_refresh_reserve(NSLP_Context* context);
    106   void process_response_msg(known_nslp_pdu* known_pdu, bool down,
    107                             const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri);
     116//  void process_response_msg(known_nslp_pdu* known_pdu, bool down,
     117//                          const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri);
     118  void process_response_msg(known_nslp_pdu* known_pdu, const ntlp::sessionid* rcvd_sid, const ntlp::mri* rcvd_mri, bool down);
    108119  void process_notify_msg(known_nslp_pdu* known_pdu, bool down, const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri,
    109120                          error_t& nslpres);
    110121  void forward_notify_msg(notifymsg* notify, bool down, const ntlp::mri_pathcoupled* rcvd_mri, const ntlp::sessionid* sid);
    111   void forward_response_msg(responsemsg* response, bool down, const ntlp::mri_pathcoupled* rcvd_mri, const ntlp::sessionid* sid);
     122//  void forward_response_msg(responsemsg* response, bool down, const ntlp::mri_pathcoupled* rcvd_mri, const ntlp::sessionid* sid);
     123  void forward_response_msg(responsemsg* response, const ntlp::sessionid* sid, const ntlp::mri* fwd_mri, bool down=false);
    112124  void process_info_spec_for_appl(info_spec* info_spec, NSLP_Context* context, const ntlp::sessionid* rcvd_sid); 
    113125  error_t process_outgoing_query(known_nslp_pdu& pdu, bool down, const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri,
    114126                                 ntlp::Flowstatus *fs);
    115   void process_query_msg(known_nslp_pdu* known_pdu, bool down, const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri);
     127//  void process_query_msg(known_nslp_pdu* known_pdu, bool down, const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri);
     128  void process_query_msg(known_nslp_pdu* known_pdu, const ntlp::sessionid* rcvd_sid, const ntlp::mri* rcvd_mri, bool down);
    116129  void send_response_to_query(rii* r, qspec_object* q, bool down, const ntlp::sessionid* sid, const ntlp::mri_pathcoupled* rcvd_mri);
    117130  void create_and_send_reserve_msg_as_response_to_query(bool send_rii, qspec_object* q, const bound_sessionid* b,
     
    141154  void aho_phase_1(NSLP_Context* context, void *param1, void *param2);
    142155  void ho_phase_3_2a(NSLP_Context* context, void *param1, void *param2);
    143   void forward_message_if_new_access_router(known_nslp_pdu* known_pdu, const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri);
    144156  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);
     157                  NSLP_Context::qn_type_t qn_type, const hostaddress &l3_mn, bool is_flow_sender, bool is_flow_receiver, bool anticipated_handover);
     158  bool is_new_access_router_and_flow_matches(const ntlp::sessionid &sid, const ntlp::mri_pathcoupled &rcvd_mri, ntlp::mri_explicitsigtarget &fwd_mri);
     159  bool if_new_access_router_send_reserve_msg_as_response_to_query(const ntlp::sessionid &sid, const ntlp::mri_pathcoupled &rcvd_mri, bool is_resv_init);
    146160#endif
    147   void create_reserve_message_from_context(NSLP_Context *context, reservereq *res, rii *send_rii=NULL);
     161  void create_reserve_message_from_context(NSLP_Context *context, reservereq *res, rsn *send_rsn, rii *send_rii=NULL);
    148162  void create_query_message_from_context(NSLP_Context *context, querymsg *query);
    149163 
  • qos-nslp/branches/20090610-qos-nslp-aho/include/nslp_aho_context.h

    r4567 r4592  
    1313#include "rsn.h"
    1414#include "qspec.h"
     15#include "refresh_period.h"
     16#include "bound_sessionid.h"
    1517
    1618
     
    5153  const ntlp::mri_pathcoupled &get_mri_new_flow() const;
    5254
    53   void set_rii(const rii &rii_obj);
    54   const rii &get_rii() const;
     55  void set_rii(const rii *rii_obj);
     56  const rii *get_rii() const;
    5557
    5658  void set_anticipated_reservation_success(bool success);
     
    6264  void set_qspec_anticipated_reservation(qspec_object *qspec_obj);
    6365  qspec_object *get_qspec_anticipated_reservation() const;
     66
     67  void set_own_rsn(const rsn &own_rsn);
     68  const rsn &get_own_rsn() const;
     69
     70  void set_refresh_period(const rp *refresh_period);
     71  const rp *get_refresh_period() const;
     72
     73  void set_bound_sessionid(const bound_sessionid *bs);
     74  const bound_sessionid *get_bound_sessionid() const;
    6475
    6576  /// lock mutex
     
    7889  rsn predecessor_rsn;
    7990  qspec_object *qspec_obj;
     91  rsn own_rsn;
     92  rp *refresh_period;
     93  bound_sessionid *bs;
    8094
    8195  /// This mutex is used to lock the NSLP_AHO_Context
  • qos-nslp/branches/20090610-qos-nslp-aho/src/QoS_StateModule.cpp

    r4567 r4592  
    206206        // check for incoming reserve message
    207207        if (known_pdu->is_reserve()) {
    208 #ifdef USE_AHO
    209                 forward_message_if_new_access_router(known_pdu, sid, rcvd_mri);
    210 #endif
    211                 bool updated = find_and_update_context(known_pdu, nslpres, down, sid, rcvd_mri, NULL);
    212                 if (!updated)
    213                         create_new_context(*known_pdu, nslpres, down, sid, rcvd_mri, NULL);
     208                bool updated = find_and_update_context(known_pdu, nslpres, sid, rcvd_mri, down, NULL);
     209                if (!updated) {
     210                        create_new_context(*known_pdu, nslpres, sid, rcvd_mri, down, NULL);
     211                }
    214212                if ((nslpres != error_ok) &&
    215213                    (nslpres != error_ok_send_response) &&
     
    228226
    229227        if (known_pdu->is_response()) {
    230 #ifdef USE_AHO
    231                 forward_message_if_new_access_router(known_pdu, sid, rcvd_mri);
    232 #endif
    233                 process_response_msg(known_pdu, down, sid, rcvd_mri);
     228                process_response_msg(known_pdu, sid, rcvd_mri, down);
    234229                resultpdu = known_pdu;
    235230                // reset to start and set message length correctly,
     
    240235
    241236        if (known_pdu->is_query()) {
    242                 process_query_msg(known_pdu, down, sid, rcvd_mri);
     237                process_query_msg(known_pdu, sid, rcvd_mri, down);
    243238                resultpdu = known_pdu;
    244239                // reset to start and set message length correctly,
     
    337332                                // downstream
    338333
    339                                 // send RESERVE message with PC-MRM
    340                                 SignalingMsg* sigmsg = new SignalingMsg();
    341                                 sigmsg->set_msg(known_pdu);
    342                                 sigmsg->set_sid(*sid);
    343                                 sigmsg->set_sig_mri(&pc_mri);
    344                                 sigmsg->set_downstream(down);
    345                                 sigmsg->send_or_delete();
     334                                // process RESERVE message just as we had received this
     335                                // message (incoming message)
     336                                error_t nslpres = error_ok;
     337                                bool updated = find_and_update_context(known_pdu, nslpres, sid, rcvd_mri, false, NULL);
     338                                if(!updated) {
     339                                        create_new_context(*known_pdu, nslpres, sid, rcvd_mri, false, NULL);
     340                                }
     341
     342                                switch (nslpres) {
     343                                case state_manager::error_old_pdu:
     344                                case state_manager::error_rsn_missing:
     345                                case state_manager::error_no_bandwidth:
     346                                        DLog(state_manager::modname, "process_tp_recv_est_msg() - processing of RESERVE msg returned an error: "
     347                                                        << error_string(nslpres));
     348                                        break;
     349                                case state_manager::error_nothing_to_do:
     350                                case state_manager::error_ok_forward:
     351                                case state_manager::error_ok_send_response:
     352                                case state_manager::error_ok:
     353                                        break;
     354                                default:
     355                                        ERRLog(state_manager::modname, "Received an NSLP error (#"
     356                                                        << nslpres << ':' << state_manager::error_string(nslpres) << ") that cannot be handled.");
     357                                        break;
     358                                }
     359                                // end process RESERVE message
    346360                        }
    347361                        else {
    348362                                // upstream
     363                               
     364                                reservereq *reservemsg = dynamic_cast<reservereq *>(known_pdu);
     365                                assert(reservemsg != NULL);
     366
     367                                // save RSN in NSLP_AHO_Context
     368                                // Note that aho_context is surly != NULL, even though not checked here!
     369                                // See assignment of variable role.
     370                                rsn *rcvd_rsn = reservemsg->get_rsn();
     371                                rp *rcvd_rp = reservemsg->get_rp();
     372                                bound_sessionid *rcvd_b_sid = reservemsg->get_bound_sid();
     373                                aho_context->lock();
     374                                if(rcvd_rsn) {
     375                                        aho_context->set_predecessor_rsn(*rcvd_rsn);
     376                                }
     377                                if(rcvd_rp) {
     378                                        aho_context->set_refresh_period(rcvd_rp);
     379                                }
     380                                if(rcvd_b_sid) {
     381                                        aho_context->set_bound_sessionid(rcvd_b_sid);
     382                                }
     383                                aho_context->unlock();
    349384
    350385                                // create NOTIFY message
     
    379414
    380415                        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;
     416                        // invert direction of MRI for comparison
     417                        pc_mri.invertDirection();
    389418
    390419                        reservereq* res = dynamic_cast<reservereq *>(known_pdu);
     
    401430                                        // Error can only be send if RII object present
    402431                                        if(rii_obj != NULL) {
    403                                                 send_response_with_rii(rii_obj, sid, est_mri_send, false,
     432                                                send_response_with_rii(rii_obj, sid, rcvd_mri, false,
    404433                                                                info_spec::protocol, info_spec::MandatoryObjectMissing);
    405434                                        }
     
    429458                                }
    430459                                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();
     460                                        if(!res->is_tear_flag()) {
     461                                                qspec_object *qspec_obj = res->get_qspec();
     462                                                if(qspec_obj != NULL) {
     463                                                        // TODO update lifetime of aho_context
     464                                               
     465                                                        aho_context->lock();
     466                                                        // update saved_pred_rsn
     467                                                        aho_context->set_predecessor_rsn(*rcvd_rsn);
     468       
     469                                                        // TODO Should here processing of QSPEC take place?
     470                                                        // I think no, since reservation isn't yet active.
     471                                                        aho_context->set_qspec_anticipated_reservation(qspec_obj);
     472                                                        aho_context->set_anticipated_reservation_success(true);
     473                                                        aho_context->unlock();
     474                                                }
     475                                                else {
     476                                                        // Send RESPONSE with RSN because this message must not be forwarded futher as one hop.
     477                                                        send_response_with_rsn(rcvd_rsn, sid, rcvd_mri, false,
     478                                                                        info_spec::transient, info_spec::FullQSPECrequired);
     479                                                }
     480       
     481                                                rii* rii_obj = res->get_rii();
     482                                                if(rii_obj != NULL) {
     483                                                        send_response_with_rii(rii_obj, sid, rcvd_mri, false,
     484                                                                        info_spec::success, info_spec::ReservationSuccessful);
     485                                                }
     486                                                else {
     487                                                        send_response_with_rsn(rcvd_rsn, sid, rcvd_mri, false,
     488                                                                        info_spec::success, info_spec::ReservationSuccessful);
     489                                                }
    444490                                        }
    445491                                        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);
     492                                                aho_context->lock();
     493                                                aho_context->set_anticipated_reservation_success(false);
     494                                                aho_context->unlock();
    459495                                        }
    460496                                }
     
    481517
    482518                mri_pathcoupled pc_mri = rcvd_mri->get_mri_pc();
     519                // invert direction of MRI for comparison
     520                pc_mri.invertDirection();
    483521
    484522                // determine node role within AHO
    485523                NSLP_AHO_Context::node_role_t role = NSLP_AHO_Context::OTHER;
    486524                ntlp::mri_pathcoupled mri_new_flow;
    487                 rii *context_rii = NULL;
     525                const rii *context_rii = NULL;
    488526                NSLP_AHO_Context *aho_context = aho_contextmap.find(*sid);
    489527                if(aho_context != NULL) {
     
    492530                        mri_new_flow = aho_context->get_mri_new_flow();
    493531                        if(role == NSLP_AHO_Context::MN) {
    494                                 context_rii = aho_context->get_rii().copy();
     532                                context_rii = aho_context->get_rii();
    495533                        }
    496534                        aho_context->unlock();
     
    501539                                rii *resp_rii = resp->get_rii();
    502540                                if(resp_rii != NULL) {
    503                                         if((*context_rii) != (*resp_rii)) {
     541                                        if((context_rii != NULL) && ((*context_rii) != (*resp_rii))) {
    504542                                                ILog(state_manager::modname, "Received RESPONSE-AHO message, but RII object doesn't match.");
    505543                                                return;
     
    539577                }
    540578                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();
     579                        // process RESPONSE message just as we had received this
     580                        // message (incoming message)
     581                        process_response_msg(known_pdu, sid, rcvd_mri, false);
    556582                }
    557583                else {
     
    596622                        // downstream
    597623
    598                         // send QUERY message with PC-MRM
    599                         SignalingMsg* sigmsg = new SignalingMsg();
    600                         sigmsg->set_msg(known_pdu);
    601                         sigmsg->set_sid(*sid);
    602                         sigmsg->set_sig_mri(&pc_mri);
    603                         sigmsg->set_downstream(down);
    604                         sigmsg->send_or_delete();
    605 
     624                        // process QUERY message just as we had received this
     625                        // message (incoming message)
     626                        process_query_msg(known_pdu, sid, rcvd_mri, false);
    606627                }
    607628                else {
     
    692713                        }
    693714
    694                         // generate new rii object
    695                         rii *rii_obj = new rii();
    696                         rii_obj->generate_new();
    697                         rii_obj->set_own(true);
    698                         rii_obj->set_is_reserve(true);
    699 
    700                         create_reserve_message_from_context(context, reserve, rii_obj);
     715                        rii *rii_obj = NULL;
     716                        if(!notify->is_x_flag()) {
     717                                // generate new rii object
     718                                rii *rii_obj = new rii();
     719                                rii_obj->generate_new();
     720                                rii_obj->set_own(true);
     721                                rii_obj->set_is_reserve(true);
     722                        }
     723
     724                        // TODO take RSN+1 from context if existing else generate a new one
     725                        // generate new rsn object
     726                        rsn *rsn_obj = new rsn();
     727                        rsn_obj->generate_new();
     728
     729                        create_reserve_message_from_context(context, reserve, rsn_obj, rii_obj);
     730                        reserve->set_originator(true);
    701731                        if(notify->is_x_flag()) {
    702732                                reserve->set_replace_flag();
     
    777807  dest_a = (*rcvd_mri)->get_destaddress();
    778808
    779   if (pdu.is_notify())
     809  if (pdu.is_notify()) {
    780810    ILog(state_manager::modname, color[magenta] << "Outgoing NOTIFY message!" << color[off]);
    781 
    782   if (pdu.is_response())
     811  }
     812
     813  if (pdu.is_response()) {
    783814    ILog(state_manager::modname, color[magenta] << "Outgoing RESPONSE message!" << color[off]);
     815  }
    784816
    785817  if (pdu.is_reserve()) {
     
    796828  if ((processing) && (!is_tear)) {
    797829    if (pdu.is_reserve()) {
    798       updated = find_and_update_context(&pdu, nslpres, down, rcvd_sid, *rcvd_mri, fs);
    799       if (!updated)
    800         ret_nslpres = create_new_context(pdu, nslpres, down, rcvd_sid, *rcvd_mri, fs);
     830      updated = find_and_update_context(&pdu, nslpres, rcvd_sid, *rcvd_mri, down, fs);
     831      if (!updated) {
     832        ret_nslpres = create_new_context(pdu, nslpres, rcvd_sid, *rcvd_mri, down, fs);
     833      }
    801834    }
    802835    if ((ret_nslpres!=error_ok) &&
     
    938971/** processes received QUERY message.
    939972 * @param known_pdu NSLP PDU to be processed.
    940  * @param down set to TRUE, if the direction is downstream, otherwise set to FALSE.
    941973 * @param rcvd_sid the session id the current message belongs to.
    942974 * @param rcvd_mri the MRI of the current session.
     975 * @param down set to TRUE, if the direction is downstream, otherwise set to FALSE. Only evaluated if MRI is path-coupled.
    943976 */
    944 void state_manager::process_query_msg(known_nslp_pdu* known_pdu, bool down,
    945                   const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri)
    946 {
    947   querymsg* query;
     977void state_manager::process_query_msg(known_nslp_pdu* known_pdu, const ntlp::sessionid* rcvd_sid, const ntlp::mri* rcvd_mri, bool down) {
     978  querymsg* query = dynamic_cast<querymsg*>(known_pdu);
     979  assert(query != NULL);
     980
     981  const ntlp::mri_pathcoupled *rcvd_pc_mri=NULL;
    948982
    949983// XXX: I think this is not used anymore
     
    953987  ILog(state_manager::modname, "process_query_msg()");
    954988
    955   query = dynamic_cast<querymsg*>(known_pdu);
     989
     990  if(rcvd_mri == NULL) {
     991          ERRLog(state_manager::modname, "process_query_msg() - rcvd_mri == NULL");
     992          return;
     993  }
     994
     995  if(rcvd_mri->get_mrm() == mri::mri_t_pathcoupled) {
     996          rcvd_pc_mri = dynamic_cast<const ntlp::mri_pathcoupled *>(rcvd_mri);
     997          assert(rcvd_pc_mri != NULL);
     998  }
     999  else if(rcvd_mri->get_mrm() == mri::mri_t_explicitsigtarget) {
     1000          const ntlp::mri_explicitsigtarget *rcvd_est_mri = dynamic_cast<const ntlp::mri_explicitsigtarget *>(rcvd_mri);
     1001          assert(rcvd_est_mri != NULL);
     1002
     1003          rcvd_pc_mri  = &rcvd_est_mri->get_mri_pc();
     1004          down = rcvd_pc_mri->get_downstream();
     1005  }
     1006  else {
     1007          ERRLog(state_manager::modname, "process_query_msg() - Unknown MRI with MRI-ID: " << rcvd_mri->get_mrm());
     1008          return;
     1009  }
     1010
     1011  // if QUERY was received by the PC-MRM and has the X-bit set, delete NLSP_AHO_Context for this session
     1012  if((rcvd_mri->get_mrm() == mri::mri_t_pathcoupled) && (query->is_x_flag())) {
     1013        // delete AHO_Context if existing
     1014        aho_contextmap.erase(*rcvd_sid);
     1015  }
    9561016
    9571017  NSLP_Context* context = rcvd_sid ? contextmap.find(*rcvd_sid) : 0;
     
    9821042    type= context->get_qn_type();
    9831043    context->set_downstream(down);
    984     context->set_mri(rcvd_mri);
     1044    context->set_mri(rcvd_pc_mri);
    9851045    context->unlock();
    9861046    //================================= process RII ======================================
    9871047    rii* r = query->get_rii();
    988     if (r) {   
     1048    if (r) {
    9891049      uint32 rii_number;
    9901050      r->get(rii_number);
    9911051      ILog(state_manager::modname, "RII in QUERY existing " << rii_number);
     1052
     1053      if(rcvd_mri->get_mrm() == mri::mri_t_explicitsigtarget) {
     1054              ERRLog(state_manager::modname, "QUERY message with RII via EST-MRM received. This should not happen!");
     1055              return;
     1056      }
    9921057
    9931058      if (type != NSLP_Context::QNR) {
     
    10021067            if (found_context_rii->get_own()) {
    10031068              ERRLog(state_manager::modname, "Another node has sent a message with the duplicated RII!!!");
    1004 //            send_response_with_rii(r, !down, rcvd_sid, rcvd_mri, info_spec::transient, info_spec::RIIconflict);
    10051069              send_response_with_rii(r, rcvd_sid, rcvd_mri, !down, info_spec::transient, info_spec::RIIconflict);
    10061070              return;
     
    10121076      }  // end if not QNR
    10131077
    1014       if (type == NSLP_Context::QNR)
    1015         send_response_to_query(r, q, !down, rcvd_sid, rcvd_mri);
     1078      if (type == NSLP_Context::QNR) {
     1079        send_response_to_query(r, q, !down, rcvd_sid, rcvd_pc_mri);
     1080      }
    10161081      else {
    1017         if (query->is_scoping_flag())
    1018           send_response_to_query(r, q, !down, rcvd_sid, rcvd_mri);
    1019         else
    1020           forward_query_msg(query, down, rcvd_sid, rcvd_mri);
     1082        if (query->is_scoping_flag()) {
     1083          send_response_to_query(r, q, !down, rcvd_sid, rcvd_pc_mri);
     1084        }
     1085        else {
     1086          forward_query_msg(query, down, rcvd_sid, rcvd_pc_mri);
     1087        }
    10211088      }
    10221089    }  // end if RII existing
    10231090    else {
    1024 // TODO: Anticipated Handover, Case 3
    1025 
    1026       // if I'm the QNR I should respond to the Query
    1027       if ( query->is_reserve_init_flag() && is_last_signaling_hop(rcvd_mri) ) {
    1028         // create RESERVE msg, send to QUERY initiator
    1029         create_and_send_reserve_msg_as_response_to_query(true, q, rcvd_b_sid, !down, rcvd_sid, rcvd_mri, context, is_x_flag_set);
    1030       }
    1031       else if (query->is_reserve_init_flag()) {
    1032         forward_query_msg(query, down, rcvd_sid, rcvd_mri);
    1033       }
    1034       else { // I'm a QNE, so simply forward this QUERY
    1035         // !query->is_reserve_init_flag()
    1036         ERRLog(state_manager::modname, "Reservation existing! Wrong message requesting new reservation!!!");
     1091      // In Anticipated Handover, Case 3
     1092      // the method "if_new_access_router_send_reserve_msg_as_response_to_query" sends and processes
     1093      // a RESERVE message on behalf of the mobile node. In all other cases the conditional block
     1094      // is executed.
     1095      if((rcvd_mri->get_mrm() == mri::mri_t_pathcoupled) &&
     1096                      !if_new_access_router_send_reserve_msg_as_response_to_query(*rcvd_sid, *rcvd_pc_mri, query->is_reserve_init_flag())) {
     1097              // if I'm the QNR I should respond to the Query
     1098              if ( query->is_reserve_init_flag() && is_last_signaling_hop(rcvd_pc_mri) ) {
     1099                // create RESERVE msg, send to QUERY initiator
     1100                create_and_send_reserve_msg_as_response_to_query(true, q, rcvd_b_sid, !down, rcvd_sid, rcvd_pc_mri, context, is_x_flag_set);
     1101              }
     1102              else if (query->is_reserve_init_flag()) {
     1103                forward_query_msg(query, down, rcvd_sid, rcvd_pc_mri);
     1104              }
     1105              else { // I'm a QNE, so simply forward this QUERY
     1106                // !query->is_reserve_init_flag()
     1107                ERRLog(state_manager::modname, "Reservation existing! Wrong message requesting new reservation!!!");
     1108              }
    10371109      }
    10381110    }
     
    10801152      // if it RII is present, it cannot have the R flag set
    10811153      ILog(state_manager::modname, "RII existing!");
    1082       // XXX: this test should be "is_last_signaling_hop(rcvd_mri)" ?!?
     1154
     1155      if(rcvd_mri->get_mrm() == mri::mri_t_explicitsigtarget) {
     1156              ERRLog(state_manager::modname, "QUERY message with RII via EST-MRM received. This should not happen!");
     1157              return;
     1158      }
     1159
     1160      // XXX: this test should be "is_last_signaling_hop(rcvd_pc_mri)" ?!?
    10831161      if (type == NSLP_Context::QNR) {
    1084         send_response_to_query(r, q, !down, rcvd_sid, rcvd_mri);
     1162        send_response_to_query(r, q, !down, rcvd_sid, rcvd_pc_mri);
    10851163      }
    10861164      else {
    10871165        if (query->is_scoping_flag()) {
    1088           send_response_to_query(r, q, !down, rcvd_sid, rcvd_mri);
     1166          send_response_to_query(r, q, !down, rcvd_sid, rcvd_pc_mri);
    10891167        }
    10901168        else {
    1091           forward_query_msg(query, down, rcvd_sid, rcvd_mri);
     1169          forward_query_msg(query, down, rcvd_sid, rcvd_pc_mri);
    10921170        }
    10931171      }
    10941172    }  // end if RII existing
    10951173    else { // no RII present
    1096 // TODO: Anticipated Handover, Case 3
    1097 
    1098 
    1099       // if I'm the QNR I should respond to the Query
    1100       if ( query->is_reserve_init_flag() && is_last_signaling_hop(rcvd_mri) ) {
    1101         // create RESERVE msg, send to QUERY initiator
    1102         create_and_send_reserve_msg_as_response_to_query(true, q, rcvd_b_sid, !down, rcvd_sid, rcvd_mri, 0, is_x_flag_set);
     1174      // In Anticipated Handover, Case 3
     1175      // the method "if_new_access_router_send_reserve_msg_as_response_to_query" sends and processes
     1176      // a RESERVE message on behalf of the mobile node. In all other cases the conditional block
     1177      // is executed.
     1178      if((rcvd_mri->get_mrm() == mri::mri_t_pathcoupled) &&
     1179                      !if_new_access_router_send_reserve_msg_as_response_to_query(*rcvd_sid, *rcvd_pc_mri, query->is_reserve_init_flag())) {
     1180              // if I'm the QNR I should respond to the Query
     1181              if ( query->is_reserve_init_flag() && is_last_signaling_hop(rcvd_pc_mri) ) {
     1182                // create RESERVE msg, send to QUERY initiator
     1183                create_and_send_reserve_msg_as_response_to_query(true, q, rcvd_b_sid, !down, rcvd_sid, rcvd_pc_mri, 0, is_x_flag_set);
     1184              }
     1185              else { // I'm a QNE, so simply forward this QUERY
     1186                // HA TEnter
     1187                if (down && addresses->addr_is_in(rcvd_pc_mri->get_destaddress(), AddressList::HomeNet_P)) {
     1188                  ntlp::mri_pathcoupled *logical_tmri = rcvd_pc_mri->copy();
     1189                  hostaddress *my_src = dynamic_cast<hostaddress *>(addresses->get_first(AddressList::HAAddr_P, rcvd_pc_mri->get_destaddress().is_ipv4()));
     1190                  logical_tmri->set_sourceaddress(*my_src);
     1191       
     1192                  uint128 tsid;
     1193       
     1194                  querymsg* tunnel_query = new querymsg();
     1195                  copy_query_message(query, tunnel_query);
     1196       
     1197                  tunnel_query->set_originator(true);
     1198                  known_nslp_pdu *pdu = dynamic_cast<known_nslp_pdu*>(tunnel_query);
     1199                  SignalingMsg* sigmsg = new SignalingMsg();
     1200                  sigmsg->set_msg(pdu);
     1201       
     1202                  sigmsg->set_sig_mri(logical_tmri);
     1203       
     1204                  sigmsg->set_downstream(down);
     1205       
     1206                  ntlp::sessionid* sid = new sessionid();
     1207                  sid->generate_random();
     1208                  sid->generate_random();
     1209                  tsid = *sid;
     1210       
     1211                  bound_sessionid* send_bs = new bound_sessionid();
     1212                  send_bs->set(tsid);
     1213       
     1214                  query->set_bound_sid(send_bs);
     1215       
     1216                  sigmsg->set_sid(tsid);
     1217                  sigmsg->send_or_delete();
     1218                }
     1219       
     1220                forward_query_msg(query, down, rcvd_sid, rcvd_pc_mri);
     1221              }
    11031222      }
    1104       else { // I'm a QNE, so simply forward this QUERY
    1105         // HA TEnter
    1106         if (down && addresses->addr_is_in(rcvd_mri->get_destaddress(), AddressList::HomeNet_P)) {
    1107           ntlp::mri_pathcoupled *logical_tmri = rcvd_mri->copy();
    1108           hostaddress *my_src = dynamic_cast<hostaddress *>(addresses->get_first(AddressList::HAAddr_P, rcvd_mri->get_destaddress().is_ipv4()));
    1109           logical_tmri->set_sourceaddress(*my_src);
    1110 
    1111           uint128 tsid;
    1112 
    1113           querymsg* tunnel_query = new querymsg();
    1114           copy_query_message(query, tunnel_query);
    1115 
    1116           tunnel_query->set_originator(true);
    1117           known_nslp_pdu *pdu = dynamic_cast<known_nslp_pdu*>(tunnel_query);
    1118           SignalingMsg* sigmsg = new SignalingMsg();
    1119           sigmsg->set_msg(pdu);
    1120 
    1121           sigmsg->set_sig_mri(logical_tmri);
    1122 
    1123           sigmsg->set_downstream(down);
    1124 
    1125           ntlp::sessionid* sid = new sessionid();
    1126           sid->generate_random();
    1127           sid->generate_random();
    1128           tsid = *sid;
    1129 
    1130           bound_sessionid* send_bs = new bound_sessionid();
    1131           send_bs->set(tsid);
    1132 
    1133           query->set_bound_sid(send_bs);
    1134 
    1135           sigmsg->set_sid(tsid);
    1136           sigmsg->send_or_delete();
    1137         }
    1138 
    1139         forward_query_msg(query, down, rcvd_sid, rcvd_mri);
    1140       }
    1141 
    11421223    } // end else
    11431224  }  // end no context
     
    14801561 * @param pdu RESERVE message is used to create new NSLP context.
    14811562 * @retval internal NSLP_error_t errorcode, usually error_ok for success.
    1482  * @param down set to TRUE, if the direction is downstream, otherwise set to FALSE.
     1563 * @param down set to TRUE, if the direction is downstream, otherwise set to FALSE. Only useful with PC-MRM.
    14831564 * @param local_sid the session id the current message belongs to.
    14841565 * @param rcvd_mri the MRI of the current session.
    14851566 */
    1486 state_manager::error_t state_manager::create_new_context(known_nslp_pdu& pdu, error_t& nslpres, bool down,
    1487                                                          const ntlp::sessionid* local_sid, const ntlp::mri_pathcoupled* rcvd_mri, ntlp::Flowstatus *fs)
    1488   {
    1489           reservereq* reservemsg = NULL;
     1567state_manager::error_t state_manager::create_new_context(known_nslp_pdu& pdu, error_t& nslpres, const ntlp::sessionid *local_sid,
     1568                const ntlp::mri *rcvd_mri, bool down, ntlp::Flowstatus *fs)
     1569{
     1570          reservereq* reservemsg = dynamic_cast<reservereq *>(&pdu);
     1571          assert(reservemsg != NULL);
     1572
    14901573          rsn* rsn_up = NULL;
    14911574          rsn* rsn_down = NULL;
     
    14951578          uint32 rsn_number_up, rsn_number_down, new_refr_p, new_lifetime;
    14961579
     1580          const ntlp::mri_pathcoupled *rcvd_pc_mri=NULL;
     1581          ntlp::mri_explicitsigtarget fwd_est_mri;
     1582
    14971583          ILog(state_manager::modname, "create_new_context() for session " << local_sid->to_string());
     1584         
     1585         
     1586          if(rcvd_mri == NULL) {
     1587                  ERRLog(state_manager::modname, "create_new_context() - rcvd_mri == NULL");
     1588                  nslpres = error_nothing_to_do;
     1589                  return nslpres;
     1590          }
     1591
     1592          if(rcvd_mri->get_mrm() == mri::mri_t_pathcoupled) {
     1593                  rcvd_pc_mri = dynamic_cast<const ntlp::mri_pathcoupled *>(rcvd_mri);
     1594                  assert(rcvd_pc_mri != NULL);
     1595          }
     1596          else if(rcvd_mri->get_mrm() == mri::mri_t_explicitsigtarget) {
     1597                  const ntlp::mri_explicitsigtarget *rcvd_est_mri = dynamic_cast<const ntlp::mri_explicitsigtarget *>(rcvd_mri);
     1598                  assert(rcvd_est_mri != NULL);
     1599
     1600                  rcvd_pc_mri  = &rcvd_est_mri->get_mri_pc();
     1601                  down = rcvd_pc_mri->get_downstream();
     1602          }
     1603          else {
     1604                  ERRLog(state_manager::modname, "create_new_context() - Unknown MRI with MRI-ID: " << rcvd_mri->get_mrm());
     1605                  nslpres = error_nothing_to_do;
     1606                  return nslpres;
     1607          }
     1608         
     1609          // if RESERVE was received by the PC-MRM and has the Replace-bit set, delete NLSP_AHO_Context for this session
     1610          if((rcvd_mri->get_mrm() == mri::mri_t_pathcoupled) && (reservemsg->is_replace_flag())) {
     1611                  // delete AHO_Context if existing
     1612                  aho_contextmap.erase(*local_sid);
     1613          }
     1614
    14981615
    14991616          NSLP_Context* local_context = new NSLP_Context();
     
    15081625
    15091626          NSLP_Context::qn_type_t type = NSLP_Context::QNE;
    1510           if ( down && is_last_signaling_hop(rcvd_mri) ) // I am a last signaling hop for this flow => QNR
     1627          if ( down && is_last_signaling_hop(rcvd_pc_mri) ) // I am a last signaling hop for this flow => QNR
    15111628          {
    15121629            type = NSLP_Context::QNR;
     
    15301647
    15311648          // determine if we are flow sender or flow receiver or none of them
    1532           bool is_flow_sender = is_flow_source(rcvd_mri);
    1533           bool is_flow_receiver = is_flow_destination(rcvd_mri);
     1649          bool is_flow_sender = is_flow_source(rcvd_pc_mri);
     1650          bool is_flow_receiver = is_flow_destination(rcvd_pc_mri);
    15341651
    15351652
     
    15371654          local_context->set_qn_type(type);
    15381655          local_context->set_downstream(down);
    1539           local_context->set_mri(rcvd_mri);
     1656          local_context->set_mri(rcvd_pc_mri);
    15401657          if (fs)
    15411658            local_context->set_logical_mri(&fs->orig_mri);
    15421659          else
    1543             local_context->set_logical_mri(rcvd_mri);
     1660            local_context->set_logical_mri(rcvd_pc_mri);
    15441661          local_context->set_is_flow_sender(is_flow_sender);
    15451662          local_context->set_is_flow_receiver(is_flow_receiver);
    15461663          local_context->unlock();
    15471664
    1548           reservemsg = dynamic_cast<reservereq*>(&pdu);
    15491665
    15501666          if (fs && fs->type == ntlp::Flowstatus::fs_tunnel && type != NSLP_Context::QNR) {
     
    15931709
    15941710        // HA as TEnter ... a bit of guess work
    1595         if (down && type == NSLP_Context::QNE && addresses->addr_is_in(rcvd_mri->get_destaddress(), AddressList::HomeNet_P)) {
    1596                 ILog(state_manager::modname, "HA TEnter for: " << *rcvd_mri);
    1597 
    1598                 ntlp::mri_pathcoupled *logical_tmri = rcvd_mri->copy();
    1599                 hostaddress *my_src = dynamic_cast<hostaddress *>(addresses->get_first(AddressList::HAAddr_P, rcvd_mri->get_destaddress().is_ipv4()));
     1711        if (down && type == NSLP_Context::QNE && addresses->addr_is_in(rcvd_pc_mri->get_destaddress(), AddressList::HomeNet_P)) {
     1712                ILog(state_manager::modname, "HA TEnter for: " << *rcvd_pc_mri);
     1713
     1714                ntlp::mri_pathcoupled *logical_tmri = rcvd_pc_mri->copy();
     1715                hostaddress *my_src = dynamic_cast<hostaddress *>(addresses->get_first(AddressList::HAAddr_P, rcvd_pc_mri->get_destaddress().is_ipv4()));
    16001716                logical_tmri->set_sourceaddress(*my_src);
    16011717
     
    16491765          if (reservemsg->is_tear_flag()) {
    16501766                  ILog(state_manager::modname, "TEAR-DOWN Flag set!");
    1651                   if (type == NSLP_Context::QNE)
    1652                           forward_reserve(reservemsg, local_context, down, rcvd_mri);
     1767                  if (type == NSLP_Context::QNE) {
     1768#ifdef USE_AHO
     1769                          if((rcvd_mri->get_mrm() == mri::mri_t_pathcoupled) &&
     1770                                          is_new_access_router_and_flow_matches(*local_sid, *rcvd_pc_mri, fwd_est_mri)) {
     1771                                // forward RESERVE message towards the mobile node by means of the EST-MRM
     1772                                forward_reserve(reservemsg, local_context, &fwd_est_mri);
     1773                          }
     1774                          else {
     1775                                // forward RESERVE message by means of the PC-MRM
     1776                                forward_reserve(reservemsg, local_context, rcvd_pc_mri, down);
     1777                          }
     1778#else
     1779                          forward_reserve(reservemsg, local_context, rcvd_pc_mri, down);
     1780#endif
     1781                  }
    16531782                  nslpres = error_nothing_to_do;
    16541783                  // XXX: maybe delete local_context forgotten??
     
    17121841                  Log(ERROR_LOG, LOG_NORMAL, state_manager::modname, "In create_new() GOT ONE RESERVE MESSAGE with NO RSN ");
    17131842                  nslpres = error_rsn_missing;
    1714                   if (rcvd_rii)
    1715 //                        send_response_with_rii(rcvd_rii, !down, local_sid, rcvd_mri, info_spec::protocol, info_spec::MandatoryObjectMissing);
     1843                  if (rcvd_rii) {
    17161844                          send_response_with_rii(rcvd_rii, local_sid, rcvd_mri, !down, info_spec::protocol, info_spec::MandatoryObjectMissing);
     1845                  }
    17171846                  // cannot forward RESERVE msg w/o RSN, delete msg
    17181847                  return nslpres;
     
    17311860                          if (type != NSLP_Context::QNI) {
    17321861                                  if (rcvd_rii) {
    1733 //                                        send_response_with_rii(rcvd_rii, !down, local_sid, rcvd_mri,
    17341862                                          send_response_with_rii(rcvd_rii, local_sid, rcvd_mri, !down,
    17351863                                                          info_spec::transient,
     
    17421870                                  }
    17431871                                  else {
    1744 //                                        send_response_with_rsn(rsn_up, !down, local_sid, rcvd_mri,
    17451872                                          send_response_with_rsn(rsn_up, local_sid, rcvd_mri, !down,
    17461873                                                          info_spec::transient,
     
    17531880                                  }
    17541881                          }
    1755                           else
     1882                          else {
    17561883                            notify_application(local_context, QoS_Appl_Msg::type_not_enough_resources, local_sid);
     1884                          }
    17571885
    17581886                          ILog(state_manager::modname, "Deleting Context!");
     
    17641892          else {
    17651893                  ILog(state_manager::modname, "NO QSPEC!");
    1766 //                send_response_with_rsn(rsn_up, !down, local_sid, rcvd_mri, info_spec::transient, info_spec::FullQSPECrequired);
    17671894                  send_response_with_rsn(rsn_up, local_sid, rcvd_mri, !down, info_spec::transient, info_spec::FullQSPECrequired);
    17681895          }
     
    17731900          bool send = true;
    17741901          if (rcvd_rii) {
    1775                   function_res = process_rii(local_context, reservemsg, local_sid, tmsg, type == NSLP_Context::QNI, type == NSLP_Context::QNR, down, rcvd_mri);
     1902                  function_res = process_rii(local_context, reservemsg, local_sid, tmsg, type == NSLP_Context::QNI, type == NSLP_Context::QNR, rcvd_pc_mri, down);
    17761903                  if (function_res != error_ok)
    17771904                          nslpres = function_res;
     
    17911918#endif
    17921919                          }
    1793 //                        send_response_with_rii(rcvd_rii, !down, local_sid, rcvd_mri, info_spec::success, er_code);
    17941920                          send_response_with_rii(rcvd_rii, local_sid, rcvd_mri, !down, info_spec::success, er_code);
    17951921                          if (reservemsg->is_scoping_flag()) {
     
    18091935                          if ((reservemsg->is_acknowledge_flag()) || (reservemsg->is_scoping_flag())) {
    18101936                                  Log(INFO_LOG,LOG_NORMAL,state_manager::modname, "QNE or QNR, A-Flag set, send RESPONSE");
    1811 //                                send_response_with_rsn(rsn_up, !down, local_sid, rcvd_mri,
    18121937                                  send_response_with_rsn(rsn_up, local_sid, rcvd_mri, !down,
    18131938                                                  info_spec::success,
     
    18671992                  if (((nslpres == error_ok_forward) && (i_am_originator))  ||
    18681993                                  ( (nslpres == error_ok_forward) && (!i_am_originator) && (type == NSLP_Context::QNE) && (!(reservemsg->is_scoping_flag())))) {
    1869                           forward_reserve(reservemsg, local_context, down, rcvd_mri);
     1994#ifdef USE_AHO
     1995                          if((rcvd_mri->get_mrm() == mri::mri_t_pathcoupled) &&
     1996                                          is_new_access_router_and_flow_matches(*local_sid, *rcvd_pc_mri, fwd_est_mri)) {
     1997                                // forward RESERVE message towards the mobile node by means of the EST-MRM
     1998                                forward_reserve(reservemsg, local_context, &fwd_est_mri);
     1999                          }
     2000                          else {
     2001                                // forward RESERVE message by means of the PC-MRM
     2002                                forward_reserve(reservemsg, local_context, rcvd_pc_mri, down);
     2003                          }
     2004#else
     2005                          forward_reserve(reservemsg, local_context, rcvd_pc_mri, down);
     2006#endif
    18702007                          // nslpres is still error_ok_forward
    18712008                          // XXX or error_ok_forward !?!
     
    19122049
    19132050          return nslpres;
    1914   }
     2051}
    19152052
    19162053/** This function sends a refresh RESERVE message.
     
    21562293                assert(est_mri != NULL);
    21572294
    2158                 info_spec* info_spec_obj = new info_spec(NULL, err_class, err_code, 0);
     2295                // prepare EST-MRI for sending RESPONSE message
     2296                mri_pathcoupled pc_mri_send = est_mri->get_mri_pc();
     2297                pc_mri_send.invertDirection();
     2298                const hostaddress orig_sig_addr = est_mri->get_dest_sig_address();
     2299                const hostaddress dest_sig_addr = est_mri->get_origin_sig_address();
     2300                mri_explicitsigtarget *est_mri_send = new mri_explicitsigtarget(pc_mri_send, orig_sig_addr, dest_sig_addr);
     2301
     2302                // For simplicity, extract v4-mapped address for v4 case
     2303                in6_addr addr6;
     2304                netaddress *na = addresses->get_first(AddressList::ConfiguredAddr_P, est_mri->get_dest_sig_address().is_ipv4());
     2305                na->get_ip(addr6);
     2306                delete(na);
     2307
     2308                info_spec* info_spec_obj = new info_spec(&addr6, err_class, err_code, 0);
    21592309                resp->set_errorobject(info_spec_obj);
    21602310               
     
    21642314                ExplicitSignalingMsg* sigmsg = new ExplicitSignalingMsg();
    21652315                sigmsg->set_pdu(pdu);
    2166                 sigmsg->set_sig_mri(est_mri);
     2316                sigmsg->set_sig_mri(est_mri_send);
    21672317                sigmsg->set_sid(*sid);
    21682318                sigmsg->send_or_delete();
     
    22702420                assert(est_mri != NULL);
    22712421
    2272                 info_spec* info_spec_obj = new info_spec(NULL, err_class, err_code, 0);
     2422                // prepare EST-MRI for sending RESPONSE message
     2423                mri_pathcoupled pc_mri_send = est_mri->get_mri_pc();
     2424                pc_mri_send.invertDirection();
     2425                const hostaddress orig_sig_addr = est_mri->get_dest_sig_address();
     2426                const hostaddress dest_sig_addr = est_mri->get_origin_sig_address();
     2427                mri_explicitsigtarget *est_mri_send = new mri_explicitsigtarget(pc_mri_send, orig_sig_addr, dest_sig_addr);
     2428
     2429                // For simplicity, extract v4-mapped address for v4 case
     2430                in6_addr addr6;
     2431                netaddress *na = addresses->get_first(AddressList::ConfiguredAddr_P, est_mri->get_dest_sig_address().is_ipv4());
     2432                na->get_ip(addr6);
     2433                delete(na);
     2434
     2435                info_spec* info_spec_obj = new info_spec(&addr6, err_class, err_code, 0);
    22732436                resp->set_errorobject(info_spec_obj);
    22742437               
     
    22782441                ExplicitSignalingMsg* sigmsg = new ExplicitSignalingMsg();
    22792442                sigmsg->set_pdu(pdu);
    2280                 sigmsg->set_sig_mri(est_mri);
     2443                sigmsg->set_sig_mri(est_mri_send);
    22812444                sigmsg->set_sid(*sid);
    22822445                sigmsg->send_or_delete();
     
    23922555
    23932556    if (context == NULL) {
    2394         error_t ret_nslpres = create_new_context(*pdu, ret_nslpres, down, sid, rcvd_mri, 0);
     2557//        error_t ret_nslpres = create_new_context(*pdu, ret_nslpres, down, sid, rcvd_mri, 0);
     2558        error_t ret_nslpres = create_new_context(*pdu, ret_nslpres, sid, rcvd_mri, down, 0);
    23952559        if (ret_nslpres != error_ok) {
    23962560            ERRLog(state_manager::modname,"create_and_send_reserve_msg_as_response_to_query() - unexpected error while creating context");
     
    24122576 * @param reservemsg received RESERVE message. Will be copied for forwarding.
    24132577 * @param context the NSLP context of the current session.
    2414  * @param down set to TRUE, if the direction is downstream, otherwise set to FALSE.
    2415  * @param rcvd_mri the MRI of the current session.
     2578 * @param fwd_mri the MRI used to forward this message.
     2579 * @param down set to TRUE, if the direction is downstream, otherwise set to FALSE. Only used by the PC-MRM.
    24162580 */
    2417 void state_manager::forward_reserve(const reservereq* reservemsg, NSLP_Context* context, bool down, const ntlp::mri_pathcoupled* rcvd_mri)
    2418 {
     2581void state_manager::forward_reserve(const reservereq* reservemsg, NSLP_Context* context, const ntlp::mri* fwd_mri, bool down) {
    24192582    DLog(state_manager::modname,"forward_reserve()");
    24202583    reservereq* res;
    24212584    known_nslp_pdu* pdu = NULL;
    2422     SignalingMsg* sigmsg;
     2585
     2586    if(fwd_mri == NULL) {
     2587            ERRLog(state_manager::modname, "forward_reserve() - fwd_mri == NULL");
     2588            return;
     2589    }
    24232590
    24242591    res = new reservereq();
     
    24712638    pdu = dynamic_cast<known_nslp_pdu*>(res);
    24722639
    2473     sigmsg = new SignalingMsg();
    2474     sigmsg->set_msg(pdu);
    2475     sigmsg->set_sig_mri(rcvd_mri);
    2476     sigmsg->set_downstream(down);
    2477     sigmsg->set_sid(local_sid);
    2478     sigmsg->set_sii_handle(0);
    2479     sigmsg->send_or_delete();
     2640    if(fwd_mri->get_mrm() == mri::mri_t_pathcoupled) {
     2641            const ntlp::mri_pathcoupled* pc_mri = dynamic_cast<const ntlp::mri_pathcoupled *>(fwd_mri);
     2642            assert(pc_mri != NULL);
     2643
     2644            SignalingMsg *sigmsg = new SignalingMsg();
     2645            sigmsg->set_msg(pdu);
     2646            sigmsg->set_sig_mri(pc_mri);
     2647            sigmsg->set_downstream(down);
     2648            sigmsg->set_sid(local_sid);
     2649            sigmsg->set_sii_handle(0);
     2650            sigmsg->send_or_delete();
     2651    }
     2652    else if(fwd_mri->get_mrm() == mri::mri_t_explicitsigtarget) {
     2653            const ntlp::mri_explicitsigtarget *est_mri = dynamic_cast<const ntlp::mri_explicitsigtarget *>(fwd_mri);
     2654            assert(est_mri != NULL);
     2655
     2656            ExplicitSignalingMsg *sigmsg = new ExplicitSignalingMsg();
     2657            sigmsg->set_pdu(pdu);
     2658            sigmsg->set_sig_mri(est_mri);
     2659            sigmsg->set_sid(local_sid);
     2660            sigmsg->send_or_delete();
     2661    }
     2662    else {
     2663            ERRLog(state_manager::modname, "forward_reserve() - Unknown MRI with MRI-ID: " << fwd_mri->get_mrm());
     2664            return;
     2665    }
     2666
    24802667    DLog(state_manager::modname,"END forward_reserve()");
    24812668}
     
    24922679 */
    24932680state_manager::error_t  state_manager::process_rii(NSLP_Context* context, reservereq* reservemsg, const ntlp::sessionid* local_sid,
    2494                                  TimerMsg* rii_tmsg, bool is_qni, bool is_qnr, bool down, const ntlp::mri_pathcoupled* rcvd_mri)
     2681                                 TimerMsg* rii_tmsg, bool is_qni, bool is_qnr, const ntlp::mri *rcvd_mri, bool down)
    24952682{
    24962683    error_t nslpres = error_ok;
     
    25302717            if (!rcvd_rii->get_own()) {
    25312718              Log(ERROR_LOG,LOG_NORMAL,state_manager::modname, "Another node has sent a message with the duplicated RII!!!");
    2532 //            send_response_with_rii(rcvd_rii, !down, local_sid, rcvd_mri, info_spec::transient, info_spec::RIIconflict);
    25332719              send_response_with_rii(rcvd_rii, local_sid, rcvd_mri, !down, info_spec::transient, info_spec::RIIconflict);
    25342720              check_it_again = false;
     
    28303016state_manager::error_t  state_manager::process_rsn_and_qspec(NSLP_Context* context, reservereq* reservemsg,
    28313017                                           rmf* rmf_admin, bool is_qni, bool is_qnr, bool& forw,
    2832                                            const ntlp::sessionid* local_sid, const ntlp::mri_pathcoupled* rcvd_mri,
     3018                                           const ntlp::sessionid* local_sid, const ntlp::mri *rcvd_mri,
    28333019                                           bool down)
    28343020{
     
    29483134            // no QSPEC. Send RESPONSE with RSN because this message must not be forwarded futher as one hop.
    29493135            Log(ERROR_LOG,LOG_NORMAL,state_manager::modname, "no qspec found!");
    2950 //          send_response_with_rsn(send_rsn, false, local_sid, rcvd_mri, info_spec::transient, info_spec::FullQSPECrequired);
    29513136            send_response_with_rsn(send_rsn, local_sid, rcvd_mri, false, info_spec::transient, info_spec::FullQSPECrequired);
    29523137        }
     
    29643149 * @return TRUE if the NSLP context for the given session id exists.
    29653150 */
    2966 bool state_manager::find_and_update_context(known_nslp_pdu* pdu, error_t& nslpres, bool down,
    2967                                    const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri,
    2968                                    ntlp::Flowstatus *fs)
     3151bool state_manager::find_and_update_context(known_nslp_pdu* pdu, error_t& nslpres, const ntlp::sessionid *rcvd_sid,
     3152                                  const ntlp::mri *rcvd_mri, bool down, ntlp::Flowstatus *fs)
    29693153{
    29703154    //=============================================== declare variables ===============================================
     3155    reservereq* reservemsg = dynamic_cast<reservereq *>(pdu);
     3156    assert(reservemsg != NULL);
     3157
    29713158    bool updated = false;
    2972     reservereq* reservemsg;
    29733159    bool forward = false;
    29743160    error_t function_res = error_ok;
     
    29763162    TimerMsg* rii_tmsg = NULL;
    29773163
     3164    const ntlp::mri_pathcoupled *rcvd_pc_mri=NULL;
     3165    ntlp::mri_explicitsigtarget fwd_est_mri;
     3166
     3167
     3168    if(rcvd_mri == NULL) {
     3169          ERRLog(state_manager::modname, "find_and_update_context() - rcvd_mri == NULL");
     3170          nslpres = error_nothing_to_do;
     3171          return false;
     3172    }
     3173 
     3174    if(rcvd_mri->get_mrm() == mri::mri_t_pathcoupled) {
     3175          rcvd_pc_mri = dynamic_cast<const ntlp::mri_pathcoupled *>(rcvd_mri);
     3176          assert(rcvd_pc_mri != NULL);
     3177    }
     3178    else if(rcvd_mri->get_mrm() == mri::mri_t_explicitsigtarget) {
     3179          const ntlp::mri_explicitsigtarget *rcvd_est_mri = dynamic_cast<const ntlp::mri_explicitsigtarget *>(rcvd_mri);
     3180          assert(rcvd_est_mri != NULL);
     3181 
     3182          rcvd_pc_mri  = &rcvd_est_mri->get_mri_pc();
     3183          down = rcvd_pc_mri->get_downstream();
     3184    }
     3185    else {
     3186          ERRLog(state_manager::modname, "find_and_update_context() - Unknown MRI with MRI-ID: " << rcvd_mri->get_mrm());
     3187          nslpres = error_nothing_to_do;
     3188          return false;
     3189    }
     3190 
     3191    // if RESERVE was received by the PC-MRM and has the Replace-bit set, delete NLSP_AHO_Context for this session
     3192    if((rcvd_mri->get_mrm() == mri::mri_t_pathcoupled) && (reservemsg->is_replace_flag())) {
     3193          // delete AHO_Context if existing
     3194          aho_contextmap.erase(*rcvd_sid);
     3195    }
     3196
     3197
    29783198    NSLP_Context* context = rcvd_sid ? contextmap.find(*rcvd_sid) : 0;
    29793199    bool i_am_originator = pdu->get_originator();
     
    29813201    // context is found, update it if necessary
    29823202    if (context) {
    2983       reservemsg = dynamic_cast<reservereq*>(pdu);
    29843203      NSLP_Context::qn_type_t type= NSLP_Context::QNE;
    29853204      // if this is not a replace, make sure the MRI is okay
     
    29913210                context->unlock();
    29923211
    2993                 if (my_mri->get_sourceaddress() != rcvd_mri->get_sourceaddress()) {
     3212                if (my_mri->get_sourceaddress() != rcvd_pc_mri->get_sourceaddress()) {
    29943213                        // if this isn't supposed to be a replace, drop it
    29953214                        nslpres = error_old_pdu;
    29963215                        return true;
    29973216                }
    2998                 if (my_mri->get_destaddress() != rcvd_mri->get_destaddress()) {
     3217                if (my_mri->get_destaddress() != rcvd_pc_mri->get_destaddress()) {
    29993218                        // if this isn't supposed to be a replace, drop it
    30003219                        nslpres = error_old_pdu;
     
    30113230
    30123231                if (mergingNode &&
    3013                     (my_mri->get_sourceaddress() != rcvd_mri->get_sourceaddress() ||
    3014                     my_mri->get_destaddress() != rcvd_mri->get_destaddress())) {
     3232                    (my_mri->get_sourceaddress() != rcvd_pc_mri->get_sourceaddress() ||
     3233                    my_mri->get_destaddress() != rcvd_pc_mri->get_destaddress())) {
    30153234                        ILog("QOS_STATEMODULE", "I'm CRN - sending NOTIFY");
    30163235                        context->lock();
     
    30423261      context->lock();
    30433262      context->set_qn_type(type);
    3044       context->set_mri(rcvd_mri);
     3263      context->set_mri(rcvd_pc_mri);
    30453264      context->unlock();
    30463265       
     
    30903309            Log(INFO_LOG,LOG_NORMAL,state_manager::modname,"TEAR-DOWN Flag set!");
    30913310            if (type != NSLP_Context::QNR) {
    3092                 forward_reserve(reservemsg, context, down, rcvd_mri);
     3311#ifdef USE_AHO
     3312                if((rcvd_mri->get_mrm() == mri::mri_t_pathcoupled) &&
     3313                        is_new_access_router_and_flow_matches(*rcvd_sid, *rcvd_pc_mri, fwd_est_mri)) {
     3314                        // forward RESERVE message towards the mobile node by means of the EST-MRM
     3315                        forward_reserve(reservemsg, context, &fwd_est_mri);
     3316                }
     3317                else {
     3318                        // forward RESERVE message by means of the PC-MRM
     3319                        forward_reserve(reservemsg, context, rcvd_pc_mri, down);
     3320                }
     3321#else
     3322                forward_reserve(reservemsg, context, rcvd_pc_mri, down);
     3323#endif
    30933324                nslpres = error_ok_forward;
    30943325            }
     
    31063337        if (send_rsn) {
    31073338            function_res = process_rsn_and_qspec(context, reservemsg, rmf_admin, i_am_originator, type == NSLP_Context::QNR,
    3108                                                  forward, rcvd_sid, rcvd_mri, down);
     3339                                                 forward, rcvd_sid, rcvd_pc_mri, down);
    31093340            if (function_res != error_ok) {
    31103341                nslpres = function_res;
     
    31143345              if (type != NSLP_Context::QNI) {
    31153346                if (rcvd_rii) {
    3116 //                send_response_with_rii(rcvd_rii, !down, rcvd_sid, rcvd_mri,
    31173347                  send_response_with_rii(rcvd_rii, rcvd_sid, rcvd_mri, !down,
    31183348                                         info_spec::transient,
     
    31253355                }
    31263356                else {
    3127 //                send_response_with_rsn(send_rsn, false, rcvd_sid, rcvd_mri,
    31283357                  send_response_with_rsn(send_rsn, rcvd_sid, rcvd_mri, false,
    31293358                                         info_spec::transient,
     
    31513380            nslpres = error_rsn_missing;
    31523381            if (rcvd_rii) {
    3153 //            send_response_with_rii(rcvd_rii, !down, rcvd_sid, rcvd_mri, info_spec::protocol, info_spec::MandatoryObjectMissing);
    31543382              send_response_with_rii(rcvd_rii, rcvd_sid, rcvd_mri, !down, info_spec::protocol, info_spec::MandatoryObjectMissing);
    31553383            }
     
    31623390        if (rcvd_rii) {
    31633391            rii_tmsg = new TimerMsg(message::qaddr_qos_nslp_timerprocessing);
    3164             function_res = process_rii(context, reservemsg, rcvd_sid, rii_tmsg, type == NSLP_Context::QNI, type == NSLP_Context::QNR, down, rcvd_mri);
     3392            function_res = process_rii(context, reservemsg, rcvd_sid, rii_tmsg, type == NSLP_Context::QNI, type == NSLP_Context::QNR, rcvd_pc_mri, down);
    31653393            if (function_res != error_ok) {
    31663394                nslpres = function_res;
     
    31683396            if (nslpres == error_ok_send_response) {
    31693397              if (type == NSLP_Context::QNR) {
    3170 //              send_response_with_rii(rcvd_rii, !down, rcvd_sid, rcvd_mri,
    31713398                send_response_with_rii(rcvd_rii, rcvd_sid, rcvd_mri, !down,
    31723399                                       info_spec::success,
     
    31843411                        ; //TODO: Not quite sure yet!
    31853412#else
    3186 //                send_response_with_rii(rcvd_rii, !down, rcvd_sid, rcvd_mri,
    31873413                  send_response_with_rii(rcvd_rii, rcvd_sid, rcvd_mri, !down,
    31883414                                         info_spec::success, info_spec::StateInstallationOK);
     
    32013427            if (type != NSLP_Context::QNI) {
    32023428                if (reservemsg->is_acknowledge_flag()) {
    3203 //               send_response_with_rsn(send_rsn, false, rcvd_sid, rcvd_mri, info_spec::success,
    32043429                 send_response_with_rsn(send_rsn, rcvd_sid, rcvd_mri, false, info_spec::success,
    32053430#ifdef QOS_NSLP_13
     
    32413466        {
    32423467          if ((i_am_originator)  || ( (!i_am_originator) && (type == NSLP_Context::QNE) && (!(reservemsg->is_scoping_flag())))) {
    3243                 forward_reserve(reservemsg, context, down, rcvd_mri);
     3468#ifdef USE_AHO
     3469                if((rcvd_mri->get_mrm() == mri::mri_t_pathcoupled) &&
     3470                        is_new_access_router_and_flow_matches(*rcvd_sid, *rcvd_pc_mri, fwd_est_mri)) {
     3471                        // forward RESERVE message towards the mobile node by means of the EST-MRM
     3472                        forward_reserve(reservemsg, context, &fwd_est_mri);
     3473                }
     3474                else {
     3475                        // forward RESERVE message by means of the PC-MRM
     3476                        forward_reserve(reservemsg, context, rcvd_pc_mri, down);
     3477                }
     3478#else
     3479                forward_reserve(reservemsg, context, rcvd_pc_mri, down);
     3480#endif
    32443481                // nslpres is still error_ok_forward
    32453482            }   
     
    33163553/** This function processes a received RESPONSE message.
    33173554 * @param known_pdu NSLP PDU to be processed.
    3318  * @param down set to TRUE, if the direction is downstream, otherwise set to FALSE.
    33193555 * @param rcvd_sid the session id the current message belongs to.
    33203556 * @param rcvd_mri the MRI of the current session.
     3557 * @param down set to TRUE, if the direction is downstream, otherwise set to FALSE. Only evaluated with PC-MRM.
    33213558 */
    3322 void state_manager::process_response_msg(known_nslp_pdu* known_pdu, bool down,
    3323                                 const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri)
     3559void state_manager::process_response_msg(known_nslp_pdu* known_pdu, const ntlp::sessionid* rcvd_sid, const ntlp::mri* rcvd_mri, bool down)
    33243560{
    3325         responsemsg* response = NULL;
     3561        responsemsg* response = dynamic_cast<responsemsg*>(known_pdu);
    33263562
    33273563        uint32 rii_number, response_rsn_number, local_rsn_number;
     
    33303566        rii* context_rii = NULL;
    33313567        bool found = false;
     3568       
     3569        const ntlp::mri_pathcoupled *rcvd_pc_mri=NULL;
     3570        ntlp::mri_explicitsigtarget fwd_est_mri;
    33323571
    33333572        ILog(state_manager::modname, "process_response_msg()");
    3334         response = dynamic_cast<responsemsg*>(known_pdu);
     3573
     3574
     3575        if(rcvd_mri == NULL) {
     3576                ERRLog(state_manager::modname, "process_response_msg() - rcvd_mri == NULL");
     3577                return;
     3578        }
     3579 
     3580        if(rcvd_mri->get_mrm() == mri::mri_t_pathcoupled) {
     3581                rcvd_pc_mri = dynamic_cast<const ntlp::mri_pathcoupled *>(rcvd_mri);
     3582                assert(rcvd_pc_mri != NULL);
     3583        }
     3584        else if(rcvd_mri->get_mrm() == mri::mri_t_explicitsigtarget) {
     3585                const ntlp::mri_explicitsigtarget *rcvd_est_mri = dynamic_cast<const ntlp::mri_explicitsigtarget *>(rcvd_mri);
     3586                assert(rcvd_est_mri != NULL);
     3587
     3588                rcvd_pc_mri  = &rcvd_est_mri->get_mri_pc();
     3589                down = rcvd_pc_mri->get_downstream();
     3590        }
     3591        else {
     3592                ERRLog(state_manager::modname, "process_response_msg() - Unknown MRI with MRI-ID: " << rcvd_mri->get_mrm());
     3593                return;
     3594        }
     3595
    33353596
    33363597        NSLP_Context* context = rcvd_sid ? contextmap.find(*rcvd_sid) : 0;
     
    33383599        // RESPONSE msg is not for me, forward it
    33393600        if (!context) {
    3340                 forward_response_msg(response, down, rcvd_mri, rcvd_sid);
     3601#ifdef USE_AHO
     3602                if((rcvd_mri->get_mrm() == mri::mri_t_pathcoupled) &&
     3603                                is_new_access_router_and_flow_matches(*rcvd_sid, *rcvd_pc_mri, fwd_est_mri)) {
     3604                        // forward RESPONSE message towards the mobile node by means of the EST-MRM
     3605                        forward_response_msg(response, rcvd_sid, &fwd_est_mri);
     3606                }
     3607                else {
     3608                        // forward RESPONSE message by means of the PC-MRM
     3609                        forward_response_msg(response, rcvd_sid, rcvd_pc_mri, down);
     3610                }
     3611#else
     3612                forward_response_msg(response, rcvd_sid, rcvd_pc_mri, down);
     3613#endif
    33413614                ILog(state_manager::modname, "END process_response_msg()");
    33423615                return;
     
    33923665                                        context->set_branchingNode(false);
    33933666                                        context->unlock();
    3394                                         send_reserve_with_tear_on_the_old_path(context, rcvd_sid, rcvd_mri, !down);
     3667                                        send_reserve_with_tear_on_the_old_path(context, rcvd_sid, rcvd_pc_mri, !down);
    33953668                                        return;
    33963669                                }
     
    34273700                                if (type == NSLP_Context::QNE) {
    34283701                                        ILog(state_manager::modname, "I am not the originator of RII: Forwarding it!");
    3429                                         forward_response_msg(response, down, rcvd_mri, rcvd_sid);
     3702#ifdef USE_AHO
     3703                                        if((rcvd_mri->get_mrm() == mri::mri_t_pathcoupled) &&
     3704                                                        is_new_access_router_and_flow_matches(*rcvd_sid, *rcvd_pc_mri, fwd_est_mri)) {
     3705                                                // forward RESPONSE message towards the mobile node by means of the EST-MRM
     3706                                                forward_response_msg(response, rcvd_sid, &fwd_est_mri);
     3707                                        }
     3708                                        else {
     3709                                                // forward RESPONSE message by means of the PC-MRM
     3710                                                forward_response_msg(response, rcvd_sid, rcvd_pc_mri, down);
     3711                                        }
     3712#else
     3713                                        forward_response_msg(response, rcvd_sid, rcvd_pc_mri, down);
     3714#endif
    34303715                                }
    34313716                        }
     
    34483733                        ILog(state_manager::modname, "Processing RESPONSE: RII " << rii_number << " NOT FOUND!");
    34493734                        // RESPONSE msg is not for me, forward it
    3450                         if (type == NSLP_Context::QNE)
    3451                                 forward_response_msg(response, down, rcvd_mri, rcvd_sid);
     3735                        if (type == NSLP_Context::QNE) {
     3736#ifdef USE_AHO
     3737                                if((rcvd_mri->get_mrm() == mri::mri_t_pathcoupled) &&
     3738                                                is_new_access_router_and_flow_matches(*rcvd_sid, *rcvd_pc_mri, fwd_est_mri)) {
     3739                                        // forward RESPONSE message towards the mobile node by means of the EST-MRM
     3740                                        forward_response_msg(response, rcvd_sid, &fwd_est_mri);
     3741                                }
     3742                                else {
     3743                                        // forward RESPONSE message by means of the PC-MRM
     3744                                        forward_response_msg(response, rcvd_sid, rcvd_pc_mri, down);
     3745                                }
     3746#else
     3747                                forward_response_msg(response, rcvd_sid, rcvd_pc_mri, down);
     3748#endif
     3749                        }
    34523750                }
    34533751
     
    34653763                                if ((er_class == info_spec::transient) && (er_code == info_spec::RIIconflict)) {
    34663764                                        erase_state = false;
    3467                                         retransmit_message(context, context_rii, false, rcvd_sid, rcvd_mri);
     3765                                        retransmit_message(context, context_rii, false, rcvd_sid, rcvd_pc_mri);
    34683766                                }
    34693767                        }
     
    35213819                                                        up_rsn->set(forward_rsn_number);
    35223820                                                        response->set_rsn(up_rsn);
    3523                                                         forward_response_msg(response, down, rcvd_mri, rcvd_sid);
     3821
     3822#ifdef USE_AHO
     3823                                                        if((rcvd_mri->get_mrm() == mri::mri_t_pathcoupled) &&
     3824                                                                        is_new_access_router_and_flow_matches(*rcvd_sid, *rcvd_pc_mri, fwd_est_mri)) {
     3825                                                                // forward RESPONSE message towards the mobile node by means of the EST-MRM
     3826                                                                forward_response_msg(response, rcvd_sid, &fwd_est_mri);
     3827                                                        }
     3828                                                        else {
     3829                                                                // forward RESPONSE message by means of the PC-MRM
     3830                                                                forward_response_msg(response, rcvd_sid, rcvd_pc_mri, down);
     3831                                                        }
     3832#else
     3833                                                        forward_response_msg(response, rcvd_sid, rcvd_pc_mri, down);
     3834#endif
    35243835                                                }
    35253836                                                //====================================================
     
    38744185        context->unlock();
    38754186
    3876         SignalingMsg* sigmsg = new SignalingMsg();
    3877         sigmsg->set_msg(pdu);
    3878         sigmsg->set_sig_mri(rcvd_mri);
    3879         sigmsg->set_sid(*rcvd_sid);
    3880         sigmsg->set_downstream(down);
    3881         sigmsg->set_sii_handle(old_sii);
    3882         sigmsg->set_allow_translate(false);
    3883         sigmsg->send_or_delete();
    3884 
    3885         context->lock();
    3886         ntlp::mri_pathcoupled *old_mri = context->get_old_mri();
    3887         context->unlock();
    3888         if (!old_mri || old_mri->get_sourceaddress() != rcvd_mri->get_sourceaddress() ||
    3889             old_mri->get_destaddress() != rcvd_mri->get_destaddress())
    3890                 return;
    3891 
    3892         sigmsg = new SignalingMsg();
    3893         sigmsg->set_sig_mri(old_mri);
    3894         sigmsg->set_msg(0);
    3895         sigmsg->set_downstream(true);
    3896         sigmsg->set_invalidate(true);
    3897         sigmsg->send_or_delete();
    3898 
    3899         sigmsg = new SignalingMsg();
    3900         sigmsg->set_sig_mri(old_mri);
    3901         sigmsg->set_msg(0);
    3902         sigmsg->set_downstream(true);
    3903         sigmsg->set_invalidate(true);
    3904         sigmsg->send_or_delete();
     4187        if(old_sii != 0) {
     4188                SignalingMsg* sigmsg = new SignalingMsg();
     4189                sigmsg->set_msg(pdu);
     4190                sigmsg->set_sig_mri(rcvd_mri);
     4191                sigmsg->set_sid(*rcvd_sid);
     4192                sigmsg->set_downstream(down);
     4193                sigmsg->set_sii_handle(old_sii);
     4194                sigmsg->set_allow_translate(false);
     4195                sigmsg->send_or_delete();
     4196       
     4197                context->lock();
     4198                ntlp::mri_pathcoupled *old_mri = context->get_old_mri();
     4199                context->unlock();
     4200                // XXX: Is this correct? Are the last two checks not exactly the conditions for
     4201                // invalidating the routing state?
     4202                if (!old_mri || old_mri->get_sourceaddress() != rcvd_mri->get_sourceaddress() ||
     4203                    old_mri->get_destaddress() != rcvd_mri->get_destaddress())
     4204                        return;
     4205       
     4206                sigmsg = new SignalingMsg();
     4207                sigmsg->set_sig_mri(old_mri);
     4208                sigmsg->set_msg(0);
     4209                sigmsg->set_downstream(true);
     4210                sigmsg->set_invalidate(true);
     4211                sigmsg->send_or_delete();
     4212       
     4213                sigmsg = new SignalingMsg();
     4214                sigmsg->set_sig_mri(old_mri);
     4215                sigmsg->set_msg(0);
     4216                sigmsg->set_downstream(true);
     4217                sigmsg->set_invalidate(true);
     4218                sigmsg->send_or_delete();
     4219        }
    39054220}
    39064221
     
    39494264 * @param rcvd_mri the MRI of the current session.
    39504265 */
    3951 void state_manager::forward_response_msg(responsemsg* response, bool down, const ntlp::mri_pathcoupled* rcvd_mri, const sessionid* sid)
    3952 {
     4266void state_manager::forward_response_msg(responsemsg* response, const ntlp::sessionid* sid, const ntlp::mri* fwd_mri, bool down) {
    39534267        DLog(state_manager::modname, "forward_response_msg() ... I am a QNE");
    39544268        uint32 n;
    3955         responsemsg* res;
     4269        responsemsg* res = new responsemsg();
    39564270        known_nslp_pdu* pdu = NULL;
    3957 
    3958         res = new responsemsg();   
     4271       
     4272       
     4273        if(fwd_mri == NULL) {
     4274                ERRLog(state_manager::modname, "forward_response_msg() - fwd_mri == NULL");
     4275                return;
     4276        }
     4277
     4278
    39594279        rsn* r = response->get_rsn();
    3960 
    39614280        if (r) {
    39624281                r->get(n);
     
    39794298       
    39804299        pdu = dynamic_cast<known_nslp_pdu*>(res);
    3981         SignalingMsg* sigmsg = new SignalingMsg();
    3982         sigmsg->set_msg(pdu);
    3983         sigmsg->set_sig_mri(rcvd_mri);
    3984         sigmsg->set_sid(*sid);
    3985         sigmsg->set_downstream(down);
    3986         sigmsg->send_or_delete();
     4300       
     4301        if(fwd_mri->get_mrm() == mri::mri_t_pathcoupled) {
     4302                const ntlp::mri_pathcoupled* pc_mri = dynamic_cast<const ntlp::mri_pathcoupled *>(fwd_mri);
     4303                assert(pc_mri != NULL);
     4304
     4305                SignalingMsg* sigmsg = new SignalingMsg();
     4306                sigmsg->set_msg(pdu);
     4307                sigmsg->set_sig_mri(pc_mri);
     4308                sigmsg->set_sid(*sid);
     4309                sigmsg->set_downstream(down);
     4310                sigmsg->send_or_delete();
     4311        }
     4312        else if(fwd_mri->get_mrm() == mri::mri_t_explicitsigtarget) {
     4313                const ntlp::mri_explicitsigtarget *est_mri = dynamic_cast<const ntlp::mri_explicitsigtarget *>(fwd_mri);
     4314                assert(est_mri != NULL);
     4315
     4316                ExplicitSignalingMsg *sigmsg = new ExplicitSignalingMsg();
     4317                sigmsg->set_pdu(pdu);
     4318                sigmsg->set_sig_mri(est_mri);
     4319                sigmsg->set_sid(*sid);
     4320                sigmsg->send_or_delete();
     4321        }
     4322        else {
     4323                ERRLog(state_manager::modname, "forward_response_msg() - Unknown MRI with MRI-ID: " << fwd_mri->get_mrm());
     4324                return;
     4325        }
     4326       
     4327        DLog(state_manager::modname,"END forward_response_msg()");
    39874328}
    39884329
     
    46785019        known_nslp_pdu *pdu;
    46795020        rii *rii_obj;
     5021        rsn *rsn_obj;
    46805022        bool is_flow_sender;
    46815023        bool is_flow_receiver;
     
    47245066                        rii_obj->set_is_reserve(true);
    47255067
    4726                         create_reserve_message_from_context(context, res, rii_obj);
     5068                        // generate new rsn object
     5069                        rsn_obj = new rsn();
     5070                        rsn_obj->generate_new();
     5071
     5072                        create_reserve_message_from_context(context, res, rsn_obj, rii_obj);
    47275073                        res->set_proxy_flag();
    47285074               
     
    47455091
    47465092                assert(pdu != NULL);
     5093
     5094
     5095                // check whether a QSPEC object was found in the pdu an thereby in the context also
     5096                qspec_object *qspec_obj = pdu->get_qspec();
     5097                if(qspec_obj == NULL) {
     5098                        ILog(state_manager::modname, "No QSPEC found in context, AHO cannot proceed!");
     5099                        return;
     5100                }
    47475101
    47485102
     
    47735127                if(qn_type == NSLP_Context::QNI) {
    47745128                        // save RII object to match RESPONSE message
    4775                         aho_context->set_rii(*rii_obj);
    4776                 }
     5129                        aho_context->set_rii(rii_obj);
     5130                        // save RSN object
     5131                        aho_context->set_own_rsn(*rsn_obj);
     5132                }
     5133                // save QSPEC in NSLP_AHO_Context
     5134                aho_context->set_qspec_anticipated_reservation(qspec_obj);
    47775135                aho_context->unlock();
    47785136
     
    48835241                                                << ") for Reservation with SID [" << sid.to_string() << "]");
    48845242       
    4885                                 activate_or_create_new_reservation_with_phase3(context, &sid, pc_mri, qn_type, *l3_mn, is_flow_sender, is_flow_receiver);
     5243                                activate_or_create_new_reservation_with_phase3(context, &sid, pc_mri, qn_type, *l3_mn, is_flow_sender, is_flow_receiver, true);
    48865244
    48875245                                // delete AHO_Context
     
    49075265
    49085266                        if(is_flow_sender) {
    4909                                 activate_or_create_new_reservation_with_phase3(context, &sid, pc_mri, qn_type, *l3_mn, is_flow_sender, is_flow_receiver);
     5267                                activate_or_create_new_reservation_with_phase3(context, &sid, pc_mri, qn_type, *l3_mn, is_flow_sender, is_flow_receiver, false);
    49105268
    49115269                                // delete AHO_Context if existing
     
    49675325
    49685326void 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)
     5327        NSLP_Context::qn_type_t qn_type, const hostaddress &l3_mn, bool is_flow_sender, bool is_flow_receiver, bool anticipated_handover)
    49705328{
    49715329        known_nslp_pdu *pdu;
     
    49815339                        // create RESERVE message
    49825340                        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);
     5341
     5342                        // RSN
     5343                        rsn *rsn_obj = NULL;
     5344                        if(anticipated_handover) {
     5345                                NSLP_AHO_Context *aho_context = aho_contextmap.find(*sid);
     5346                                if(aho_context != NULL) {
     5347                                        uint32 r;
     5348                                        aho_context->lock();
     5349                                        aho_context->get_own_rsn().get(r);
     5350                                        r++;
     5351                                        rsn_obj = new rsn(r);
     5352                                        aho_context->unlock();
     5353                                }
     5354                                else {
     5355                                        ERRLog(state_manager::modname, "No NSLP_AHO_Context found for Reservation with SID [" << sid->to_string() << "]");
     5356                                        return;
     5357                                }
     5358                        }
     5359                        else {
     5360                                rsn_obj = new rsn();
     5361                                rsn_obj->generate_new();
     5362                        }
     5363       
     5364                        // TODO create RESERVE from NSLP_AHO_Context!!
     5365                        create_reserve_message_from_context(context, res, rsn_obj, NULL);
     5366                        res->set_originator(true);
    49915367                        res->set_replace_flag();
    49925368               
     
    49975373                        querymsg* query = new querymsg();
    49985374       
     5375                        // TODO create QUERY from NSLP_AHO_Context!!
    49995376                        create_query_message_from_context(context, query);
    50005377                        query->set_reserve_init_flag();
     
    50335410
    50345411
    5035 /* if the current node is the new access router in the context of an
    5036  * anticipated handover an incoming RESERVE / RESPONSE message needs to be
    5037  * forwarded to the mobile node, which is accomplished by this function.
    5038  * @param known_pdu PDU of the incoming RESERVE / RESPONSE message.
    5039  * @param rcvd_sid the session id the message belongs to.
    5040  * @param rcvd_mri the MRI for which signaling takes place.
     5412/* This function looks in the NSLP_AHO_Context if the current node is the new
     5413 * access router for the given session. If then the flow in the context matches
     5414 * also the given flow, TRUE is returned together with an EST-MRI which allows
     5415 * to forward messages towards the mobile node.
     5416 * @param sid the session id used to search the corresponding NSLP_AHO_Context.
     5417 * @param rcvd_mri the MRI of the received message which possibly should be forwarded.
     5418 * @param fwd_mri if TRUE is returned, this references a valid EST-MRI which is used to forward messages towards the mobile node.
    50415419 */
    5042 void state_manager::forward_message_if_new_access_router(known_nslp_pdu* known_pdu, const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri) {
     5420bool state_manager::is_new_access_router_and_flow_matches(const ntlp::sessionid &sid, const ntlp::mri_pathcoupled &rcvd_mri,
     5421                ntlp::mri_explicitsigtarget &fwd_mri)
     5422{
     5423        DLog(state_manager::modname, "is_new_access_router_and_flow_matches()");
     5424
     5425        bool ret=false;
     5426
     5427        ntlp::mri_pathcoupled pc_mri = rcvd_mri;
     5428        // invert direction for comparison
     5429        pc_mri.invertDirection();
     5430
    50435431        // determine node role within AHO
    50445432        NSLP_AHO_Context::node_role_t role = NSLP_AHO_Context::OTHER;
    5045         hostaddress ar_n, mn;
    5046         ntlp::mri_pathcoupled mri_new_flow;
    5047         NSLP_AHO_Context *aho_context = aho_contextmap.find(*rcvd_sid);
     5433        NSLP_AHO_Context *aho_context = aho_contextmap.find(sid);
    50485434        if(aho_context != NULL) {
    50495435                aho_context->lock();
    50505436                role = aho_context->get_aho_node_role();
    50515437                if(role == NSLP_AHO_Context::ARN) {
    5052                         ar_n = aho_context->get_addr_new_access_router();
    5053                         mn = aho_context->get_addr_mobile_node();
    5054                         mri_new_flow = aho_context->get_mri_new_flow();
     5438                        const hostaddress ar_n = aho_context->get_addr_new_access_router();
     5439                        const hostaddress mn = aho_context->get_addr_mobile_node();
     5440                        const ntlp::mri_pathcoupled mri_new_flow = aho_context->get_mri_new_flow();
     5441
     5442                        if(pc_mri == mri_new_flow) {
     5443                                // fill EST-MRI
     5444                                fwd_mri.set_origin_sig_address(ar_n);
     5445                                fwd_mri.set_dest_sig_address(mn);
     5446                                fwd_mri.set_mri_pc(rcvd_mri);
     5447
     5448                                ret = true;
     5449                        }
    50555450                }
    50565451                aho_context->unlock();
    50575452        }
    50585453
    5059         if(role == NSLP_AHO_Context::ARN && (*rcvd_mri == mri_new_flow)) {
    5060                 // forward message towards the mobile node
    5061                 const hostaddress orig_sig_addr = ar_n;
    5062                 const hostaddress dest_sig_addr = mn;
    5063                 mri_explicitsigtarget *est_mri = new mri_explicitsigtarget(*rcvd_mri, orig_sig_addr, dest_sig_addr);
    5064 
    5065                 ExplicitSignalingMsg* sigmsg = new ExplicitSignalingMsg();
    5066                 sigmsg->set_pdu(known_pdu);
    5067                 sigmsg->set_sid(*rcvd_sid);
    5068                 sigmsg->set_sig_mri(est_mri);
    5069                 sigmsg->send_or_delete();
    5070         }
     5454        DLog(state_manager::modname, "END is_new_access_router_and_flow_matches()");
     5455
     5456        return ret;
     5457}
     5458
     5459
     5460/* This function looks in the NSLP_AHO_Context if the current node is the new
     5461 * access router for the given session. If then the flow in the context matches
     5462 * the given flow and is_resv_init is TRUE, a RESERVE message is created from
     5463 * the NSLP_AHO_Context and send upstream.
     5464 * @param sid the session id used to search the corresponding NSLP_AHO_Context.
     5465 * @param rcvd_mri the MRI of the received QUERY message which possibly must be answered.
     5466 * @param is_resv_init TRUE if the received QUERY message has the Reserve-Init-Bit set.
     5467 * @return TRUE if role of the current node is ARN and the flow in the NSLP_AHO_Context
     5468 *         matches the received rcvd_mri and is_resv_init is TRUE.
     5469 */
     5470bool state_manager::if_new_access_router_send_reserve_msg_as_response_to_query(const ntlp::sessionid &sid, const ntlp::mri_pathcoupled &rcvd_mri, bool is_resv_init) {
     5471        bool ret = false;
     5472
     5473        ntlp::mri_pathcoupled pc_mri = rcvd_mri;
     5474        // invert direction for comparison
     5475        pc_mri.invertDirection();
     5476
     5477        if(is_resv_init) {
     5478                // determine node role within AHO
     5479                NSLP_AHO_Context::node_role_t role = NSLP_AHO_Context::OTHER;
     5480                NSLP_AHO_Context *aho_context = aho_contextmap.find(sid);
     5481                if(aho_context != NULL) {
     5482                        aho_context->lock();
     5483                        role = aho_context->get_aho_node_role();
     5484                        if(role == NSLP_AHO_Context::ARN) {
     5485                                const hostaddress ar_n = aho_context->get_addr_new_access_router();
     5486                                const hostaddress mn = aho_context->get_addr_mobile_node();
     5487                                const ntlp::mri_pathcoupled mri_new_flow = aho_context->get_mri_new_flow();
     5488
     5489                                rsn send_rsn = aho_context->get_predecessor_rsn();
     5490                                const rii *rii_obj = aho_context->get_rii();
     5491                                rii *send_rii = NULL;
     5492                                const rp *rp_obj = aho_context->get_refresh_period();
     5493                                rp *send_refresh_period = NULL;
     5494                                const bound_sessionid *bs_obj = aho_context->get_bound_sessionid();
     5495                                bound_sessionid *send_b_sid = NULL;
     5496                                qspec_object* send_qspec = aho_context->get_qspec_anticipated_reservation();
     5497
     5498       
     5499                                if(pc_mri == mri_new_flow) {
     5500                                        // create an EST-MRI which causes correct delivery of RESPONSE
     5501                                        // messages during processing of the created RESERVE message.
     5502                                        ntlp::mri_explicitsigtarget est_mri(mri_new_flow, mn, ar_n);
     5503
     5504                                        // create RESERVE message
     5505                                        reservereq *reserve = new reservereq();
     5506                                        reserve->set_rsn(&send_rsn);
     5507
     5508                                        if(rii_obj != NULL) {
     5509                                                send_rii = rii_obj->copy();
     5510                                                reserve->set_rii(send_rii);
     5511                                        }
     5512
     5513                                        if(rp_obj != NULL) {
     5514                                                send_refresh_period = rp_obj->copy();
     5515                                                reserve->set_rp(send_refresh_period);
     5516                                        }
     5517
     5518                                        if(bs_obj != NULL) {
     5519                                                send_b_sid = bs_obj->copy();
     5520                                                reserve->set_bound_sid(send_b_sid);
     5521                                        }
     5522
     5523                                        if(send_qspec != NULL) {
     5524                                                reserve->set_qspec(send_qspec);
     5525                                        }
     5526
     5527
     5528                                        // process created RESERVE message
     5529                                        error_t nslpres = error_ok;
     5530                                        bool updated = find_and_update_context(reserve, nslpres, &sid, &est_mri, false, NULL);
     5531                                        if(!updated) {
     5532                                                create_new_context(*reserve, nslpres, &sid, &est_mri, false, NULL);
     5533                                        }
     5534       
     5535                                        switch (nslpres) {
     5536                                        case state_manager::error_old_pdu:
     5537                                        case state_manager::error_rsn_missing:
     5538                                        case state_manager::error_no_bandwidth:
     5539                                                DLog(state_manager::modname, "if_new_access_router...() - processing    of RESERVE msg returned an error: "
     5540                                                                << error_string(nslpres));
     5541                                                break;
     5542                                        case state_manager::error_nothing_to_do:
     5543                                        case state_manager::error_ok_forward:
     5544                                        case state_manager::error_ok_send_response:
     5545                                        case state_manager::error_ok:
     5546                                                break;
     5547                                        default:
     5548                                                ERRLog(state_manager::modname, "Received an NSLP error (#"
     5549                                                                << nslpres << ':' << state_manager::error_string(nslpres) << ") that cannot be handled.");
     5550                                                break;
     5551                                        }
     5552
     5553                                        if(reserve != NULL) {
     5554                                                delete reserve;
     5555                                        }
     5556       
     5557                                        ret = true;
     5558                                }
     5559
     5560                                if(send_rii != NULL) {
     5561                                        delete send_rii;
     5562                                }
     5563
     5564                                if(send_refresh_period != NULL) {
     5565                                        delete send_rii;
     5566                                }
     5567
     5568                                if(send_b_sid != NULL) {
     5569                                        delete send_rii;
     5570                                }
     5571                        }
     5572                        aho_context->unlock();
     5573                }
     5574        }
     5575
     5576        return ret;
    50715577}
    50725578#endif // USE_AHO
     
    50765582 * @param context the NSLP Context.
    50775583 * @param res the RESERVE message.
    5078  * @param rii RII object to use in RESERVE message, NULL if none.
     5584 * @param send_rsn RSN object to use in RESERVE message.
     5585 * @param send_rii RII object to use in RESERVE message, NULL if none.
    50795586 */
    50805587// TODO: which QSPEC to choose, after modifying context to allow multiple concurrent flows within a session
    5081 void state_manager::create_reserve_message_from_context(NSLP_Context *context, reservereq *res, rii *send_rii) {
     5588void state_manager::create_reserve_message_from_context(NSLP_Context *context, reservereq *res, rsn *send_rsn, rii *send_rii) {
    50825589        uint32 n32;
    50835590        uint128 n128;
    50845591        bool found;
    50855592
    5086         rsn *send_rsn = NULL;
    50875593        rp *send_refresh_period = NULL;
    50885594        bound_sessionid *send_b_sid = NULL;
     
    50935599        assert(res != NULL);
    50945600       
    5095         // TODO:
    5096         // * only lock once
    5097 
    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) {
    5103                 res->set_originator(true);
    5104 //      }
     5601        // TODO only lock once
    51055602
    51065603        // RSN
    5107         context->lock();
    5108         context->get_rsn_own(n32);
    5109         context->unlock();
    5110         send_rsn = new rsn(n32);
    5111         res->set_rsn(send_rsn);
     5604        if(send_rsn != NULL) {
     5605                res->set_rsn(send_rsn);
     5606        }
    51125607
    51135608        // RII
  • qos-nslp/branches/20090610-qos-nslp-aho/src/nslp_aho_context.cpp

    r4567 r4592  
    1313
    1414
    15 NSLP_AHO_Context::NSLP_AHO_Context() : node_role(NSLP_AHO_Context::OTHER), anticipated_reservation_successful(false), predecessor_rsn(0)
     15NSLP_AHO_Context::NSLP_AHO_Context() : node_role(NSLP_AHO_Context::OTHER), anticipated_reservation_successful(false), predecessor_rsn(0), own_rsn(0)
    1616{
    1717  pthread_mutexattr_init(&mutex_attr);
     
    2727  rii_obj = NULL;
    2828  qspec_obj = NULL;
     29  refresh_period = NULL;
     30  bs = NULL;
    2931} // end constructor
    3032
     
    4648  if(qspec_obj != NULL) {
    4749    delete qspec_obj;
     50  }
     51
     52  if(refresh_period != NULL) {
     53    delete refresh_period;
     54  }
     55
     56  if(bs != NULL) {
     57    delete bs;
    4858  }
    4959}
     
    130140  * @param the sent RII object.
    131141  */
    132 void NSLP_AHO_Context::set_rii(const rii &rii_obj) {
    133   this->rii_obj = rii_obj.copy();
     142void NSLP_AHO_Context::set_rii(const rii *rii_obj) {
     143  if(rii_obj != NULL) {
     144    this->rii_obj = rii_obj->copy();
     145  }
    134146}
    135147
     
    140152  * @return the previously sent RII object.
    141153  */
    142 const rii &NSLP_AHO_Context::get_rii() const {
    143   return *rii_obj;
     154const rii *NSLP_AHO_Context::get_rii() const {
     155  return rii_obj;
    144156}
    145157
     
    163175
    164176
    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.
     177/** This function is used by the mobile node in case it is QNR, and sets the RSN
     178  * of the predecessor to process incoming RESERVE messages. It is also used by
     179  * the new access router in case the mobile node is QNI and flow receiver.
    167180  * @param the new RSN to save in context.
    168181  */
     
    186199  */
    187200void NSLP_AHO_Context::set_qspec_anticipated_reservation(qspec_object *qspec_obj) {
    188   assert(qspec_obj != NULL);
    189   this->qspec_obj = qspec_obj->copy();
     201  if(qspec_obj != NULL) {
     202    this->qspec_obj = qspec_obj->copy();
     203  }
    190204}
    191205
     
    199213}
    200214
     215
     216/** This function is used by the mobile node in case it is QNI, and sets his own
     217  * RSN.
     218  * @param the new RSN to save in context.
     219  */
     220void NSLP_AHO_Context::set_own_rsn(const rsn &own_rsn) {
     221  this->own_rsn = own_rsn;
     222}
     223
     224
     225/** This function is used by the mobile node in case it is QNI, and returns the
     226  * RSN saved in the context.
     227  * @return the saved RSN.
     228  */
     229const rsn &NSLP_AHO_Context::get_own_rsn() const {
     230  return own_rsn;
     231}
     232
     233
     234/** This function is used by the new access router in case it is QNI and flow
     235  * receiver, and saves the refresh period of a reservation in the context.
     236  * @param the refresh period to save in the context.
     237  */
     238void NSLP_AHO_Context::set_refresh_period(const rp *refresh_period) {
     239  if(refresh_period != NULL) {
     240    this->refresh_period = refresh_period->copy();
     241  }
     242}
     243
     244
     245/** This function is used by the new access router in case it is QNI and flow
     246  * receiver, and returns the refresh period of a reservation saved in the
     247  * context.
     248  * @return the refresh period saved in the context.
     249  */
     250const rp *NSLP_AHO_Context::get_refresh_period() const {
     251  return refresh_period;
     252}
     253
     254
     255/** This function is used by the new access router in case it is QNI and flow
     256  * receiver, and saves the id of a bound session in the context.
     257  * @param the id of a bound session to save in the context.
     258  */
     259void NSLP_AHO_Context::set_bound_sessionid(const bound_sessionid *bs) {
     260  if(bs != NULL) {
     261    this->bs = bs->copy();
     262  }
     263}
     264
     265
     266/** This function is used by the new access router in case it is QNI and flow
     267  * receiver, and saves the id of a bound session in the context.
     268  * @return the id of a bound session to save in the context.
     269  */
     270const bound_sessionid *NSLP_AHO_Context::get_bound_sessionid() const {
     271  return bs;
     272}
     273
    201274} // end namespace qos_nslp
    202275
  • qos-nslp/branches/20090610-qos-nslp-aho/src/nslp_pdu.cpp

    r3489 r4592  
    403403  nslp_pdu::nslp_pdu(bool known, uint8 t, const char *const name, uint8 s_f, uint16 g_f)
    404404  : NSLP_IE(known?(NSLP_IE::cat_known_nslp_pdu):(NSLP_IE::cat_unknown_nslp_pdu)),
    405     type(t), name(name), specific_flags(s_f), generic_flags(g_f) 
     405    type(t), name(name), specific_flags(s_f), generic_flags(g_f)
    406406{
    407407        switch (type) {
Note: See TracChangeset for help on using the changeset viewer.