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

Changeset 4540


Ignore:
Timestamp:
Oct 12, 2009, 12:28:19 AM (8 years ago)
Author:
stud-dettling
Message:
  • Implemented AHO phase 3 for the anticipated handover case.
Location:
qos-nslp/branches/20090610-qos-nslp-aho
Files:
4 edited

Legend:

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

    r4530 r4540  
    4444  const hostaddress &get_addr_new_access_router() const;
    4545
     46  void set_is_flow_sender(bool is_sender);
     47  bool get_is_flow_sender() const;
     48
     49  void set_is_flow_receiver(bool is_receiver);
     50  bool get_is_flow_receiver() const;
     51
    4652  /// lock mutex
    4753  void lock();
     
    6167  hostaddress mn;
    6268  hostaddress ar_n;
     69  bool is_flow_sender;
     70  bool is_flow_receiver;
    6371
    6472  /// This mutex is used to lock the NSLP_AHO_Context
  • qos-nslp/branches/20090610-qos-nslp-aho/include/nslp_pdu.h

    r3701 r4540  
    6969        #define QUERY_FLAG_RESERVE_INIT                 (1<<0)
    7070        #define QUERY_FLAG_BREAK                                (1<<1)
     71        #define QUERY_FLAG_X                                    (1<<2)  // see Anticipated Handover
    7172
    7273        /* RESPONSE specific flags (8bit) */
     
    115116        void set_req_reduced_refresh_flag();
    116117        void set_break_flag(); // XXX: should this be namespaced?
     118        void set_x_flag();
    117119
    118120        bool is_replace_flag() const;
     
    124126        bool is_req_reduced_refresh_flag() const;
    125127        bool is_break_flag() const;
     128        bool is_x_flag() const;
    126129
    127130// @{
     
    333336inline void nslp_pdu::set_req_reduced_refresh_flag() { specific_flags |= RESV_FLAG_REQ_REDUCED_REFRESH; }
    334337inline void nslp_pdu::set_break_flag() { break_flag_set = true; }
     338inline void nslp_pdu::set_x_flag() { specific_flags |= QUERY_FLAG_X; }
    335339inline bool nslp_pdu::is_replace_flag() const { return (specific_flags & RESV_FLAG_REPLACE); }
    336340inline bool nslp_pdu::is_acknowledge_flag() const { return (generic_flags & GEN_FLAG_ACKNOWLEDGE); }
     
    341345inline bool nslp_pdu::is_req_reduced_refresh_flag() const { return (specific_flags & RESV_FLAG_REQ_REDUCED_REFRESH); }
    342346inline bool nslp_pdu::is_break_flag() const { return break_flag_set; }
     347inline bool nslp_pdu::is_x_flag() const { return (specific_flags & QUERY_FLAG_X); }
    343348
    344349/** true if this is a RESERVE PDU. */
  • qos-nslp/branches/20090610-qos-nslp-aho/src/QoS_StateModule.cpp

    r4537 r4540  
    43434343
    43444344
     4345                // error checking
     4346                if((!is_flow_sender) && (!is_flow_receiver)) {
     4347                        ERRLog(state_manager::modname, "AHO not implemented for case where mobile node isn't endpoint of a flow!");
     4348                        return;
     4349                }
     4350
    43454351                // create new AHO_Context
    43464352                NSLP_AHO_Context *aho_context = new NSLP_AHO_Context();
     
    43504356                // save address of access router AR_N
    43514357                aho_context->set_addr_new_access_router(*l3_ar_n);
     4358                // save is_flow_sender / is_flow_receiver
     4359                aho_context->set_is_flow_sender(is_flow_sender);
     4360                aho_context->set_is_flow_receiver(is_flow_receiver);
    43524361                aho_context->unlock();
    43534362
     
    44024411
    44034412                        create_query_message_from_context(context, query);
     4413                        query->set_reserve_init_flag();
    44044414                        query->set_proxy_flag();
    44054415
     
    44164426                // build mri
    44174427                hostaddress orig_sig_addr;
    4418                 if(is_flow_source(pc_mri)) {
     4428                if(is_flow_sender) {
    44194429                        orig_sig_addr = pc_mri->get_sourceaddress();
    44204430                        pc_mri->set_sourceaddress(*l3_ar_n);
    44214431                        pc_mri->set_downstream(true);
    44224432                }
    4423                 else if(is_flow_destination(pc_mri)) {
     4433                else if(is_flow_receiver) {
    44244434                        orig_sig_addr = pc_mri->get_destaddress();
    44254435                        pc_mri->set_destaddress(*l3_ar_n);
    44264436                        pc_mri->set_downstream(false);
    4427                 }
    4428                 else {
    4429                         ERRLog(state_manager::modname, "AHO not implemented for case where mobile node isn't endpoint of a flow!");
    4430                         return;
    44314437                }
    44324438                mri_explicitsigtarget *est_mri = new mri_explicitsigtarget(*pc_mri, orig_sig_addr, *l3_ar_n);
     
    44674473        ILog(state_manager::modname, "aho_phase_3_2a)");
    44684474
    4469         // TODO: prÃŒfen, ob AR_N_saved == AR_N_received
    4470         // falls nein - Hard Handover
    4471 
    4472         //
    4473         // TODO: delete aho_context
     4475        hostaddress *l3_ar_n;
     4476        hostaddress *l3_mn;
     4477        uint128 tmp_sid;
     4478        NSLP_Context::qn_type_t qn_type;
     4479        ntlp::mri_pathcoupled* pc_mri = NULL;
     4480        known_nslp_pdu *pdu;
     4481
     4482        bool is_flow_sender=false;
     4483        bool is_flow_receiver=false;
     4484
     4485
     4486        l3_ar_n = reinterpret_cast<hostaddress *>(param1);
     4487        if(l3_ar_n == NULL) {
     4488                ERRLog(state_manager::modname, "aho_phase_3_2a: Missing parameter l3_ar_n!");
     4489                return;
     4490        }
     4491
     4492        l3_mn = reinterpret_cast<hostaddress *>(param2);
     4493        if(l3_mn == NULL) {
     4494                ERRLog(state_manager::modname, "aho_phase_3_2a: Missing parameter l3_mn!");
     4495                return;
     4496        }
     4497
     4498        if(context) {
     4499                // retrieve some informations from context
     4500                context->lock();
     4501                context->get_s_id(tmp_sid);
     4502                qn_type = context->get_qn_type();
     4503                pc_mri = context->get_mri()->copy();
     4504                context->unlock();
     4505
     4506                ntlp::sessionid sid(tmp_sid);
     4507
     4508
     4509                // find AHO_Context
     4510                NSLP_AHO_Context *aho_context = aho_contextmap.find(sid);
     4511                if(aho_context == NULL) {
     4512                        ERRLog(state_manager::modname, "No NSLP_AHO_Context found for SID [" << sid.to_string() << "]");
     4513                        return;
     4514                }
     4515
     4516                aho_context->lock();
     4517                NSLP_AHO_Context::node_role_t role = aho_context->get_aho_node_role();
     4518                is_flow_sender = aho_context->get_is_flow_sender();
     4519                is_flow_receiver = aho_context->get_is_flow_receiver();
     4520
     4521                hostaddress l3_ar_n_saved;
     4522                if(role != NSLP_AHO_Context::MN) {
     4523                        ERRLog(state_manager::modname, "Since I received a HO-Trigger, I am MN, but AHO_Context tells something other!");
     4524                        aho_context->unlock();
     4525                        return;
     4526                }
     4527                else {
     4528                        l3_ar_n_saved = aho_context->get_addr_new_access_router();
     4529                }
     4530                aho_context->unlock();
     4531
     4532
     4533                // now proceed with handover
     4534                if((*l3_ar_n) == l3_ar_n_saved) {
     4535                        // Proceed with an Anticipated Handover
     4536                        ILog(state_manager::modname, "Starting AHO-Phase 3 (" <<  color[green] << "Anticipated Handover" <<  color[off]
     4537                                        << ") for Reservation with SID [" << sid.to_string() << "]");
     4538
     4539                        // build RESERVE or QUERY message depending
     4540                        // on the role of the mobile node
     4541                        if(qn_type == NSLP_Context::QNI) {
     4542                                // create RESERVE message
     4543                                reservereq* res = new reservereq();
     4544       
     4545                                // generate new rii object
     4546//                              rii *send_rii = new rii();
     4547//                              send_rii->generate_new();
     4548//                              send_rii->set_own(true);
     4549//                              send_rii->set_is_reserve(true);
     4550       
     4551                                create_reserve_message_from_context(context, res, NULL);
     4552                                res->set_replace_flag();
     4553                       
     4554                                pdu = dynamic_cast<known_nslp_pdu*>(res);
     4555                        }
     4556                        else if(qn_type == NSLP_Context::QNR) {
     4557                                // create QUERY message
     4558                                querymsg* query = new querymsg();
     4559       
     4560                                create_query_message_from_context(context, query);
     4561                                query->set_reserve_init_flag();
     4562                                query->set_x_flag();
     4563       
     4564                                pdu = dynamic_cast<known_nslp_pdu*>(query);
     4565                        }
     4566                        else {
     4567                                ERRLog(state_manager::modname, "AHO not implemented for case where mobile node is QNE of a reservation!");
     4568                                return;
     4569                        }
     4570       
     4571                        assert(pdu != NULL);
     4572
     4573
     4574                        // build mri
     4575                        if(is_flow_sender) {
     4576                                pc_mri->set_sourceaddress(*l3_mn);
     4577                                pc_mri->set_downstream(true);
     4578                        }
     4579                        else if(is_flow_receiver) {
     4580                                pc_mri->set_destaddress(*l3_mn);
     4581                                pc_mri->set_downstream(false);
     4582                        }
     4583
     4584
     4585                        // send message with PC-MRM
     4586                        SignalingMsg* sigmsg = new SignalingMsg();
     4587                        sigmsg->set_msg(pdu);
     4588                        sigmsg->set_sid(sid);
     4589                        sigmsg->set_sig_mri(pc_mri);
     4590                        sigmsg->set_downstream(pc_mri->get_downstream());
     4591                        sigmsg->send_or_delete();
     4592                }
     4593                else {
     4594                        // Proceed with a Hard Handover
     4595                        ILog(state_manager::modname, "Starting AHO-Phase 3 / 2a (" <<  color[magenta] << "Hard Handover" <<  color[off]
     4596                                        << ") for Reservation with SID [" << sid.to_string() << "]");
     4597
     4598                        // TODO
     4599                }
     4600
     4601
     4602                // delete AHO_Context
     4603                aho_contextmap.erase(sid);
     4604        }
    44744605
    44754606        ILog(state_manager::modname, "aho_phase_3_2a() - done");
  • qos-nslp/branches/20090610-qos-nslp-aho/src/nslp_aho_context.cpp

    r4530 r4540  
    8585}
    8686
     87
     88/** This function is used by the mobile node and sets whether the mobile
     89  * node is the sender of the flow.
     90  * @param true if sender of the flow.
     91  */
     92void NSLP_AHO_Context::set_is_flow_sender(bool is_sender) {
     93  is_flow_sender = is_sender;
     94}
     95
     96
     97/** This function returns whether the mobile node is the sender of the flow.
     98  * @return true if sender of the flow.
     99  */
     100bool NSLP_AHO_Context::get_is_flow_sender() const {
     101  return is_flow_sender;
     102}
     103
     104
     105/** This function is used by the mobile node and sets whether the mobile
     106  * node is the receiver of the flow.
     107  * @param true if receiver of the flow
     108  */
     109void NSLP_AHO_Context::set_is_flow_receiver(bool is_receiver) {
     110  is_flow_receiver = is_receiver;
     111}
     112
     113
     114/** This function returns whether the mobile node is the receiver of the flow.
     115  * @return true if receiver of the flow.
     116  */
     117bool NSLP_AHO_Context::get_is_flow_receiver() const {
     118  return is_flow_receiver;
     119}
     120
    87121} // end namespace qos_nslp
    88122
Note: See TracChangeset for help on using the changeset viewer.