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

Changeset 4546


Ignore:
Timestamp:
Oct 14, 2009, 1:50:19 AM (8 years ago)
Author:
stud-dettling
Message:
  • Updated NSLP_AHO_Context
  • Further implemented AHO phase 2 / 2a
  • Implemented InitReserve? in phase 2a of AHO
  • Added sematic for non-standard X-Flag to QUERY-Messages
  • Refactored method process_aho_event
  • Corrected AHO phase 3
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

    r4525 r4546  
    113113  void create_and_send_reserve_msg_as_response_to_query(bool send_rii, qspec_object* q, const bound_sessionid* b,
    114114                                                        bool down, const ntlp::sessionid* sid, const ntlp::mri_pathcoupled* rcvd_mri,
    115                                                         NSLP_Context *context);
     115                                                        NSLP_Context *context, bool replace=true);
    116116  void forward_query_msg(querymsg* q, bool down, const ntlp::sessionid* sid, const ntlp::mri_pathcoupled* rcvd_mri);
    117117  void notify_application(NSLP_Context* context, QoS_Appl_Msg::qos_info_type_t info, const ntlp::sessionid* rcvd_sid);
     
    137137  void aho_phase_1(NSLP_Context* context, void *param1, void *param2);
    138138  void ho_phase_3_2a(NSLP_Context* context, void *param1, void *param2);
     139  void forward_message_if_new_access_router(known_nslp_pdu* known_pdu, const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri);
    139140#endif
    140141  void create_reserve_message_from_context(NSLP_Context *context, reservereq *res, rii *send_rii=NULL);
  • qos-nslp/branches/20090610-qos-nslp-aho/include/nslp_aho_context.h

    r4540 r4546  
    99#include "llhashers.h"
    1010#include "address.h"
     11#include "mri_pc.h"
     12#include "rii.h"
    1113
    1214
     
    5052  bool get_is_flow_receiver() const;
    5153
     54  void set_mri_new_flow(const ntlp::mri_pathcoupled &mri);
     55  const ntlp::mri_pathcoupled &get_mri_new_flow() const;
     56
     57  void set_rii(const rii &rii_obj);
     58  const rii &get_rii() const;
     59
     60  void set_anticipated_reservation_success(bool success);
     61  bool get_anticipated_reservation_success() const;
     62
    5263  /// lock mutex
    5364  void lock();
     
    6980  bool is_flow_sender;
    7081  bool is_flow_receiver;
     82  ntlp::mri_pathcoupled* mri_new_flow;
     83  rii *rii_obj;
     84  bool anticipated_reservation_successful;
    7185
    7286  /// This mutex is used to lock the NSLP_AHO_Context
  • qos-nslp/branches/20090610-qos-nslp-aho/src/QoS_StateModule.cpp

    r4543 r4546  
    198198        // check for incoming reserve message
    199199        if (known_pdu->is_reserve()) {
     200#ifdef USE_AHO
     201                forward_message_if_new_access_router(known_pdu, sid, rcvd_mri);
     202#endif
    200203                bool updated = find_and_update_context(known_pdu, nslpres, down, sid, rcvd_mri, NULL);
    201204                if (!updated)
     
    217220
    218221        if (known_pdu->is_response()) {
     222#ifdef USE_AHO
     223                forward_message_if_new_access_router(known_pdu, sid, rcvd_mri);
     224#endif
    219225                process_response_msg(known_pdu, down, sid, rcvd_mri);
    220226                resultpdu = known_pdu;
     
    258264                                  const ntlp::mri_explicitsigtarget* rcvd_mri)
    259265{
    260         // TODO: error checking with appropriate return values!!
    261 
    262266        // initialize result variables
    263267        resultpdu = NULL;
    264 //      error_t nslpres;
    265 //      nslpres = error_ok;
    266268
    267269        // parse NetMsg
     
    294296                        // save address of mobile node MN
    295297                        aho_context->set_addr_mobile_node(rcvd_mri->get_origin_sig_address());
     298                        // save address of new access router ARN
     299                        aho_context->set_addr_new_access_router(rcvd_mri->get_dest_sig_address());
     300                        // save mri of the new flow in AHO_Context
     301                        aho_context->set_mri_new_flow(rcvd_mri->get_mri_pc());
    296302                        aho_context->unlock();
    297303
     
    317323                }
    318324
    319                 /*
    320                 switch(role) {
    321                 case NSLP_AHO_Context::MN:
    322                         DLog(state_manager::modname, "Node Role: MN");
    323                         break;
    324                 case NSLP_AHO_Context::ARN:
    325                         DLog(state_manager::modname, "Node Role: ARN, address of MN is " << aho_context->get_addr_mobile_node());
    326                         break;
    327                 case NSLP_AHO_Context::CN:
    328                         DLog(state_manager::modname, "Node Role: CN");
    329                         break;
    330                 case NSLP_AHO_Context::OTHER:
    331                         DLog(state_manager::modname, "Node Role: OTHER");
    332                         break;
    333                 }
    334                 */
    335 
    336325
    337326                // proceed with anticipated handover
     
    399388        if (known_pdu->is_response()) {
    400389                DLog(state_manager::modname, color[blue] << "Received RESPONSE-AHO message by the EST-MRM." << color[off]);
     390
     391                responsemsg* resp = dynamic_cast<responsemsg*>(known_pdu);
     392                assert(resp != NULL);
     393
     394                mri_pathcoupled pc_mri = rcvd_mri->get_mri_pc();
     395
     396                // determine node role within AHO
     397                NSLP_AHO_Context::node_role_t role = NSLP_AHO_Context::OTHER;
     398                ntlp::mri_pathcoupled mri_new_flow;
     399                rii *context_rii = NULL;
     400                NSLP_AHO_Context *aho_context = aho_contextmap.find(*sid);
     401                if(aho_context != NULL) {
     402                        aho_context->lock();
     403                        role = aho_context->get_aho_node_role();
     404                        mri_new_flow = aho_context->get_mri_new_flow();
     405                        if(role == NSLP_AHO_Context::MN) {
     406                                context_rii = aho_context->get_rii().copy();
     407                        }
     408                        aho_context->unlock();
     409                }
     410       
     411                if(role == NSLP_AHO_Context::MN) {
     412                        if(pc_mri == mri_new_flow) {
     413                                rii *resp_rii = resp->get_rii();
     414                                if(resp_rii != NULL) {
     415                                        if((*context_rii) != (*resp_rii)) {
     416                                                ILog(state_manager::modname, "Received RESPONSE-AHO message, but RII object doesn't match.");
     417                                                return error_nothing_to_do;
     418                                        }
     419
     420                                        info_spec* err_obj = resp->get_errorobject();
     421                                        if(err_obj != NULL) {
     422                                                info_spec::errorclass_t err_class = (info_spec::errorclass_t) err_obj->get_errorclass();
     423                                                info_spec::errorcode_t err_code = (info_spec::errorcode_t) err_obj->get_errorcode();
     424
     425                                                if((err_class == info_spec::success) &&
     426                                                   ((err_code == info_spec::ReservationSuccessful) || (err_code == info_spec::RefreshSuccessful))) {
     427                                                        if(aho_context != NULL) {
     428                                                                aho_context->lock();
     429                                                                aho_context->set_anticipated_reservation_success(true);
     430                                                                aho_context->unlock();
     431                                                        }
     432                                                }
     433                                        }
     434                                        else {
     435                                                ILog(state_manager::modname, "Missing mandatory INFO_SPEC object in RESPONSE-AHO message.");
     436                                                return error_nothing_to_do;
     437                                        }
     438                                }
     439                                else {
     440                                        ILog(state_manager::modname, "Received RESPONSE-AHO message w/o RII object, but RII was expected.");
     441                                        return error_nothing_to_do;
     442                                }
     443                        }
     444                }
     445
     446                if(role == NSLP_AHO_Context::ARN) {
     447                        //
     448                }
     449
    401450                return error_nothing_to_do;
    402451        }
     
    418467                // save address of mobile node MN
    419468                aho_context->set_addr_mobile_node(rcvd_mri->get_origin_sig_address());
     469                // save address of new access router ARN
     470                aho_context->set_addr_new_access_router(rcvd_mri->get_dest_sig_address());
     471                // save mri of the new flow in AHO_Context
     472                aho_context->set_mri_new_flow(rcvd_mri->get_mri_pc());
    420473                aho_context->unlock();
    421474
     
    424477
    425478               
    426                 // we are ARN and start with AHO phase 2 / 2a
     479                // we are ARN and start with AHO phase 2a
    427480                mri_pathcoupled pc_mri = rcvd_mri->get_mri_pc();
    428481                bool down = pc_mri.get_downstream();
     
    431484                        // downstream
    432485
    433                         // TODO: send QUERY downstream
     486                        // send QUERY message with PC-MRM
     487                        SignalingMsg* sigmsg = new SignalingMsg();
     488                        sigmsg->set_msg(known_pdu);
     489                        sigmsg->set_sid(*sid);
     490                        sigmsg->set_sig_mri(&pc_mri);
     491                        sigmsg->set_downstream(down);
     492                        sigmsg->send_or_delete();
     493
    434494                }
    435495                else {
     
    468528                assert(notify != NULL);
    469529
    470                 info_spec* er_obj = notify->get_errorobject();
    471                 info_spec::errorclass_t er_class = (info_spec::errorclass_t) er_obj->get_errorclass();
    472                 info_spec::errorcode_t er_code = (info_spec::errorcode_t) er_obj->get_errorcode();
    473 
    474                 if(er_class != info_spec::information) {
    475                         ILog(state_manager::modname, "Received NOTIFY message with error class " << er_obj->get_errorclass_string() << ", ending here!");
     530                info_spec* err_obj = notify->get_errorobject();
     531                info_spec::errorclass_t err_class = (info_spec::errorclass_t) err_obj->get_errorclass();
     532                info_spec::errorcode_t err_code = (info_spec::errorcode_t) err_obj->get_errorcode();
     533
     534                if(err_class != info_spec::information) {
     535                        ILog(state_manager::modname, "Received NOTIFY message with error class " << err_obj->get_errorclass_string() << ", ending here!");
    476536                        return error_nothing_to_do;
    477537                }
    478538
    479                 if(er_code == info_spec::InitQuery) {
     539                if(err_code == info_spec::InitQuery) {
    480540                        // create QUERY message
    481541                        querymsg* query = new querymsg();
     
    503563                        sigmsg->send_or_delete();
    504564                }
    505                 else if(er_code == info_spec::InitReserve) {
     565                else if(err_code == info_spec::InitReserve) {
     566                        // create RESERVE message
     567                        reservereq* reserve = new reservereq();
     568       
    506569                        // get context of given session
    507                         //NSLP_Context* context = sid ? contextmap.find(*sid) : NULL;
    508 
    509                         //create_query_message_from_context(context, query);
     570                        NSLP_Context* context = sid ? contextmap.find(*sid) : NULL;
     571                        if(context == NULL) {
     572                                ERRLog(state_manager::modname, "Unable to retrieve context for Session with SID [" << sid->to_string() << "], ending here!");
     573                                return error_nothing_to_do;
     574                        }
     575
     576                        // generate new rii object
     577                        rii *rii_obj = new rii();
     578                        rii_obj->generate_new();
     579                        rii_obj->set_own(true);
     580                        rii_obj->set_is_reserve(true);
     581
     582                        create_reserve_message_from_context(context, reserve, rii_obj);
     583                        reserve->set_proxy_flag();
     584
     585                        known_nslp_pdu *reserve_pdu = dynamic_cast<known_nslp_pdu*>(reserve);
     586                        assert(reserve_pdu != NULL);
     587       
     588
     589                        // send RESERVE message with PC-MRM
     590                        mri_pathcoupled pc_mri = rcvd_mri->get_mri_pc();
     591                        pc_mri.invertDirection();
     592                        bool down = pc_mri.get_downstream();
     593       
     594                        SignalingMsg* sigmsg = new SignalingMsg();
     595                        sigmsg->set_msg(reserve_pdu);
     596                        sigmsg->set_sid(*sid);
     597                        sigmsg->set_sig_mri(&pc_mri);
     598                        sigmsg->set_downstream(down);
     599                        sigmsg->send_or_delete();
    510600                }
    511601                else {
    512                         ILog(state_manager::modname, "Received NOTIFY message with error class " << er_obj->get_errorclass_string()
     602                        ILog(state_manager::modname, "Received NOTIFY message with error class " << err_obj->get_errorclass_string()
    513603                                        << ", but unexpected error code, ending here!");
    514604                        return error_nothing_to_do;
     
    814904  querymsg* query;
    815905
    816   bound_sessionid* send_bs = NULL;
    817   bound_sessionid* bs = NULL;
    818   bool found = false;
     906// XXX: I think this is not used anymore
     907//  bound_sessionid* send_bs = NULL;
     908//  bound_sessionid* bs = NULL;
     909//  bool found = false;
    819910  ILog(state_manager::modname, "process_query_msg()");
    820911
     
    838929    }
    839930  */
     931
     932  bool is_x_flag_set = query->is_x_flag();
    840933
    841934  NSLP_Context::qn_type_t type = NSLP_Context::QNE;
     
    886979    }  // end if RII existing
    887980    else {
     981// TODO: Anticipated Handover, Case 3
     982
    888983      // if I'm the QNR I should respond to the Query
    889984      if ( query->is_reserve_init_flag() && is_last_signaling_hop(rcvd_mri) ) {
    890985        // create RESERVE msg, send to QUERY initiator
    891         create_and_send_reserve_msg_as_response_to_query(true, q, rcvd_b_sid, !down, rcvd_sid, rcvd_mri, context);
     986        create_and_send_reserve_msg_as_response_to_query(true, q, rcvd_b_sid, !down, rcvd_sid, rcvd_mri, context, is_x_flag_set);
    892987      }
    893988      else if (query->is_reserve_init_flag()) {
     
    895990      }
    896991      else { // I'm a QNE, so simply forward this QUERY
     992        // !query->is_reserve_init_flag()
    897993        ERRLog(state_manager::modname, "Reservation existing! Wrong message requesting new reservation!!!");
    898994      }
     
    9061002      context->unlock();
    9071003    }
    908     else {
    909       if (type != NSLP_Context::QNR) {
    910         // check, if there is a BOUND_SESSIONID saved for this SID
    911         uint128 saved_b_sid;
    912         context->lock();
    913         found = context->get_bound_s_id(saved_b_sid);
    914         context->unlock();
    915         if (found) {
    916           ILog(state_manager::modname, "Found saved BOUND_SID. Setting BOUND_SESSIONID in QUERY message to [" << saved_b_sid << "]");
    917           send_bs = new bound_sessionid();
    918           send_bs->set(saved_b_sid);
    919         } 
    920       }
    921     }
     1004// XXX: I think this is useless since send_bs is never used.
     1005// Note the scope of the previously declared variable send_bs
     1006// and the later declared with the same name!
     1007//    else {
     1008//      if (type != NSLP_Context::QNR) {
     1009//      // check, if there is a BOUND_SESSIONID saved for this SID
     1010//      uint128 saved_b_sid;
     1011//      context->lock();
     1012//      found = context->get_bound_s_id(saved_b_sid);
     1013//      context->unlock();
     1014//      if (found) {
     1015//        ILog(state_manager::modname, "Found saved BOUND_SID. Setting BOUND_SESSIONID in QUERY message to [" << saved_b_sid << "]");
     1016//        send_bs = new bound_sessionid();
     1017//        send_bs->set(saved_b_sid);
     1018//        } 
     1019//      }
     1020//    }
    9221021  } // end if context found
    9231022  else {
    9241023    // no context so far
    925     if (rcvd_b_sid) {
    926       bs = new bound_sessionid(*rcvd_b_sid);
    927     }
    928     else {
    929       if (send_bs) {
    930         bs = new bound_sessionid(*send_bs);
    931       }
    932     }
     1024//    if (rcvd_b_sid) {
     1025//      bs = new bound_sessionid(*rcvd_b_sid);
     1026//    }
     1027// XXX: I think this is dead code!! See initialization of send_bs
     1028//    else {
     1029//      if (send_bs) {
     1030//      bs = new bound_sessionid(*send_bs);
     1031//      }
     1032//    }
    9331033
    9341034    //================================ process RII ======================================
     
    9511051    }  // end if RII existing
    9521052    else { // no RII present
    953      
     1053// TODO: Anticipated Handover, Case 3
     1054
     1055
    9541056      // if I'm the QNR I should respond to the Query
    9551057      if ( query->is_reserve_init_flag() && is_last_signaling_hop(rcvd_mri) ) {
    9561058        // create RESERVE msg, send to QUERY initiator
    957         create_and_send_reserve_msg_as_response_to_query(true, q, rcvd_b_sid, !down, rcvd_sid, rcvd_mri, 0);
     1059        create_and_send_reserve_msg_as_response_to_query(true, q, rcvd_b_sid, !down, rcvd_sid, rcvd_mri, 0, is_x_flag_set);
    9581060      }
    9591061      else { // I'm a QNE, so simply forward this QUERY
     
    20112113void state_manager::create_and_send_reserve_msg_as_response_to_query(bool send_rii, qspec_object* q, const bound_sessionid* b,
    20122114                                                            bool down, const ntlp::sessionid* sid, const ntlp::mri_pathcoupled* rcvd_mri,
    2013                                                             NSLP_Context *context)
     2115                                                            NSLP_Context *context, bool replace)
    20142116{
    20152117    DLog(state_manager::modname,"create_and_send_reserve_msg_as_response_to_query()");
     
    20482150    }
    20492151
     2152    // TODO: QSPEC is mandatory in a QUERY message!
     2153    // But in a Receiver Initiated Reservation it
     2154    // is in question if sensible
    20502155    if (q) {
    20512156        qspec::qspec_pdu* q_class = q->get_qspec_class();
    20522157        qspec_object* send_qspec = new qspec_object(q_class);
    20532158        res->set_qspec(send_qspec);
    2054     }
    2055     else {
    2056         // TODO: use QSPEC from context!
    2057         // Have RMF in mind!
    20582159    }
    20592160
     
    20662167    }
    20672168    uint128 local_sid= *sid;
    2068     if (context)
     2169
     2170//    if (context)
     2171//        res->set_replace_flag();
     2172    if(replace) {
    20692173        res->set_replace_flag();
     2174    }
     2175
    20702176    pdu = dynamic_cast<known_nslp_pdu*>(res);
    20712177
     
    33083414       
    33093415                        reservereq *res = new reservereq();
     3416                        // XXX: a little hack
     3417                        res->set_originator(true);
    33103418                        res->set_rsn(new rsn(rsn_own));
    33113419                        res->set_tear_flag();
     
    42974405        ILog(state_manager::modname, "process_aho_event()");
    42984406
    4299         DLog(state_manager::modname, "AHO-iface: " << iface);
    4300         DLog(state_manager::modname, "AHO-l2_ap_n: " << l2_ap_n);
    4301         DLog(state_manager::modname, "AHO-l3_ar_n: " << l3_ar_n);
     4407        ILog(state_manager::modname, "AHO-iface: " << iface);
     4408        ILog(state_manager::modname, "AHO-l2_ap_n: " << l2_ap_n);
     4409        ILog(state_manager::modname, "AHO-l3_ar_n: " << l3_ar_n);
    43024410
    43034411        //
     
    43484456        ntlp::mri_pathcoupled* pc_mri = NULL;
    43494457        known_nslp_pdu *pdu;
     4458        rii *rii_obj;
    43504459
    43514460        bool is_flow_sender=false;
     
    43784487                }
    43794488
     4489                ILog(state_manager::modname, "Starting AHO-Phase 1 for Reservation with SID [" << sid.to_string() << "]");
     4490                ILog(state_manager::modname, "PC-MRI src address: " << pc_mri->get_sourceaddress());
     4491                ILog(state_manager::modname, "PC-MRI dst address: " << pc_mri->get_destaddress());
     4492
     4493
     4494                // build RESERVE or QUERY message depending
     4495                // on the role of the mobile node
     4496                if(qn_type == NSLP_Context::QNI) {
     4497                        // create RESERVE message
     4498                        reservereq* res = new reservereq();
     4499
     4500                        // generate new rii object
     4501                        rii_obj = new rii();
     4502                        rii_obj->generate_new();
     4503                        rii_obj->set_own(true);
     4504                        rii_obj->set_is_reserve(true);
     4505
     4506                        create_reserve_message_from_context(context, res, rii_obj);
     4507                        res->set_proxy_flag();
     4508               
     4509                        pdu = dynamic_cast<known_nslp_pdu*>(res);
     4510                }
     4511                else if(qn_type == NSLP_Context::QNR) {
     4512                        // create QUERY message
     4513                        querymsg* query = new querymsg();
     4514
     4515                        create_query_message_from_context(context, query);
     4516                        query->set_reserve_init_flag();
     4517                        query->set_proxy_flag();
     4518
     4519                        pdu = dynamic_cast<known_nslp_pdu*>(query);
     4520                }
     4521                else {
     4522                        ERRLog(state_manager::modname, "AHO not implemented for case where mobile node is QNE of a reservation!");
     4523                        return;
     4524                }
     4525
     4526                assert(pdu != NULL);
     4527
     4528
     4529                // build mri
     4530                hostaddress orig_sig_addr;
     4531                if(is_flow_sender) {
     4532                        orig_sig_addr = pc_mri->get_sourceaddress();
     4533                        pc_mri->set_sourceaddress(*l3_ar_n);
     4534                        pc_mri->set_downstream(true);
     4535                }
     4536                else if(is_flow_receiver) {
     4537                        orig_sig_addr = pc_mri->get_destaddress();
     4538                        pc_mri->set_destaddress(*l3_ar_n);
     4539                        pc_mri->set_downstream(false);
     4540                }
     4541                mri_explicitsigtarget *est_mri = new mri_explicitsigtarget(*pc_mri, orig_sig_addr, *l3_ar_n);
     4542
     4543
    43804544                // create new AHO_Context
    43814545                NSLP_AHO_Context *aho_context = new NSLP_AHO_Context();
     
    43854549                // save address of access router AR_N
    43864550                aho_context->set_addr_new_access_router(*l3_ar_n);
     4551                // save mri of new flow
     4552                aho_context->set_mri_new_flow(*pc_mri);
    43874553                // save is_flow_sender / is_flow_receiver
    43884554                aho_context->set_is_flow_sender(is_flow_sender);
    43894555                aho_context->set_is_flow_receiver(is_flow_receiver);
     4556                if(qn_type == NSLP_Context::QNI) {
     4557                        // save RII object to match RESPONSE message
     4558                        aho_context->set_rii(*rii_obj);
     4559                }
    43904560                aho_context->unlock();
    4391 
    4392                 // TODO: remove
    4393                 /*
    4394                 role = aho_context->get_aho_node_role();
    4395                 switch(role) {
    4396                 case NSLP_AHO_Context::MN:
    4397                         DLog(state_manager::modname, "Node Role: MN");
    4398                         break;
    4399                 case NSLP_AHO_Context::ARN:
    4400                         DLog(state_manager::modname, "Node Role: ARN");
    4401                         break;
    4402                 case NSLP_AHO_Context::CN:
    4403                         DLog(state_manager::modname, "Node Role: CN");
    4404                         break;
    4405                 case NSLP_AHO_Context::OTHER:
    4406                         DLog(state_manager::modname, "Node Role: OTHER");
    4407                         break;
    4408                 }
    4409                 */
    44104561
    44114562                // insert AHO_Context into aho_contextmap
    44124563                aho_contextmap.insert(sid, aho_context);
    4413 
    4414 
    4415                 ILog(state_manager::modname, "Starting AHO-Phase 1 for Reservation with SID [" << sid.to_string() << "]");
    4416                 ILog(state_manager::modname, "PC-MRI src address: " << pc_mri->get_sourceaddress());
    4417                 ILog(state_manager::modname, "PC-MRI dst address: " << pc_mri->get_destaddress());
    4418 
    4419 
    4420                 // build RESERVE or QUERY message depending
    4421                 // on the role of the mobile node
    4422                 if(qn_type == NSLP_Context::QNI) {
    4423                         // create RESERVE message
    4424                         reservereq* res = new reservereq();
    4425 
    4426                         // generate new rii object
    4427                         rii *send_rii = new rii();
    4428                         send_rii->generate_new();
    4429                         send_rii->set_own(true);
    4430                         send_rii->set_is_reserve(true);
    4431 
    4432                         create_reserve_message_from_context(context, res, send_rii);
    4433                         res->set_proxy_flag();
    4434                
    4435                         pdu = dynamic_cast<known_nslp_pdu*>(res);
    4436                 }
    4437                 else if(qn_type == NSLP_Context::QNR) {
    4438                         // create QUERY message
    4439                         querymsg* query = new querymsg();
    4440 
    4441                         create_query_message_from_context(context, query);
    4442                         query->set_reserve_init_flag();
    4443                         query->set_proxy_flag();
    4444 
    4445                         pdu = dynamic_cast<known_nslp_pdu*>(query);
    4446                 }
    4447                 else {
    4448                         ERRLog(state_manager::modname, "AHO not implemented for case where mobile node is QNE of a reservation!");
    4449                         return;
    4450                 }
    4451 
    4452                 assert(pdu != NULL);
    4453 
    4454 
    4455                 // build mri
    4456                 hostaddress orig_sig_addr;
    4457                 if(is_flow_sender) {
    4458                         orig_sig_addr = pc_mri->get_sourceaddress();
    4459                         pc_mri->set_sourceaddress(*l3_ar_n);
    4460                         pc_mri->set_downstream(true);
    4461                 }
    4462                 else if(is_flow_receiver) {
    4463                         orig_sig_addr = pc_mri->get_destaddress();
    4464                         pc_mri->set_destaddress(*l3_ar_n);
    4465                         pc_mri->set_downstream(false);
    4466                 }
    4467                 mri_explicitsigtarget *est_mri = new mri_explicitsigtarget(*pc_mri, orig_sig_addr, *l3_ar_n);
    44684564
    44694565
     
    45114607        bool is_flow_sender=false;
    45124608        bool is_flow_receiver=false;
     4609
     4610        bool hard_handover=false;
    45134611
    45144612
     
    45384636                // find AHO_Context
    45394637                NSLP_AHO_Context *aho_context = aho_contextmap.find(sid);
    4540                 if(aho_context == NULL) {
    4541                         ERRLog(state_manager::modname, "No NSLP_AHO_Context found for SID [" << sid.to_string() << "]");
    4542                         return;
    4543                 }
    4544 
    4545                 aho_context->lock();
    4546                 NSLP_AHO_Context::node_role_t role = aho_context->get_aho_node_role();
    4547                 is_flow_sender = aho_context->get_is_flow_sender();
    4548                 is_flow_receiver = aho_context->get_is_flow_receiver();
    4549 
    4550                 hostaddress l3_ar_n_saved;
    4551                 if(role != NSLP_AHO_Context::MN) {
    4552                         ERRLog(state_manager::modname, "Since I received a HO-Trigger, I am MN, but AHO_Context tells something other!");
    4553                         aho_context->unlock();
    4554                         return;
    4555                 }
    4556                 else {
    4557                         l3_ar_n_saved = aho_context->get_addr_new_access_router();
    4558                 }
    4559                 aho_context->unlock();
    4560 
    4561 
    4562                 // now proceed with handover
    4563                 if((*l3_ar_n) == l3_ar_n_saved) {
    4564                         // Proceed with an Anticipated Handover
    4565                         ILog(state_manager::modname, "Starting AHO-Phase 3 (" <<  color[green] << "Anticipated Handover" <<  color[off]
    4566                                         << ") for Reservation with SID [" << sid.to_string() << "]");
    4567 
    4568                         // build RESERVE or QUERY message depending
    4569                         // on the role of the mobile node
    4570                         if(qn_type == NSLP_Context::QNI) {
    4571                                 // create RESERVE message
    4572                                 reservereq* res = new reservereq();
     4638                if(aho_context != NULL) {
     4639                        aho_context->lock();
     4640                        NSLP_AHO_Context::node_role_t role = aho_context->get_aho_node_role();
     4641                        is_flow_sender = aho_context->get_is_flow_sender();
     4642                        is_flow_receiver = aho_context->get_is_flow_receiver();
     4643                        bool anticipated_reservation_successful = aho_context->get_anticipated_reservation_success();
    45734644       
    4574                                 // generate new rii object
    4575 //                              rii *send_rii = new rii();
    4576 //                              send_rii->generate_new();
    4577 //                              send_rii->set_own(true);
    4578 //                              send_rii->set_is_reserve(true);
    4579        
    4580                                 create_reserve_message_from_context(context, res, NULL);
    4581                                 res->set_replace_flag();
    4582                        
    4583                                 pdu = dynamic_cast<known_nslp_pdu*>(res);
    4584                         }
    4585                         else if(qn_type == NSLP_Context::QNR) {
    4586                                 // create QUERY message
    4587                                 querymsg* query = new querymsg();
    4588        
    4589                                 create_query_message_from_context(context, query);
    4590                                 query->set_reserve_init_flag();
    4591                                 query->set_x_flag();
    4592        
    4593                                 pdu = dynamic_cast<known_nslp_pdu*>(query);
     4645                        hostaddress l3_ar_n_saved;
     4646                        if(role != NSLP_AHO_Context::MN) {
     4647                                ERRLog(state_manager::modname, "Since I received a HO-Trigger, I am MN, but AHO_Context tells something other!");
     4648                                aho_context->unlock();
     4649                                return;
    45944650                        }
    45954651                        else {
    4596                                 ERRLog(state_manager::modname, "AHO not implemented for case where mobile node is QNE of a reservation!");
    4597                                 return;
     4652                                l3_ar_n_saved = aho_context->get_addr_new_access_router();
     4653                        }
     4654                        aho_context->unlock();
     4655       
     4656       
     4657                        // now proceed with handover
     4658                        if(((*l3_ar_n) == l3_ar_n_saved) && anticipated_reservation_successful) {
     4659                                // Proceed with an Anticipated Handover
     4660                                ILog(state_manager::modname, "Starting AHO-Phase 3 (" <<  color[green] << "Anticipated Handover" <<  color[off]
     4661                                                << ") for Reservation with SID [" << sid.to_string() << "]");
     4662       
     4663                                // build RESERVE or QUERY message depending
     4664                                // on the role of the mobile node
     4665                                if(qn_type == NSLP_Context::QNI) {
     4666                                        // create RESERVE message
     4667                                        reservereq* res = new reservereq();
     4668               
     4669                                        // generate new rii object
     4670//                                      rii *send_rii = new rii();
     4671//                                      send_rii->generate_new();
     4672//                                      send_rii->set_own(true);
     4673//                                      send_rii->set_is_reserve(true);
     4674               
     4675                                        create_reserve_message_from_context(context, res, NULL);
     4676                                        res->set_replace_flag();
     4677                               
     4678                                        pdu = dynamic_cast<known_nslp_pdu*>(res);
     4679                                }
     4680                                else if(qn_type == NSLP_Context::QNR) {
     4681                                        // create QUERY message
     4682                                        querymsg* query = new querymsg();
     4683               
     4684                                        create_query_message_from_context(context, query);
     4685                                        query->set_reserve_init_flag();
     4686                                        query->set_x_flag();
     4687               
     4688                                        pdu = dynamic_cast<known_nslp_pdu*>(query);
     4689                                }
     4690                                else {
     4691                                        ERRLog(state_manager::modname, "AHO not implemented for case where mobile node is QNE of a reservation!");
     4692                                        return;
     4693                                }
     4694               
     4695                                assert(pdu != NULL);
     4696       
     4697       
     4698                                // build mri
     4699                                if(is_flow_sender) {
     4700                                        pc_mri->set_sourceaddress(*l3_mn);
     4701                                        pc_mri->set_downstream(true);
     4702                                }
     4703                                else if(is_flow_receiver) {
     4704                                        pc_mri->set_destaddress(*l3_mn);
     4705                                        pc_mri->set_downstream(false);
     4706                                }
     4707       
     4708       
     4709                                // send message with PC-MRM
     4710                                SignalingMsg* sigmsg = new SignalingMsg();
     4711                                sigmsg->set_msg(pdu);
     4712                                sigmsg->set_sid(sid);
     4713                                sigmsg->set_sig_mri(pc_mri);
     4714                                sigmsg->set_downstream(pc_mri->get_downstream());
     4715                                sigmsg->send_or_delete();
     4716                        }
     4717                        else {
     4718                                // new access router is not the anticipated one
     4719                                ILog(state_manager::modname, "New Router is not the anticipated one, proceeding with Hard Handover.");
     4720                                hard_handover = true;
    45984721                        }
    45994722       
    4600                         assert(pdu != NULL);
    4601 
    4602 
    4603                         // build mri
    4604                         if(is_flow_sender) {
    4605                                 pc_mri->set_sourceaddress(*l3_mn);
    4606                                 pc_mri->set_downstream(true);
    4607                         }
    4608                         else if(is_flow_receiver) {
    4609                                 pc_mri->set_destaddress(*l3_mn);
    4610                                 pc_mri->set_downstream(false);
    4611                         }
    4612 
    4613 
    4614                         // send message with PC-MRM
    4615                         SignalingMsg* sigmsg = new SignalingMsg();
    4616                         sigmsg->set_msg(pdu);
    4617                         sigmsg->set_sid(sid);
    4618                         sigmsg->set_sig_mri(pc_mri);
    4619                         sigmsg->set_downstream(pc_mri->get_downstream());
    4620                         sigmsg->send_or_delete();
     4723       
     4724                        // delete AHO_Context
     4725                        aho_contextmap.erase(sid);
    46214726                }
    46224727                else {
     4728                        // no NSLP_AHO_Context found
     4729                        ILog(state_manager::modname, "No NSLP_AHO_Context found for this Session or anticipated reservation failed, proceeding with Hard Handover.");
     4730                        hard_handover = true;
     4731                }
     4732
     4733
     4734                if(hard_handover) {
    46234735                        // Proceed with a Hard Handover
    46244736                        ILog(state_manager::modname, "Starting AHO-Phase 3 / 2a (" <<  color[magenta] << "Hard Handover" <<  color[off]
     
    46274739                        // TODO
    46284740                }
    4629 
    4630 
    4631                 // delete AHO_Context
    4632                 aho_contextmap.erase(sid);
    46334741        }
    46344742
    46354743        ILog(state_manager::modname, "aho_phase_3_2a() - done");
     4744}
     4745
     4746
     4747/* if the current node is the new access router in the context of an
     4748 * anticipated handover an incoming RESERVE / RESPONSE message needs to be
     4749 * forwarded to the mobile node, which is accomplished by this function.
     4750 * @param known_pdu PDU of the incoming RESERVE / RESPONSE message.
     4751 * @param rcvd_sid the session id the message belongs to.
     4752 * @param rcvd_mri the MRI for which signaling takes place.
     4753 */
     4754void state_manager::forward_message_if_new_access_router(known_nslp_pdu* known_pdu, const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri) {
     4755        // determine node role within AHO
     4756        NSLP_AHO_Context::node_role_t role = NSLP_AHO_Context::OTHER;
     4757        hostaddress ar_n, mn;
     4758        ntlp::mri_pathcoupled mri_new_flow;
     4759        NSLP_AHO_Context *aho_context = aho_contextmap.find(*rcvd_sid);
     4760        if(aho_context != NULL) {
     4761                aho_context->lock();
     4762                role = aho_context->get_aho_node_role();
     4763                if(role == NSLP_AHO_Context::ARN) {
     4764                        ar_n = aho_context->get_addr_new_access_router();
     4765                        mn = aho_context->get_addr_mobile_node();
     4766                        mri_new_flow = aho_context->get_mri_new_flow();
     4767                }
     4768                aho_context->unlock();
     4769        }
     4770
     4771        if(role == NSLP_AHO_Context::ARN && (*rcvd_mri == mri_new_flow)) {
     4772                // forward message towards the mobile node
     4773                const hostaddress orig_sig_addr = ar_n;
     4774                const hostaddress dest_sig_addr = mn;
     4775                mri_explicitsigtarget *est_mri = new mri_explicitsigtarget(*rcvd_mri, orig_sig_addr, dest_sig_addr);
     4776
     4777                ExplicitSignalingMsg* sigmsg = new ExplicitSignalingMsg();
     4778                sigmsg->set_pdu(known_pdu);
     4779                sigmsg->set_sid(*rcvd_sid);
     4780                sigmsg->set_sig_mri(est_mri);
     4781                sigmsg->send_or_delete();
     4782        }
    46364783}
    46374784#endif // USE_AHO
     
    46424789 * @param res the RESERVE message.
    46434790 * @param rii RII object to use in RESERVE message, NULL if none.
    4644  * */
     4791 */
    46454792// TODO: which QSPEC to choose, after modifying context to allow multiple concurrent flows within a session
    46464793void state_manager::create_reserve_message_from_context(NSLP_Context *context, reservereq *res, rii *send_rii) {
     
    47114858 * @param context the NSLP Context.
    47124859 * @param query the QUERY message.
    4713  * */
     4860 */
    47144861// TODO: which QSPEC to choose, after modifying context to allow multiple concurrent flows within a session
    47154862void state_manager::create_query_message_from_context(NSLP_Context *context, querymsg *query) {
  • qos-nslp/branches/20090610-qos-nslp-aho/src/nslp_aho_context.cpp

    r4540 r4546  
    1313
    1414
    15 NSLP_AHO_Context::NSLP_AHO_Context() : node_role(NSLP_AHO_Context::OTHER)
     15NSLP_AHO_Context::NSLP_AHO_Context() : node_role(NSLP_AHO_Context::OTHER), anticipated_reservation_successful(false)
    1616{
    1717  pthread_mutexattr_init(&mutex_attr);
     
    2222#endif
    2323  pthread_mutex_init(&mutex, &mutex_attr); 
     24
     25
     26  mri_new_flow = NULL;
     27  rii_obj = NULL;
    2428} // end constructor
    2529
     
    2933  pthread_mutex_destroy(&mutex);
    3034  pthread_mutexattr_destroy(&mutex_attr);
     35
     36
     37  if(mri_new_flow != NULL) {
     38    delete mri_new_flow;
     39  }
     40
     41  if(rii_obj != NULL) {
     42    delete rii_obj;
     43  }
    3144}
    3245
     
    6881
    6982
    70 /** This function is used by the mobile node and sets the address of the
    71   * new access router, which is needed later in an anticipated handover.
     83/** This function is used by the mobile node and the new access router and sets
     84  * the address of the new access router, which is needed later in an
     85  * anticipated handover.
    7286  * @param the address of the new access router.
    7387  */
     
    119133}
    120134
     135
     136/** This function is used by the new access router and sets the mri of the new
     137  * flow, which is needed to match RESERVE / RESPONSE messages, that need to be
     138  * forwarded to the mobile node.
     139  * @param the mri of the new flow.
     140  */
     141void NSLP_AHO_Context::set_mri_new_flow(const ntlp::mri_pathcoupled &mri) {
     142  mri_new_flow = mri.copy();
     143}
     144
     145
     146/** This function is used by the new access router and returns the mri of the
     147  * new flow, which is needed to match RESERVE / RESPONSE messages, that need to
     148  * be forwarded to the mobile node.
     149  * @return the mri of the new flow.
     150  */
     151const ntlp::mri_pathcoupled &NSLP_AHO_Context::get_mri_new_flow() const {
     152  return *mri_new_flow;
     153}
     154
     155
     156/** This function is used by the mobile node in the case where the MN is QNI and
     157  * saves the RII object of the sent RESERVE message to match a received
     158  * RESPONSE message.
     159  * @param the sent RII object.
     160  */
     161void NSLP_AHO_Context::set_rii(const rii &rii_obj) {
     162  this->rii_obj = rii_obj.copy();
     163}
     164
     165
     166/** This function is used by the mobile node in the case where the MN is QNI and
     167  * returns the saved RII object of the sent RESERVE message to match a received
     168  * RESPONSE message.
     169  * @return the previously sent RII object.
     170  */
     171const rii &NSLP_AHO_Context::get_rii() const {
     172  return *rii_obj;
     173}
     174
     175
     176/** This function is used by the mobile node and sets whether the anticipated
     177  * reservation was successful or not.
     178  * @param true if anticipated reservation was successful.
     179  */
     180void NSLP_AHO_Context::set_anticipated_reservation_success(bool success) {
     181  anticipated_reservation_successful = success;
     182}
     183
     184
     185/** This function is used by the mobile node returns whether the anticipated
     186  * reservation was successful.
     187  * @return true if anticipated reservation was successful.
     188  */
     189bool NSLP_AHO_Context::get_anticipated_reservation_success() const {
     190  return anticipated_reservation_successful;
     191}
     192
    121193} // end namespace qos_nslp
    122194
  • qos-nslp/branches/20090610-qos-nslp-aho/src/querymsg.cpp

    r3489 r4546  
    230230  */
    231231querymsg::querymsg() : known_nslp_pdu(QUERY,"QUERY",specific_not_set,generic_not_set) {
     232        set_x_flag();
    232233} // end constructor
    233234
     
    248249        set_bound_sid(bound_session_id);
    249250        set_qspec(q_spec_1);
     251
     252        set_x_flag();
    250253} // end constructor
    251254
Note: See TracChangeset for help on using the changeset viewer.