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

Changeset 4213


Ignore:
Timestamp:
Aug 6, 2009, 2:33:37 PM (8 years ago)
Author:
stud-lenk
Message:

Re-sync qos-nlsp with trunk (up to SVN rev. 4212)

Location:
qos-nslp/branches/20090723-multicast
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • qos-nslp/branches/20090723-multicast

  • qos-nslp/branches/20090723-multicast/Makefile

    • Property svn:keywords deleted
    r3130 r4213  
    22# Makefile - Top-level Makefile for QoSNSLPka
    33# ----------------------------------------------------------
    4 # $Id$
    5 # $HeadURL$
     4# $Id: Makefile 3130 2008-07-07 14:05:13Z bless $
     5# $HeadURL: https://svn.ipv6.tm.uka.de/nsis/qos-nslp/branches/20090723-multicast/Makefile $
    66# ==========================================================
    77#                     
     
    99# - Institute of Telematics, University of Karlsruhe (TH)
    1010# ==========================================================
    11 SHELL = /bin/bash # otherwise make TAGS will fail
    1211
    1312DISTDIR?=$(CURDIR)/..
  • qos-nslp/branches/20090723-multicast/include/ProcessingModule.h

    r3673 r4213  
    2020#include "SignalingAppl.h"
    2121#include "apimessage.h"
     22#include "flowinfo.h"
    2223
    2324#include <ext/hash_map>
     
    3132                        ProcessingModuleParam(
    3233                                              uint32 sleep_time,
    33                                               const hostaddress& oa4,
    34                                               const hostaddress& oa6,
     34                                              AddressList &addresses,
     35                                              Flowinfo &fi_service,
    3536                                              bool see = true,
    3637                                              bool sre = true
    3738                );
    3839                const  message::qaddr_t source;
    39                 hostaddress orig_a4;
    40                 hostaddress orig_a6;
     40                AddressList &addresses;
     41                Flowinfo &fi_service;
    4142                const  bool send_error_expedited;
    4243                const  bool send_reply_expedited;
     
    121122        bool get_downstream() const { return down; }
    122123        // @}
     124        void set_allow_translate(bool d) { translate = d; }
     125        bool get_allow_translate() const { return translate; }
     126        void set_invalidate(bool d) { invalidate = d; }
     127        bool get_invalidate() const { return invalidate; }
    123128        void set_sii_handle(uint32 sii) { sii_handle = sii; }
    124129        uint32 get_sii_handle() const { return sii_handle; }
     
    130135        uint32 sii_handle;
    131136        bool down;
     137        bool translate;
     138        bool invalidate;
    132139}; // end class SignalingMsg
    133140
  • qos-nslp/branches/20090723-multicast/include/QoS_StateModule.h

    r3673 r4213  
    2424#include "querymsg.h"
    2525#include "responsemsg.h"
     26#include "notifymsg.h"
    2627#include "aggregate.h"
    2728#include "QoS_Appl_Msg.h"
     
    2930#include "address.h"
    3031#include "mri_pc.h"
     32#include "flowinfo.h"
     33#include "apimessage.h"
     34#include "addresslist.h"
    3135
    3236#include <pthread.h>
     
    6670  /// constructor
    6771  state_manager();
    68   state_manager(const hostaddress& oa4, const hostaddress& oa6);
     72  state_manager(AddressList &addresses, Flowinfo &fi_service);
    6973  ~state_manager();
    7074  void* timerchecker(void *p);
     
    7377                              const ntlp::sessionid* sid, const ntlp::mri_pathcoupled* rcvd_mri);
    7478  error_t process_outgoing(known_nslp_pdu& rsppdu, NetMsg*& msg, bool down,
    75                            const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri);
     79                           const ntlp::sessionid* rcvd_sid, ntlp::mri_pathcoupled** rcvd_mri);
    7680  error_t create_new_context(known_nslp_pdu& pdu, error_t& nslpres, bool down,
    77                              const ntlp::sessionid* local_sid, const ntlp::mri_pathcoupled* rcvd_mri);
     81                             const ntlp::sessionid* local_sid, const ntlp::mri_pathcoupled* rcvd_mri,
     82                             ntlp::Flowstatus *fs);
    7883  bool find_and_update_context(known_nslp_pdu* pdu, error_t& nslpres, bool down,
    79                                const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri);
     84                               const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri,
     85                               ntlp::Flowstatus *fs);
    8086  void forward_reserve(const reservereq* reservemsg, NSLP_Context* context, bool down, const ntlp::mri_pathcoupled* rcvd_mri);
    8187  error_t  process_rii(NSLP_Context* context, reservereq* reservemsg, const ntlp::sessionid* local_sid,
     
    8389  error_t  process_qspec(NSLP_Context* context, reservereq* reservemsg, rmf* rmf_adm);
    8490  error_t  process_rsn_and_qspec(NSLP_Context* context, reservereq* reservemsg, rmf* rmf_admin,
    85                                  bool is_qni, bool is_qnr, bool& forw, const sessionid* local_sid, const ntlp::mri_pathcoupled* rcvd_mri);
     91                                 bool is_qni, bool is_qnr, bool& forw, const ntlp::sessionid* local_sid, const ntlp::mri_pathcoupled* rcvd_mri,
     92                                 bool down);
    8693  void send_response_with_rii(rii* rcvd_rii, bool is_qnr, bool down, const ntlp::sessionid* sid, const ntlp::mri_pathcoupled* rcvd_mri,
    8794                              info_spec::errorclass_t e_class, info_spec::errorcode_t e_code);
     
    9198  void process_response_msg(known_nslp_pdu* known_pdu, bool down,
    9299                            const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri);
    93   void process_notify_msg(known_nslp_pdu* known_pdu, bool down, const ntlp::sessionid* rcvd_sid);
    94   void forward_response_msg(responsemsg* response, bool down, const ntlp::mri_pathcoupled* rcvd_mri, const sessionid* sid);
     100  void process_notify_msg(known_nslp_pdu* known_pdu, bool down, const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri,
     101                          error_t& nslpres);
     102  void forward_notify_msg(notifymsg* notify, bool down, const ntlp::mri_pathcoupled* rcvd_mri, const ntlp::sessionid* sid);
     103  void forward_response_msg(responsemsg* response, bool down, const ntlp::mri_pathcoupled* rcvd_mri, const ntlp::sessionid* sid);
    95104  void process_info_spec_for_appl(info_spec* info_spec, NSLP_Context* context, const ntlp::sessionid* rcvd_sid); 
    96   error_t process_outgoing_query(known_nslp_pdu& pdu, bool down, const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri);
     105  error_t process_outgoing_query(known_nslp_pdu& pdu, bool down, const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri,
     106                                 ntlp::Flowstatus *fs);
    97107  void process_query_msg(known_nslp_pdu* known_pdu, bool down, const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri);
    98108  void send_response_to_query(rii* r, qspec_object* q, bool down, const ntlp::sessionid* sid, const ntlp::mri_pathcoupled* rcvd_mri);
    99109  void create_and_send_reserve_msg_as_response_to_query(bool send_rii, qspec_object* q, const bound_sessionid* b,
    100                                                         bool down, const ntlp::sessionid* sid, const ntlp::mri_pathcoupled* rcvd_mri);
     110                                                        bool down, const ntlp::sessionid* sid, const ntlp::mri_pathcoupled* rcvd_mri,
     111                                                        NSLP_Context *context);
    101112  void forward_query_msg(querymsg* q, bool down, const ntlp::sessionid* sid, const ntlp::mri_pathcoupled* rcvd_mri);
    102113  void notify_application(NSLP_Context* context, QoS_Appl_Msg::qos_info_type_t info, const ntlp::sessionid* rcvd_sid);
     
    104115  void retransmit_message(NSLP_Context* context, rii* context_rii, bool down,
    105116                                        const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri);
    106   void send_reserve_with_tear_down_on_the_old_path(NSLP_Context* context, const ntlp::sessionid* rcvd_sid,
    107                                                    const ntlp::mri_pathcoupled* rcvd_mri);
     117  void send_reserve_with_tear_on_the_old_path(NSLP_Context* context, const ntlp::sessionid* rcvd_sid,
     118                                              const ntlp::mri_pathcoupled* rcvd_mri, bool down);
    108119  void copy_reserve_message(const reservereq* source, reservereq* dest);
    109120  void copy_query_message(const querymsg* source, querymsg* dest);
    110   void process_sii_handle(uint32 sii_handle, bool down, const ntlp::sessionid* my_sid, const ntlp::mri_pathcoupled* rcvd_mri);
     121  void copy_notify_message(const notifymsg* source, notifymsg* dest);
     122  void process_sii_handle(uint32 sii_handle, bool down, const ntlp::sessionid* my_sid, const ntlp::mri_pathcoupled* rcvd_mri, APIMsg::error_t status);
    111123  void delete_context(NSLP_Context* context);
     124  void process_mobility(ntlp::mri_pathcoupled *rcvd_mri, ntlp::APIMsg::error_t status);
     125  void send_mobility_refresh(NSLP_Context *context, ntlp::Flowstatus *fs);
     126  void send_notify_on_the_old_path(NSLP_Context* context, const ntlp::sessionid* rcvd_sid,
     127                                                  const ntlp::mri_pathcoupled* rcvd_mri, bool down,
     128                                                  info_spec::errorclass_t e_class, info_spec::errorcode_t e_code);
     129  void create_tunnel_reserve(NSLP_Context *context);
     130 
    112131
    113132  static const char* error_string(error_t err) { return err < error_max_val ? errstr[err] : "** invalid error code, must update error strings **"; }
     
    120139  /// accept unauthenticated messages
    121140  const bool accept_unauthenticated;
    122   hostaddress orig_a4;
    123   hostaddress orig_a6;
    124 
    125   static const char *const errstr[];
     141  AddressList *addresses;
     142  Flowinfo *fi_service;
    126143
    127144  // return whether this node is a last hop for this data flow
    128   bool is_last_signaling_hop(const ntlp::mri_pathcoupled* flow_mri) const;
     145  bool is_last_signaling_hop(const ntlp::mri_pathcoupled* flow_mri, bool down = true) const;
     146  static const char *const errstr[];
    129147
    130148  error_t generate_pdu(const known_nslp_pdu& pdu, NetMsg*& msg);
  • qos-nslp/branches/20090723-multicast/include/nslp_context.h

    r3673 r4213  
    2626 */
    2727
    28 typedef uint64 simple_sid; // shortened sessionid in order to fit into a single 64-bit integer
     28typedef int64 simple_sid; // shortened sessionid in order to fit into a single 64-bit integer
    2929typedef int32 timer_t;    // timer type
    3030
     
    5959        void increment_down_rsn();
    6060        void set_rsn_upstream(uint32 r);
     61        void set_rsn_downstream(uint32 r);
    6162        void set_refresh_period(uint32 r);
    6263        void set_rii_res(uint32 r, rii* temp_rii);
    6364        void set_s_id(const uint128& sid);
    6465        void set_bound_s_id(const uint128& b_sid);
     66        void unset_bound_s_id();
    6567        void set_timer_id_for_reserve_or_query(id_t t);
    6668        void set_timer_id_for_lifetime(id_t t);
     69        void set_timer_id_for_tunnel(id_t t);
    6770        void set_time_to_live(timer_t sec);
    6871        void set_refresh_timer(timer_t sec);
     
    7073        void get_rsn_own(uint32& r);
    7174        void get_rsn_upstream(uint32& r);
     75        void get_rsn_downstream(uint32& r);
    7276        void get_refresh_period(uint32& r);
    7377        void get_rii_res(uint32 r, rii* temp_rii);
     
    7680        void get_timer_id_for_reserve_or_query(id_t& t);
    7781        void get_timer_id_for_lifetime(id_t& t);
     82        void get_timer_id_for_tunnel(id_t& t);
    7883        void get_time_to_live(timer_t& sec);
    7984        void get_refresh_timer(timer_t& sec);
     
    8792        bool get_branchingNode();
    8893        void set_branchingNode(bool branch);
     94        bool get_is_maybe_dead_end();
     95        void set_is_maybe_dead_end(bool dead_end);
    8996        bool get_downstream();
    9097        void set_ReducedRefresh(bool refr);
     
    121128        void set_mri(const ntlp::mri_pathcoupled* set_mri);
    122129        const ntlp::mri_pathcoupled* get_mri() const;
     130        void set_logical_mri(const ntlp::mri_pathcoupled* set_mri);
     131        const ntlp::mri_pathcoupled* get_logical_mri() const;
    123132        void set_context_qspec(qspec_object* set_qspec);
     133        ntlp::mri_pathcoupled* get_old_mri();
    124134        qspec_object* get_context_qspec();
    125135
     
    137147            uint32 rsn_own;
    138148            uint32 rsn_upstream;
     149            uint32 rsn_downstream;
    139150            uint32 refresh_period;
    140151            uint32 retry_counter_for_query;
     
    145156            id_t timer_id_for_reserve_or_query;
    146157            id_t timer_id_for_lifetime;
     158            id_t timer_id_for_tunnel;
    147159            time_t time_to_live;
    148160            time_t refresh_timer;
     
    156168            bool mergingNode;
    157169            bool branchingNode;
     170            bool maybe_dead_end;
    158171            bool in_an_aggregate;
    159172            //nslp_aggregate::aggregator_type_t aggregator_type;
     
    163176            bool downstream;
    164177            ntlp::mri_pathcoupled* context_mri;
     178            ntlp::mri_pathcoupled* old_mri;
     179            ntlp::mri_pathcoupled* logical_mri;
    165180            qspec_object* context_qspec;
    166181
     
    176191typedef contextmap_t::iterator context_hashmap_it_t; 
    177192typedef contextmap_t::const_iterator context_hashmap_const_it_t; 
     193
     194typedef multimap<const ntlp::mri_pathcoupled *, simple_sid,
     195    ntlp::mri_pathcoupled::ltmri> mri2contextmap_t;
     196typedef mri2contextmap_t::iterator mri2context_map_it_t;
     197typedef mri2contextmap_t::const_iterator mri2context_map_const_it_t;
    178198
    179199inline
  • qos-nslp/branches/20090723-multicast/include/qos_nslp_constants.h

    r3673 r4213  
    77  const int REFRESH_PERIOD_default= 5;
    88  // when should the request (RESERVE w/ RII) be resent if no RESPONSE was received
    9   const int QOSNSLP_REQUEST_RETRY_default = 2;
     9  const int QOSNSLP_REQUEST_RETRY_default = 20;
    1010  // maximum retries for retransmitting a RESERVE with RII
    1111  const int MAX_RETRY_COUNTER_default= 3;
  • qos-nslp/branches/20090723-multicast/include/qos_nslp_contextmap.h

    r3673 r4213  
    99#include "nslp_context.h"
    1010#include "sessionid.h"
     11#include "mri_pc.h"
    1112
    1213using namespace protlib;
     
    2324  /// context hashmap stores all NSLP contexts (session states)
    2425  contextmap_t context_hashmap;
     26
     27  /// context multimap that stores sessions with a logical mri associated
     28  mri2contextmap_t mri2context_map;
    2529 
    2630  /// This mutex is used to lock the context map
     
    3640
    3741 public:
     42  class search_context {
     43    public:
     44      search_context() { sidlist = 0; };
     45      ~search_context() { delete sidlist; };
     46
     47      list<simple_sid> *sidlist;
     48      list<simple_sid>::iterator slit;
     49  };
     50
    3851  ContextMap();
    3952  ~ContextMap();
    4053
    4154  NSLP_Context* find(const sessionid& sid);
     55  NSLP_Context* find_first(const mri_pathcoupled& mri, search_context &sc);
     56  NSLP_Context* find_next(search_context &sc);
    4257  bool insert(const sessionid& sid, NSLP_Context* context);
    4358  void erase(const sessionid& sid);
  • qos-nslp/branches/20090723-multicast/include/qosnslp_starter.h

    r4116 r4213  
    3535
    3636        NTLPStarterParam *ntlppar;
     37        AddressList *addresses;
     38        Flowinfo *fi_service;
    3739};
    3840
  • qos-nslp/branches/20090723-multicast/src/Makefile

    r4116 r4213  
    2222QOSOPTIONS      = -D_DEBUG -DQOS_NSLP_13 #-D_NO_LOGGING
    2323
    24 DEBUG_CFLAGS    = -O0 -ggdb
    25 CFLAGS          = -pedantic -Wno-long-long -W -Wall $(DEBUG_CFLAGS) $(QOSOPTIONS) # development (valgrind)
     24CFLAGS          = -pedantic -O0 -g -Wno-long-long  -Wno-deprecated -Werror -Wall $(QOSOPTIONS) # development (valgrind)
     25
     26ifdef USE_FLOWINFO
     27CFLAGS += $(FLOWINFO_CFLAGS)
     28endif
    2629
    2730CLINK           = -c -o
  • qos-nslp/branches/20090723-multicast/src/ProcessingModule.cpp

    r3673 r4213  
    2121#include "queuemanager.h"
    2222
     23// from NTLP
     24#ifdef USE_FLOWINFO
     25#include "flowinfo.h"
     26#endif
     27
    2328// QoS NSLP
    2429#include "all_nslp_ies.h"
     
    4651
    4752  ProcessingModuleParam::ProcessingModuleParam(uint32 sleep_time,
    48                                const hostaddress& oa4, const hostaddress& oa6,
     53                               AddressList &addresses,
     54                               Flowinfo &fi_service,
    4955                               bool see, bool sre
    5056                               )
    5157  : ThreadParam(sleep_time,"QoSProcessing"),
    5258    source(message::qaddr_qos_nslp_signaling),
    53     orig_a4(oa4),
    54     orig_a6(oa6),
     59    addresses(addresses),
     60    fi_service(fi_service),
    5561    send_error_expedited(see),
    5662    send_reply_expedited(sre)
     
    7884        QueueManager::instance()->register_queue(get_fqueue(),p.source);
    7985        DLog(param.name, "Created ProcessingModule object");
    80         statemodule = new state_manager(param.orig_a4, param.orig_a6);
     86        statemodule = new state_manager(param.addresses, param.fi_service);
    8187} // end constructor
    8288
     
    190196        bool downstream = applmsg->get_direction();
    191197        ntlp::mri_pathcoupled *nslp_mri = new ntlp::mri_pathcoupled(source_addr, source_prefix, source_port, dest_addr, dest_prefix, dest_port, "udp", 0, 0, 0, downstream);
    192 
    193198        qos_nslp::known_nslp_pdu::type_t type = applmsg->get_pdu_type();
    194199        switch (type) {
     
    290295        state_manager::error_t nslperror;
    291296        known_nslp_pdu* result_pdu = NULL;
    292         state_manager statemodule(param.orig_a4, param.orig_a6);
     297        state_manager statemodule(param.addresses, param.fi_service);
    293298        APIMsg::subtype_t apimsg_subtype;
    294299
     
    301306        uint32 sii = apimsg->get_sii_handle();
    302307        ntlp::sessionid* rcvd_sid = apimsg->get_sessionid();
     308        apimsg_subtype = apimsg->get_subtype();
    303309
    304310        if (rcvd_sid == NULL) {
    305                 DLog(param.name,"SID is NULL");
     311                if (apimsg_subtype == APIMsg::NetworkNotification) {
     312                        APIMsg::error_t nf_type = apimsg->get_msgstatus();
     313                        DLog("ProcessingModule","Processing mobility event");
     314                        statemodule.process_mobility(rcvd_mri, nf_type);
     315                } else {
     316                        DLog(param.name,"SID is NULL");
     317                }
    306318                return;
    307319        }
    308320
    309321        if (nslp_data == NULL) {
    310                 apimsg_subtype = apimsg->get_subtype();
    311322                DLog(param.name, "SII handle is " << sii);
     323                DLog("ProcessingModule", "NN status is: " << apimsg->get_msgstatus());
    312324                if (apimsg_subtype == APIMsg::NetworkNotification) {
    313325                        bool down = rcvd_mri->get_downstream();
    314                         statemodule.process_sii_handle(sii, down, rcvd_sid, rcvd_mri);
     326                        statemodule.process_sii_handle(sii, down, rcvd_sid, rcvd_mri, apimsg->get_msgstatus());
    315327                }
    316328        } else {
     
    330342                // process NetMsg by NSLP (generates C++ objects from byte stream)
    331343                nslperror = statemodule.process_tp_recv_msg(*netmsg, result_pdu, down, my_sid, rcvd_mri);
    332                 statemodule.process_sii_handle(sii, down, my_sid, rcvd_mri);
     344                if (nslperror != state_manager::error_old_pdu) {
     345                        // it the direction of the MRI is downstream, the message came from the upstream peer
     346                        statemodule.process_sii_handle(sii, !down, my_sid, rcvd_mri, APIMsg::error_msg_delivered);
     347                }
    333348                DLog(param.name, "process_gist_api_msg() - parsed PDU");
    334349
     
    410425    // send it to NSLP
    411426    bool d = sigmsg->get_downstream();
    412     const ntlp::mri_pathcoupled* sig_mri = sigmsg->get_sig_mri();
    413     nslperror = statemodule->process_outgoing(*pdu,netmsg, d, process_sid, sig_mri);
     427    ntlp::mri_pathcoupled* sig_mri = sigmsg->get_sig_mri()->copy();
     428    nslperror = statemodule->process_outgoing(*pdu,netmsg, d, process_sid, &sig_mri);
     429    if (sigmsg->get_allow_translate())
     430      sigmsg->set_sig_mri(sig_mri);
    414431   
    415432    if (nslperror!=state_manager::error_ok)
     
    426443    }
    427444  }
     445  if (sigmsg->get_invalidate()) {
     446    bool downstream = sigmsg->get_downstream();
     447    ntlp::mri_pathcoupled* nslp_mri = NULL;
     448    nslp_mri = sigmsg->get_sig_mri()->copy();
     449    if (downstream != nslp_mri->get_downstream()) {
     450      DLog("ProcessingModule", "Message should be sent " << (downstream?"downstream":"upstream") << ", Inverting MRI");
     451      nslp_mri->invertDirection();
     452    }
     453    ntlp::APIMsg *apimsg = new ntlp::APIMsg();
     454    apimsg->set_source(message::qaddr_api_1);
     455    apimsg->set_invalidateroutingstate(1, nslp_mri, APIMsg::bad, false);
     456    apimsg->send_to(message::qaddr_coordination);
     457  }
     458
    428459} // end process_sig_msg
    429460
     
    434465  : message(type_signaling), pdu(NULL), sig_mri(NULL), sii_handle(0), down(true)
    435466{
     467  translate = true;
     468  invalidate = false;
    436469}
    437470
     
    527560                        continue;
    528561
    529                 EVLog("applmsgchecker", "applmsgchecker received a message");             
     562                EVLog("applmsgchecker", "applmsgchecker received a message");
    530563                applmsg = dynamic_cast<QoS_Appl_Msg*>(msg);
    531564                if (applmsg) {
     
    616649        timer_t time_to_live;
    617650        NSLP_Context* context = NULL;
    618         state_manager statemodule(param.orig_a4, param.orig_a6);
     651        state_manager statemodule(param.addresses, param.fi_service);
    619652        NSLP_Context::rii_hashmap_it_t rii_hit;
    620653 
     
    664697                        reservereq* reserve = NULL;
    665698                        querymsg* query = NULL;
     699                        if (second->is_notify())  {
     700                                statemodule.create_tunnel_reserve(context);
     701                                msg = NULL;
     702                                tmsg = NULL;
     703                                continue;
     704                        }
    666705                        if (second->is_query())  {
    667706                                DLog(param.name, "Param2 is QUERY");
     
    831870            tx_attr.secure =false;
    832871            bool downstream = sigmsg->get_downstream();
    833             ntlp::mri_pathcoupled* nslp_mri = sigmsg->get_sig_mri()->copy();
    834 
     872            ntlp::mri_pathcoupled* nslp_mri = NULL;
     873            nslp_mri = sigmsg->get_sig_mri()->copy();
    835874            if (downstream != nslp_mri->get_downstream()) {
    836875              DLog(param.name, "Message should be sent " << (downstream?"downstream":"upstream") << ", Inverting MRI");
  • qos-nslp/branches/20090723-multicast/src/QoS_StateModule.cpp

    r3673 r4213  
    2727#include <unistd.h>
    2828#include <cmath>
    29 #include <netdb.h>
    3029
    3130using namespace protlib;
     
    6362
    6463  /***** class state_manager *****/
    65   state_manager::state_manager(const hostaddress& oa4, const hostaddress& oa6)
     64  state_manager::state_manager(AddressList &addresses, Flowinfo &fi_service)
    6665    : coding(IE::nslp_v1), accept_unauthenticated(true),
    67     orig_a4(oa4), orig_a6(oa6)  {
     66    addresses(&addresses), fi_service(&fi_service)  {
    6867  }
    6968  /** Default constructor for SESSIONID without any params. The value of SESSIONID will be set to the default.
     
    7170  state_manager::state_manager()
    7271    : coding(IE::nslp_v1), accept_unauthenticated(true)  {
    73         orig_a4.set_ip("127.0.0.1");
    74         orig_a6.set_ip("::1");
    7572        abort();
    7673  }
     
    8885*/
    8986bool
    90 state_manager::is_last_signaling_hop(const ntlp::mri_pathcoupled* flow_mri) const
     87state_manager::is_last_signaling_hop(const ntlp::mri_pathcoupled* flow_mri, bool down) const
    9188{
    9289  // choose own address for comparison according to protocol type
    93   const hostaddress& flow_dest= flow_mri->get_destaddress();
    94   const hostaddress& orig_addr = flow_dest.is_ipv4() ? orig_a4 : orig_a6;
    95 
    96   return (orig_addr == flow_dest) ? true : false;
     90  const hostaddress& flow_dest = down ? flow_mri->get_destaddress() : flow_mri->get_sourceaddress();
     91
     92  // if flow source is my address, I am a QNI
     93  if (addresses->addr_is(flow_dest, AddressList::ConfiguredAddr_P) ||
     94      addresses->addr_is(flow_dest, AddressList::LocalAddr_P))
     95        return true;
     96  else // if flow dest is my address, I am a QNR
     97        return false;
    9798}
    9899
     
    133134        // check for incoming reserve message
    134135        if (known_pdu->is_reserve()) {
    135                 bool updated = find_and_update_context(known_pdu, nslpres, down, sid, rcvd_mri);
     136                bool updated = find_and_update_context(known_pdu, nslpres, down, sid, rcvd_mri, NULL);
    136137                if (!updated)
    137                         create_new_context(*known_pdu, nslpres, down, sid, rcvd_mri);
     138                        create_new_context(*known_pdu, nslpres, down, sid, rcvd_mri, NULL);
    138139                if ((nslpres != error_ok) &&
    139140                    (nslpres != error_ok_send_response) &&
     
    170171
    171172        if (known_pdu->is_notify()) {
    172                 process_notify_msg(known_pdu, down, sid);
     173                process_notify_msg(known_pdu, down, sid, rcvd_mri, nslpres);
    173174                resultpdu = known_pdu;
    174175                // reset to start and set message length correctly,
    175176                // because we will just forward this message
    176177                netmsg.truncate();
    177                 return state_manager::error_nothing_to_do;
     178                return nslpres;
    178179        }
    179180
     
    191192*/
    192193state_manager::error_t state_manager::process_outgoing(known_nslp_pdu& pdu, NetMsg*& netbuffer, bool down,
    193                                                        const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri)
     194                const ntlp::sessionid* rcvd_sid, ntlp::mri_pathcoupled** rcvd_mri)
    194195{
    195196  error_t nslpres = error_ok;
     197  error_t ret_nslpres = error_ok;
    196198  netbuffer = NULL;
    197199  bool updated = false;
    198200  bool processing = false;
    199201  bool is_tear = false;
     202        Flowstatus *fs = NULL;
    200203
    201204  NSLP_Context* context = rcvd_sid ? contextmap.find(*rcvd_sid) : 0;
     205
     206#ifdef USE_FLOWINFO
     207  fs = fi_service->get_flowinfo(**rcvd_mri);
     208  switch (fs->type) {
     209  case ntlp::Flowstatus::fs_normal:
     210    *rcvd_mri = fs->new_mri;
     211    break;
     212  case ntlp::Flowstatus::fs_tunnel:
     213  case ntlp::Flowstatus::fs_nothing:
     214  default:
     215    break;
     216  }
     217  ILog(state_manager::modname, "Flowstatus: " << fs->type << fs->orig_mri << *fs->new_mri);
     218#endif
    202219
    203220  if (rcvd_sid)
     
    207224
    208225  hostaddress orig_a, source_a, dest_a;
    209   source_a = rcvd_mri->get_sourceaddress();
    210   dest_a = rcvd_mri->get_destaddress();
     226  source_a = (*rcvd_mri)->get_sourceaddress();
     227  dest_a = (*rcvd_mri)->get_destaddress();
    211228
    212229  if (pdu.is_notify())
     
    227244  }
    228245
    229   error_t ret_nslpres = error_ok;
    230 
    231246  if ((processing) && (!is_tear)) {
    232247    if (pdu.is_reserve()) {
    233 
    234       updated = find_and_update_context(&pdu, nslpres, down, rcvd_sid, rcvd_mri);
     248      updated = find_and_update_context(&pdu, nslpres, down, rcvd_sid, *rcvd_mri, fs);
    235249      if (!updated)
    236         ret_nslpres = create_new_context(pdu, nslpres, down, rcvd_sid, rcvd_mri);
     250        ret_nslpres = create_new_context(pdu, nslpres, down, rcvd_sid, *rcvd_mri, fs);
    237251    }
    238252    if ((ret_nslpres!=error_ok) &&
     
    248262  if (pdu.is_query()) {
    249263    ILog(state_manager::modname, color[magenta] << "Outgoing QUERY message!" << color[off]);
    250                
    251264    ret_nslpres = error_ok;
    252265    querymsg* query = dynamic_cast<querymsg*>(&pdu);
     
    257270      rii* check_rii = query->get_rii();
    258271      if (check_rii) {
    259         if ( ( down && is_last_signaling_hop(rcvd_mri) )  || ( down == false ) ) {
     272        if ( ( down && is_last_signaling_hop(*rcvd_mri) )  || ( down == false ) ) {
    260273          // this situation should not happen, QNR MAY send QUERY msgs ONLY w/o RII
    261274          ret_nslpres = error_nothing_to_do;
     
    266279      else
    267280        { // no RII object present
    268           if ( ( down || ((!down) && is_last_signaling_hop(rcvd_mri) ) )
     281          if ( ( down || ((!down) && is_last_signaling_hop(*rcvd_mri) ) )
    269282               && query->is_reserve_init_flag() == false ) {
    270283            // this situation should not happen, QNI MAY send QUERY msgs ONLY with RII
     
    277290               
    278291    if (i_am_originator && continue_it)
    279       ret_nslpres = process_outgoing_query(pdu, down, rcvd_sid, rcvd_mri);
     292      ret_nslpres = process_outgoing_query(pdu, down, rcvd_sid, *rcvd_mri, fs);
    280293
    281294    if (ret_nslpres!=error_ok) {
     
    287300  }
    288301
     302  if (is_last_signaling_hop(*rcvd_mri, down)) {
     303    ERRLog(state_manager::modname, "Trying to send message to myself - I'll stop right here!");
     304    if (netbuffer)
     305      delete netbuffer;
     306    netbuffer = NULL;
     307    return error_nothing_to_do;
     308  }
    289309  // now serialize
    290310  nslpres = generate_pdu(pdu,netbuffer);
     
    297317  return nslpres;
    298318} // end process_outgoing
    299 
    300 
    301319
    302320/** processes received QUERY message.
     
    383401    }  // end if RII existing
    384402    else {
    385       ERRLog(state_manager::modname, "Reservation existing! Wrong message requesting new reservation!!!");
     403      // if I'm the QNR I should respond to the Query
     404      if ( query->is_reserve_init_flag() && is_last_signaling_hop(rcvd_mri) ) {
     405        // create RESERVE msg, send to QUERY initiator
     406        create_and_send_reserve_msg_as_response_to_query(true, q, rcvd_b_sid, !down, rcvd_sid, rcvd_mri, context);
     407      }
     408      else if (query->is_reserve_init_flag()) {
     409        forward_query_msg(query, down, rcvd_sid, rcvd_mri);
     410      }
     411      else { // I'm a QNE, so simply forward this QUERY
     412        ERRLog(state_manager::modname, "Reservation existing! Wrong message requesting new reservation!!!");
     413      }
    386414    }
    387415
     
    424452      // if it RII is present, it cannot have the R flag set
    425453      ILog(state_manager::modname, "RII existing!");
     454      // XXX: this test should be "is_last_signaling_hop(rcvd_mri)" ?!?
    426455      if (type == NSLP_Context::QNR) {
    427456        send_response_to_query(r, q, !down, rcvd_sid, rcvd_mri);
     
    441470      if ( query->is_reserve_init_flag() && is_last_signaling_hop(rcvd_mri) ) {
    442471        // create RESERVE msg, send to QUERY initiator
    443         create_and_send_reserve_msg_as_response_to_query(true, q, rcvd_b_sid, !down, rcvd_sid, rcvd_mri);
     472        create_and_send_reserve_msg_as_response_to_query(true, q, rcvd_b_sid, !down, rcvd_sid, rcvd_mri, 0);
    444473      }
    445474      else { // I'm a QNE, so simply forward this QUERY
     475        // HA TEnter
     476        if (down && addresses->addr_is_in(rcvd_mri->get_destaddress(), AddressList::HomeNet_P)) {
     477          ntlp::mri_pathcoupled *logical_tmri = rcvd_mri->copy();
     478          hostaddress *my_src = dynamic_cast<hostaddress *>(addresses->get_first(AddressList::HAAddr_P, rcvd_mri->get_destaddress().is_ipv4()));
     479          logical_tmri->set_sourceaddress(*my_src);
     480
     481          uint128 tsid;
     482
     483          querymsg* tunnel_query = new querymsg();
     484          copy_query_message(query, tunnel_query);
     485
     486          tunnel_query->set_originator(true);
     487          known_nslp_pdu *pdu = dynamic_cast<known_nslp_pdu*>(tunnel_query);
     488          SignalingMsg* sigmsg = new SignalingMsg();
     489          sigmsg->set_msg(pdu);
     490
     491          sigmsg->set_sig_mri(logical_tmri);
     492
     493          sigmsg->set_downstream(down);
     494
     495          ntlp::sessionid* sid = new sessionid();
     496          sid->generate_random();
     497          sid->generate_random();
     498          tsid = *sid;
     499
     500          bound_sessionid* send_bs = new bound_sessionid();
     501          send_bs->set(tsid);
     502
     503          query->set_bound_sid(send_bs);
     504
     505          sigmsg->set_sid(tsid);
     506          sigmsg->send_or_delete();
     507        }
     508
    446509        forward_query_msg(query, down, rcvd_sid, rcvd_mri);
    447510      }
     
    451514  ILog(state_manager::modname,"END process_query_msg()");
    452515}
    453 
    454516
    455517/** processes outgoing QUERY message.
     
    460522 */
    461523state_manager::error_t state_manager::process_outgoing_query(known_nslp_pdu& pdu, bool down, const ntlp::sessionid* rcvd_sid,
    462                   const ntlp::mri_pathcoupled* rcvd_mri)
     524                  const ntlp::mri_pathcoupled* rcvd_mri, ntlp::Flowstatus *fs)
    463525{
    464526  error_t nslpres = error_ok;
     
    607669      context->set_reserved(false);
    608670      context->set_mri(rcvd_mri);
     671      if (fs)
     672        context->set_logical_mri(&fs->orig_mri);
     673      else
     674        context->set_logical_mri(rcvd_mri);
    609675      context->unlock();
     676
     677      // In tunnel mode send a QUERY-T
     678      if (fs && fs->type == ntlp::Flowstatus::fs_tunnel) {
     679        uint128 tsid;
     680
     681        querymsg* tunnel_query = new querymsg();
     682        copy_query_message(query, tunnel_query);
     683
     684/*
     685        if (query->get_bool_rii()) {
     686          rii* new_rii = new rii();
     687          new_rii->generate_new();
     688          new_rii->set_own(true);
     689          tunnel_query->set_rii(new_rii);
     690        }
     691 */
     692
     693        tunnel_query->set_originator(true);
     694        known_nslp_pdu *pdu = dynamic_cast<known_nslp_pdu*>(tunnel_query);
     695        SignalingMsg* sigmsg = new SignalingMsg();
     696        sigmsg->set_msg(pdu);
     697
     698        ntlp::mri_pathcoupled *logical_tmri = fs->new_mri->copy();
     699        if (type == NSLP_Context::QNI)
     700          logical_tmri->set_sourceaddress(fs->orig_mri.get_sourceaddress());
     701        else
     702          logical_tmri->set_destaddress(fs->orig_mri.get_destaddress());
     703        sigmsg->set_sig_mri(logical_tmri);
     704
     705        sigmsg->set_downstream(down);
     706
     707        ntlp::sessionid* sid = new sessionid();
     708        sid->generate_random();
     709        tsid = *sid;
     710
     711        bound_sessionid* send_bs = new bound_sessionid();
     712        send_bs->set(tsid);
     713
     714        query->set_bound_sid(send_bs);
     715
     716        sigmsg->set_sid(tsid);
     717        sigmsg->send_or_delete();
     718      }
    610719
    611720      rii* r = query->get_rii();
     
    736845 */
    737846state_manager::error_t state_manager::create_new_context(known_nslp_pdu& pdu, error_t& nslpres, bool down,
    738                                                          const ntlp::sessionid* local_sid, const ntlp::mri_pathcoupled* rcvd_mri)
     847                                                         const ntlp::sessionid* local_sid, const ntlp::mri_pathcoupled* rcvd_mri, ntlp::Flowstatus *fs)
    739848  {
    740849          reservereq* reservemsg = NULL;
     
    783892          local_context->set_downstream(down);
    784893          local_context->set_mri(rcvd_mri);
     894          if (fs)
     895            local_context->set_logical_mri(&fs->orig_mri);
     896          else
     897            local_context->set_logical_mri(rcvd_mri);
    785898          local_context->unlock();
    786899
    787900          reservemsg = dynamic_cast<reservereq*>(&pdu);
     901
     902          if (fs && fs->type == ntlp::Flowstatus::fs_tunnel && type != NSLP_Context::QNR) {
     903                uint128 tsid;
     904
     905                reservereq* tunnel_res = new reservereq();
     906                copy_reserve_message(reservemsg, tunnel_res);
     907
     908                rsn* new_rsn = new rsn();
     909                new_rsn->generate_new();
     910                tunnel_res->set_rsn(new_rsn);
     911
     912                if (reservemsg->get_bool_rii()) {
     913                        rii* new_rii = new rii();
     914                        new_rii->generate_new();
     915                        new_rii->set_own(true);
     916                        tunnel_res->set_rii(new_rii);
     917                }
     918
     919                tunnel_res->set_originator(true);
     920
     921                known_nslp_pdu *pdu = dynamic_cast<known_nslp_pdu*>(tunnel_res);
     922                SignalingMsg* sigmsg = new SignalingMsg();
     923                sigmsg->set_msg(pdu);
     924
     925                ntlp::mri_pathcoupled *logical_tmri = fs->new_mri->copy();
     926                if (type == NSLP_Context::QNI)
     927                        logical_tmri->set_sourceaddress(fs->orig_mri.get_sourceaddress());
     928                else
     929                        logical_tmri->set_destaddress(fs->orig_mri.get_destaddress());
     930                sigmsg->set_sig_mri(logical_tmri);
     931
     932                sigmsg->set_downstream(true);
     933
     934                ntlp::sessionid* sid = new sessionid();
     935                sid->generate_random();
     936                tsid = *sid;
     937
     938                bound_sessionid* send_bs = new bound_sessionid();
     939                send_bs->set(tsid);
     940                reservemsg->set_bound_sid(send_bs);
     941               
     942                sigmsg->set_sid(tsid);
     943                sigmsg->send_or_delete();
     944        }
     945
     946        // HA as TEnter ... a bit of guess work
     947        if (down && type == NSLP_Context::QNE && addresses->addr_is_in(rcvd_mri->get_destaddress(), AddressList::HomeNet_P)) {
     948                ILog(state_manager::modname, "HA TEnter for: " << *rcvd_mri);
     949
     950                ntlp::mri_pathcoupled *logical_tmri = rcvd_mri->copy();
     951                hostaddress *my_src = dynamic_cast<hostaddress *>(addresses->get_first(AddressList::HAAddr_P, rcvd_mri->get_destaddress().is_ipv4()));
     952                logical_tmri->set_sourceaddress(*my_src);
     953
     954                ILog(state_manager::modname, "Tunnel MRI: " << *logical_tmri);
     955               
     956                uint128 tsid;
     957
     958                reservereq* tunnel_res = new reservereq();
     959                copy_reserve_message(reservemsg, tunnel_res);
     960
     961                rsn* new_rsn = new rsn();
     962                new_rsn->generate_new();
     963                tunnel_res->set_rsn(new_rsn);
     964
     965                if (reservemsg->get_bool_rii()) {
     966                        rii* new_rii = new rii();
     967                        new_rii->generate_new();
     968                        new_rii->set_own(true);
     969                        tunnel_res->set_rii(new_rii);
     970                }
     971
     972                tunnel_res->set_originator(true);
     973
     974                known_nslp_pdu *pdu = dynamic_cast<known_nslp_pdu*>(tunnel_res);
     975                SignalingMsg* sigmsg = new SignalingMsg();
     976                sigmsg->set_msg(pdu);
     977
     978                sigmsg->set_sig_mri(logical_tmri);
     979
     980                sigmsg->set_downstream(true);
     981
     982                ntlp::sessionid* sid = new sessionid();
     983                sid->generate_random();
     984                tsid = *sid;
     985
     986                bound_sessionid* send_bs = new bound_sessionid();
     987                send_bs->set(tsid);
     988                reservemsg->set_bound_sid(send_bs);
     989               
     990                sigmsg->set_sid(tsid);
     991                sigmsg->send_or_delete();
     992        }
    788993
    789994          // if Originator, save rii to match response, forward the message
     
    7961001          if (reservemsg->is_tear_flag()) {
    7971002                  ILog(state_manager::modname, "TEAR-DOWN Flag set!");
    798                   if (type == NSLP_Context::QNE) {
    799                     forward_reserve(reservemsg, local_context, down, rcvd_mri);
    800                     nslpres = error_ok_forward;
    801                   }
    802                   else
    803                     nslpres = error_nothing_to_do;
    804 
     1003                  if (type == NSLP_Context::QNE)
     1004                          forward_reserve(reservemsg, local_context, down, rcvd_mri);
     1005                  nslpres = error_nothing_to_do;
    8051006                  local_context = NULL;
    8061007                  return nslpres;
     
    8371038                          rsn_down->get(rsn_number_down);
    8381039                          local_context->lock();
    839                           local_context->set_rsn_upstream(rsn_number_up);
     1040                          // if the RESERVE is sent downstream the RSN is that of the upstream peer and vice versa
     1041                          if (down)
     1042                            local_context->set_rsn_upstream(rsn_number_up);
     1043                          else
     1044                            local_context->set_rsn_downstream(rsn_number_up);                         
    8401045                          local_context->set_rsn_own(rsn_number_down);
    8411046                          local_context->unlock();
     
    8451050                          rsn_number_down = 0;
    8461051                          local_context->lock();
    847                           local_context->set_rsn_upstream(rsn_number_up);
     1052                          // if the RESERVE is sent downstream the RSN is that of the upstream peer and vice versa
     1053                          if (down)
     1054                            local_context->set_rsn_upstream(rsn_number_up);
     1055                          else
     1056                            local_context->set_rsn_downstream(rsn_number_up);
    8481057                          local_context->set_rsn_own(rsn_number_down);
    8491058                          local_context->unlock();
     
    10061215                          forward_reserve(reservemsg, local_context, down, rcvd_mri);
    10071216                          // nslpres is still error_ok_forward
     1217                          // XXX or error_ok_forward !?!
    10081218                  }
    10091219
    10101220                  // start timer for lifetime of the state
    10111221                  id_t check_lifetime_id;
    1012                   sessionid* lifetime_sid = local_sid->copy();
     1222                  ntlp::sessionid* lifetime_sid = local_sid->copy();
    10131223                  tmsg = new TimerMsg(message::qaddr_qos_nslp_timerprocessing);
    10141224                  check_lifetime_id = tmsg->get_id();
     
    10281238                  if (((!i_am_originator) && (type == NSLP_Context::QNE) && (!(reservemsg->is_scoping_flag()))) || (i_am_originator)) {
    10291239                          id_t check_refresh_id;
    1030                           sessionid* refresh_sid = local_sid->copy();
     1240                          ntlp::sessionid* refresh_sid = local_sid->copy();
    10311241                          tmsg = new TimerMsg(message::qaddr_qos_nslp_timerprocessing);
    10321242                          check_refresh_id = tmsg->get_id();
     
    11311341          timer_reserve->set_bool_rp(true);
    11321342          // start timer with two parameters: SESSIONID and RESERVE message (it is easier process elapsed timer)
    1133           sessionid* local_sid= new sessionid(my_sid);
     1343          ntlp::sessionid* local_sid= new sessionid(my_sid);
    11341344          tmsg_refresh->start_absolute(t_refresh, 0, local_sid, timer_reserve);
    11351345          if (tmsg_refresh->send_to(message::qaddr_timer))
     
    11621372          // For simplicity, extract v4-mapped address for v4 case
    11631373          in6_addr addr6;
    1164           if (rcvd_mri->get_destaddress().is_ipv4())
    1165                   orig_a4.get_ip(addr6);
    1166           else
    1167                   orig_a6.get_ip(addr6);
     1374          netaddress *na = addresses->get_first(AddressList::ConfiguredAddr_P,
     1375              rcvd_mri->get_destaddress().is_ipv4());
     1376          na->get_ip(addr6);
     1377          delete(na);
    11681378
    11691379          info_spec* send_error = new info_spec(&addr6, info_spec::success,
     
    12051415                  info_spec::errorclass_t e_class, info_spec::errorcode_t e_code)
    12061416  {
     1417          uint128 local_sid;
    12071418          uint32 number_rii;
    1208           uint128 local_sid;
    12091419          ILog(state_manager::modname, "send_response_with_rii()");
    12101420
     
    12181428          // For simplicity, extract v4-mapped address for v4 case
    12191429          in6_addr addr6;
    1220           if (rcvd_mri->get_destaddress().is_ipv4())
    1221                   orig_a4.get_ip(addr6);
    1222           else
    1223                   orig_a6.get_ip(addr6);
     1430          netaddress *na = addresses->get_first(AddressList::ConfiguredAddr_P,
     1431              rcvd_mri->get_destaddress().is_ipv4());
     1432          na->get_ip(addr6);
     1433          delete(na);
    12241434
    12251435          info_spec* send_error = new info_spec(&addr6, e_class, e_code, 0);
     
    12501460  {
    12511461          uint32 number_rsn;
    1252           ILog(state_manager::modname, "send_response_with_rsn()");
     1462          ILog("QOS_STATEMODULE", "send_response_with_rsn()");
    12531463
    12541464          known_nslp_pdu* pdu = new responsemsg;
     
    12611471          // For simplicity, extract v4-mapped address for v4 case
    12621472          in6_addr addr6;
    1263           if (rcvd_mri->get_destaddress().is_ipv4())
    1264                   orig_a4.get_ip(addr6);
    1265           else
    1266                   orig_a6.get_ip(addr6);
     1473          netaddress *na = addresses->get_first(AddressList::ConfiguredAddr_P,
     1474              rcvd_mri->get_destaddress().is_ipv4());
     1475          na->get_ip(addr6);
     1476          delete(na);
    12671477
    12681478          info_spec* tmp = new info_spec(&addr6, e_class, e_code, 0);
     
    13151525 */
    13161526void state_manager::create_and_send_reserve_msg_as_response_to_query(bool send_rii, qspec_object* q, const bound_sessionid* b,
    1317                                                             bool down, const ntlp::sessionid* sid, const ntlp::mri_pathcoupled* rcvd_mri)
     1527                                                            bool down, const ntlp::sessionid* sid, const ntlp::mri_pathcoupled* rcvd_mri,
     1528                                                            NSLP_Context *context)
    13181529{
    13191530    DLog(state_manager::modname,"create_and_send_reserve_msg_as_response_to_query()");
     
    13341545    res->set_originator(true); // we are originator of the RESERVE
    13351546    rsn* send_rsn = new rsn();
    1336     send_rsn->get(n);
     1547    if (context) {
     1548        context->lock();
     1549        context->increment_down_rsn();
     1550        context->increment_down_rsn();
     1551        context->get_rsn_own(n);
     1552        context->unlock();
     1553    } else {
     1554        send_rsn->get(n);
     1555    }
     1556    send_rsn->set(n);
    13371557    res->set_rsn(send_rsn);
    13381558
     
    13561576    }
    13571577    uint128 local_sid= *sid;
     1578    if (context)
     1579        res->set_replace_flag();
    13581580    pdu = dynamic_cast<known_nslp_pdu*>(res);
    13591581
    1360     error_t ret_nslpres = create_new_context(*pdu, ret_nslpres, down, sid, rcvd_mri);
    1361     if (ret_nslpres != error_ok) {
    1362       ERRLog(state_manager::modname,"create_and_send_reserve_msg_as_response_to_query() - unexpected error while creating context");
     1582    if (context == NULL) {
     1583        error_t ret_nslpres = create_new_context(*pdu, ret_nslpres, down, sid, rcvd_mri, 0);
     1584        if (ret_nslpres != error_ok) {
     1585            ERRLog(state_manager::modname,"create_and_send_reserve_msg_as_response_to_query() - unexpected error while creating context");
     1586        }
    13631587    }
    13641588
     
    14561680 * @param rcvd_mri the MRI of the current session.
    14571681 */
    1458 state_manager::error_t  state_manager::process_rii(NSLP_Context* context, reservereq* reservemsg, const sessionid* local_sid,
     1682state_manager::error_t  state_manager::process_rii(NSLP_Context* context, reservereq* reservemsg, const ntlp::sessionid* local_sid,
    14591683                                 TimerMsg* rii_tmsg, bool is_qni, bool is_qnr, bool down, const ntlp::mri_pathcoupled* rcvd_mri)
    14601684{
     
    14911715          // in case that a received RII is equal to the own saved RII send response with error
    14921716          if (saved_rii) {
     1717//XXX: retransmissions are broken!
     1718//TODO:     rcvd_rii->get_retry_counter(n);
    14931719            if (!rcvd_rii->get_own()) {
    14941720              Log(ERROR_LOG,LOG_NORMAL,state_manager::modname, "Another node has sent a message with the duplicated RII!!!");
     
    14991725              return nslpres;
    15001726            }
    1501             else {
     1727            else /* TODO: if (n == 0) */ {
    15021728              Log(ERROR_LOG,LOG_NORMAL,state_manager::modname, "I am trying to send a message with the duplicated RII!!!");
    15031729              rcvd_rii->generate_new();
    15041730            }
     1731// TODO:    else
     1732//            check_it_again = false;
    15051733          }
    15061734        }
     
    15381766      timer_reserve->set_bool_rp(false);
    15391767     
    1540       double repeat = pow((double)QOSNSLP_REQUEST_RETRY_default, (double)n);
     1768      double repeat = pow((double)QOSNSLP_REQUEST_RETRY_default, (double)(n + 1));
    15411769      timer_t rii_t = time(NULL) + (int)repeat;
    15421770
    15431771
    15441772      uint128 sid= *local_sid;
    1545       sessionid* timer_sid = new sessionid(sid);
     1773      ntlp::sessionid* timer_sid = new sessionid(sid);
    15461774      rii_tmsg->start_absolute(rii_t, msec, timer_sid, timer_reserve);
    15471775      if (rii_tmsg->send_to(message::qaddr_timer))
     
    17081936}
    17091937
     1938/** This function copies NOTIFY message.
     1939 * @param source the source NOTIFY message.
     1940 * @param dest the destination NOTIFY message.
     1941 */
     1942void
     1943state_manager::copy_notify_message(const notifymsg* source, notifymsg* dest)
     1944{
     1945    Log(INFO_LOG,LOG_NORMAL,state_manager::modname,"copy_notify_message()");
     1946    bool orig = source->get_originator();
     1947    dest->set_originator(orig);
     1948
     1949    bound_sessionid* bs = source->get_bound_sid();
     1950    if (bs) {
     1951        uint128 s;
     1952        bs->get(s);
     1953        bound_sessionid* send_bs = new bound_sessionid(s);
     1954        dest->set_bound_sid(send_bs);
     1955        bs = NULL;
     1956    }
     1957    qspec_object* qs = source->get_qspec();
     1958    if (qs) {
     1959        qspec::qspec_pdu* q_class = qs->get_qspec_class();
     1960        qspec_object* send_qspec = new qspec_object(q_class);
     1961        dest->set_qspec(send_qspec);
     1962        qs = NULL;
     1963    }
     1964    info_spec* err_obj = source->get_errorobject();
     1965    if (err_obj) {
     1966        info_spec *send_err_obj = new info_spec(*err_obj);
     1967        dest->set_errorobject(send_err_obj);
     1968    }
     1969
     1970    if (source->is_scoping_flag()) {
     1971        dest->set_scoping_flag();
     1972    }
     1973    if (source->is_reserve_init_flag()) {
     1974        dest->set_reserve_init_flag();
     1975    }
     1976    Log(INFO_LOG,LOG_NORMAL,state_manager::modname,"END copy_notify_message()");
     1977}
     1978
     1979
    17101980/** This function processes the QSPEC object from a received message or for the message to be sent.
    17111981 * @param context the NSLP context of the current session.
     
    17492019state_manager::error_t  state_manager::process_rsn_and_qspec(NSLP_Context* context, reservereq* reservemsg,
    17502020                                           rmf* rmf_admin, bool is_qni, bool is_qnr, bool& forw,
    1751                                            const sessionid* local_sid, const ntlp::mri_pathcoupled* rcvd_mri)
     2021                                           const ntlp::sessionid* local_sid, const ntlp::mri_pathcoupled* rcvd_mri,
     2022                                           bool down)
    17522023{
    17532024    error_t nslpres = error_ok;
     
    17682039    else {
    17692040        context->lock();
    1770         context->get_rsn_upstream(local_rsn_upstream);
     2041        if (down)
     2042          context->get_rsn_upstream(local_rsn_upstream);
     2043        else
     2044          context->get_rsn_downstream(local_rsn_upstream);
    17712045        context->unlock();
    17722046    }
    17732047    send_rsn->get(rcvd_rsn_upstream);
     2048    Log(INFO_LOG,LOG_NORMAL,"QOS_STATEMODULE","RSNs: " << local_rsn_upstream << " <= " << rcvd_rsn_upstream);
    17742049   
    17752050    //======================================== process REFRESH_PERIOD ================================================
     
    18402115        else {
    18412116          context->lock();
    1842           context->set_rsn_upstream(rcvd_rsn_upstream);
     2117          if (down)
     2118            context->set_rsn_upstream(rcvd_rsn_upstream);
     2119          else
     2120            context->set_rsn_downstream(rcvd_rsn_upstream);
    18432121          context->increment_down_rsn();
    18442122          context->unlock();
     
    18792157 */
    18802158bool state_manager::find_and_update_context(known_nslp_pdu* pdu, error_t& nslpres, bool down,
    1881                                    const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri)
     2159                                   const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri,
     2160                                   ntlp::Flowstatus *fs)
    18822161{
    18832162    //=============================================== declare variables ===============================================
    18842163    bool updated = false;
     2164    reservereq* reservemsg;
    18852165    bool forward = false;
    18862166    error_t function_res = error_ok;
     
    18932173    // context is found, update it if necessary
    18942174    if (context) {
     2175      reservemsg = dynamic_cast<reservereq*>(pdu);
    18952176      NSLP_Context::qn_type_t type= NSLP_Context::QNE;
     2177      // if this is not a replace, make sure the MRI is okay
     2178      if (!reservemsg->is_replace_flag()) {
     2179                ntlp::mri_pathcoupled *my_mri;
     2180
     2181                context->lock();
     2182                my_mri = context->get_mri()->copy();
     2183                context->unlock();
     2184
     2185                if (my_mri->get_sourceaddress() != rcvd_mri->get_sourceaddress()) {
     2186                        // if this isn't supposed to be a replace, drop it
     2187                        nslpres = error_old_pdu;
     2188                        return true;
     2189                }
     2190                if (my_mri->get_destaddress() != rcvd_mri->get_destaddress()) {
     2191                        // if this isn't supposed to be a replace, drop it
     2192                        nslpres = error_old_pdu;
     2193                        return true;
     2194                }
     2195      } else {
     2196                ntlp::mri_pathcoupled *my_mri;
     2197                bool mergingNode;
     2198
     2199                context->lock();
     2200                my_mri = context->get_mri()->copy();
     2201                mergingNode = context->get_mergingNode();
     2202                context->unlock();
     2203
     2204                if (mergingNode &&
     2205                    (my_mri->get_sourceaddress() != rcvd_mri->get_sourceaddress() ||
     2206                    my_mri->get_destaddress() != rcvd_mri->get_destaddress())) {
     2207                        ILog("QOS_STATEMODULE", "I'm CRN - sending NOTIFY");
     2208                        context->lock();
     2209                        context->set_mergingNode(false);
     2210                        context->unlock();                     
     2211
     2212                        send_notify_on_the_old_path(context, rcvd_sid, my_mri, !down, info_spec::information, info_spec::RouteChange);
     2213                }
     2214      }
    18962215      context->lock();
    18972216      type= context->get_qn_type();
     
    19172236      context->set_mri(rcvd_mri);
    19182237      context->unlock();
     2238       
    19192239
    19202240      reservereq* reservemsg= dynamic_cast<reservereq*>(pdu);
     
    19672287            else
    19682288              nslpres = error_nothing_to_do;
    1969 
    19702289            delete_context(context);
    19712290
     
    19792298        if (send_rsn) {
    19802299            function_res = process_rsn_and_qspec(context, reservemsg, rmf_admin, i_am_originator, type == NSLP_Context::QNR,
    1981                                                  forward, rcvd_sid, rcvd_mri);
     2300                                                 forward, rcvd_sid, rcvd_mri, down);
    19822301            if (function_res != error_ok) {
    19832302                nslpres = function_res;
     
    21252444{
    21262445  // release reserved ressources, stop timer for lifetime, delete state
    2127   uint128 s_sid;
     2446  uint128 s_sid, b_sid;
     2447  bool bound_session;
    21282448  context->lock();
    21292449  context->get_s_id(s_sid);
     2450  bound_session = context->get_bound_s_id(b_sid);
    21302451  qspec_object* local_qspec = context->get_context_qspec();
     2452  const ntlp::mri_pathcoupled *mri = context->get_mri();
    21312453  context->unlock();
    21322454  qspec_pdu* q_pdu = local_qspec->get_qspec_class();
     
    21432465  tmsg->send_to(message::qaddr_timer);
    21442466  if (stop) { Log(INFO_LOG,LOG_NORMAL,state_manager::modname,"LIFETIME " << lifetime_timer_id << "  timer stopped!"); }
    2145   sessionid* sid = new sessionid(s_sid);
     2467  ntlp::sessionid* sid = new sessionid(s_sid);
    21462468  contextmap.erase(*sid);
    21472469  Log(INFO_LOG,LOG_NORMAL,state_manager::modname,"Context deleted!");
     2470
     2471  SignalingMsg *sigmsg = new SignalingMsg();
     2472  sigmsg->set_sig_mri(mri);
     2473  sigmsg->set_msg(0);
     2474  sigmsg->set_downstream(true);
     2475  sigmsg->set_invalidate(true);
     2476  sigmsg->send_or_delete();
     2477
     2478  sigmsg = new SignalingMsg();
     2479  sigmsg->set_sig_mri(mri);
     2480  sigmsg->set_msg(0);
     2481  sigmsg->set_downstream(false);
     2482  sigmsg->set_invalidate(true);
     2483  sigmsg->send_or_delete();
     2484
    21482485  tmsg = NULL;
     2486
     2487  if (bound_session) {
     2488        sid = new sessionid(b_sid);
     2489        NSLP_Context *t_context = contextmap.find(*sid);
     2490        if (t_context) {
     2491                NSLP_Context::qn_type_t type;
     2492
     2493                t_context->lock();
     2494                type = t_context->get_qn_type();
     2495                t_context->unlock();
     2496
     2497                if (type ==  NSLP_Context::QNI)
     2498                        delete_context(t_context);
     2499        }
     2500  }
    21492501}
    21502502
     
    22242576                                //if branching node check whether to tear down the reservation on the old path
    22252577                                context->lock();
    2226                                 if ((context->get_branchingNode()) && (context->get_replace())) {
     2578                                if ((context->get_branchingNode()) && (context->get_replace()) && type != NSLP_Context::QNI) {
    22272579                                        context->set_branchingNode(false);
    22282580                                        context->unlock();
    2229                                         send_reserve_with_tear_down_on_the_old_path(context, rcvd_sid, rcvd_mri);
     2581                                        send_reserve_with_tear_on_the_old_path(context, rcvd_sid, rcvd_mri, !down);
    22302582                                        return;
    22312583                                }
    2232                                 else
     2584                                else {
     2585                                        ILog(state_manager::modname, "Checking to see if we should send a TEAR");
     2586                                        if (context->get_branchingNode()) {
     2587                                                ILog(state_manager::modname, "Looks like it, looking up old MRI");
     2588                                                ntlp::mri_pathcoupled *old_mri;
     2589                                                context->set_branchingNode(false);
     2590                                                old_mri = context->get_old_mri();
     2591                                                if (old_mri) {
     2592                                                        context->unlock();
     2593                                                        ILog(state_manager::modname, "Branching node - sending TEAR");
     2594                                                        send_reserve_with_tear_on_the_old_path(context, rcvd_sid, old_mri, !down);
     2595                                                        context->lock();
     2596                                                }
     2597                                        }
    22332598                                        context->unlock();
     2599                                }
    22342600                        } else {
     2601                                ILog(state_manager::modname, "Checking to see if we should send a TEAR");
     2602                                context->lock();
     2603                                if ((context->get_branchingNode()) && type != NSLP_Context::QNI) {
     2604                                        ILog(state_manager::modname, "Looks like it, looking up old MRI");
     2605                                        ntlp::mri_pathcoupled *old_mri;
     2606                                        context->set_branchingNode(false);
     2607                                        old_mri = context->get_old_mri();
     2608                                        context->unlock();
     2609                                        if (old_mri) {
     2610                                                ILog(state_manager::modname, "Branching node - sending TEAR");
     2611                                                send_reserve_with_tear_on_the_old_path(context, rcvd_sid, old_mri, !down);
     2612                                        }
     2613                                }
    22352614                                if (type == NSLP_Context::QNE) {
    22362615                                        ILog(state_manager::modname, "I am not the originator of RII: Forwarding it!");
     
    22402619                } // end IF RII in local hashmap found
    22412620                else {
     2621                        ILog(state_manager::modname, "Checking to see if we should send a TEAR");
     2622                        if ((context->get_branchingNode()) && type != NSLP_Context::QNI) {
     2623                                ILog(state_manager::modname, "Looks like it, looking up old MRI");
     2624                                ntlp::mri_pathcoupled *old_mri;
     2625                                context->set_branchingNode(false);
     2626                                old_mri = context->get_old_mri();
     2627                                if (old_mri) {
     2628                                        context->unlock();
     2629                                        ILog(state_manager::modname, "Branching node - sending TEAR");
     2630                                        send_reserve_with_tear_on_the_old_path(context, rcvd_sid, old_mri, !down);
     2631                                        context->lock();
     2632                                }
     2633                        }
    22422634                        context->unlock();
    22432635                        ILog(state_manager::modname, "Processing RESPONSE: RII " << rii_number << " NOT FOUND!");
     
    23082700                                                        uint32 forward_rsn_number;
    23092701                                                        context->lock();
    2310                                                         context->get_rsn_upstream(forward_rsn_number);
     2702                                                        if (down)
     2703                                                          context->get_rsn_upstream(forward_rsn_number);
     2704                                                        else
     2705                                                          context->get_rsn_downstream(forward_rsn_number);
    23112706                                                        context->unlock();
    23122707                                                        rsn* up_rsn = new rsn();
     
    23682763 * @param rcvd_sid the session id the current message belongs to.
    23692764 */
    2370 void state_manager::process_notify_msg(known_nslp_pdu* known_pdu, bool down, const ntlp::sessionid* rcvd_sid)
     2765void state_manager::process_notify_msg(known_nslp_pdu* known_pdu, bool down,
     2766                                      const ntlp::sessionid* rcvd_sid, const ntlp::mri_pathcoupled* rcvd_mri,
     2767                                      error_t& nslpres)
    23712768{
    23722769    notifymsg* notify = NULL;
    23732770
    23742771    DLog(state_manager::modname, "process_notify_msg()");
     2772    nslpres = error_nothing_to_do;
    23752773
    23762774    notify = dynamic_cast<notifymsg*>(known_pdu);
     
    23832781        bool erase_state = false;
    23842782        info_spec* er_obj = notify->get_errorobject();
     2783        ntlp::mri_pathcoupled *my_mri;
     2784        context->lock();
     2785        my_mri = context->get_mri()->copy();
     2786        context->unlock();
     2787        if (my_mri->get_sourceaddress() != rcvd_mri->get_sourceaddress() ||
     2788            my_mri->get_destaddress() != rcvd_mri->get_destaddress()) {
     2789                nslpres = error_old_pdu;
     2790                return;
     2791        }
    23852792        if (er_obj) {
    23862793            // forward ERROR_SPEC to application
    23872794            process_info_spec_for_appl(er_obj, context, rcvd_sid);
    23882795            info_spec::errorclass_t er_class = (info_spec::errorclass_t) er_obj->get_errorclass();
     2796            info_spec::errorcode_t er_code = (info_spec::errorcode_t) er_obj->get_errorcode();
    23892797            if ((er_class == info_spec::transient) || (er_class == info_spec::permanent)) {
    23902798                erase_state = true;
    23912799                Log(INFO_LOG,LOG_NORMAL,state_manager::modname,"Processing NOTIFY: SET erase_state to TRUE!");
    23922800            }
    2393         }
    2394        
     2801            if (er_class == info_spec::information && er_code == info_spec::RouteChange) {
     2802                context->lock();
     2803                context->set_is_maybe_dead_end(true);
     2804                context->unlock();
     2805            }
     2806        }
     2807        if (!is_last_signaling_hop(rcvd_mri, down)) {
     2808                forward_notify_msg(notify, down, rcvd_mri, rcvd_sid);
     2809        }
    23952810        if (erase_state == true) {
    23962811          delete_context(context);
     
    23982813    }  // end if context found
    23992814    DLog(state_manager::modname, "END process_notify_msg()");
     2815}
     2816
     2817void
     2818state_manager::forward_notify_msg(notifymsg* notify, bool down, const ntlp::mri_pathcoupled* rcvd_mri, const ntlp::sessionid* sid)
     2819{
     2820    ILog(state_manager::modname, "forward_notify_msg()");
     2821    notifymsg* s_notify;
     2822    uint128 local_sid;
     2823    known_nslp_pdu* pdu = NULL;
     2824    local_sid = *sid;
     2825    s_notify = new notifymsg();
     2826    copy_notify_message(notify, s_notify);
     2827    pdu = dynamic_cast<known_nslp_pdu*>(s_notify);
     2828    SignalingMsg* sigmsg = new SignalingMsg();
     2829    sigmsg->set_msg(pdu);
     2830    sigmsg->set_sig_mri(rcvd_mri);
     2831    sigmsg->set_downstream(down);
     2832    sigmsg->set_sid(local_sid);
     2833    sigmsg->send_or_delete();
     2834    ILog(state_manager::modname, "END forward_notify_msg()");
    24002835}
    24012836
     
    25342969    if (((!rcvd_mri->get_downstream()) && (down)) || ((rcvd_mri->get_downstream()) && (!down)))  {
    25352970        context->lock();
    2536         context->get_rsn_upstream(rsn_number);
     2971        if (down)
     2972          context->get_rsn_upstream(rsn_number);
     2973        else
     2974          context->get_rsn_downstream(rsn_number);
    25372975        context->unlock();
    25382976        send_rsn = new rsn(rsn_number);
     
    25653003 * @param rcvd_mri the MRI of the current session.
    25663004 */
    2567 void state_manager::send_reserve_with_tear_down_on_the_old_path(NSLP_Context* context, const ntlp::sessionid* rcvd_sid,
    2568                                                    const ntlp::mri_pathcoupled* rcvd_mri)
     3005void state_manager::send_reserve_with_tear_on_the_old_path(NSLP_Context* context, const ntlp::sessionid* rcvd_sid,
     3006                                                   const ntlp::mri_pathcoupled* rcvd_mri, bool down)
    25693007{
    25703008        ILog(state_manager::modname, "send_reserve_with_tear_down_on_the_old_path()");
     
    25963034        sigmsg->set_sig_mri(rcvd_mri);
    25973035        sigmsg->set_sid(*rcvd_sid);
    2598         sigmsg->set_downstream(true);
     3036        sigmsg->set_downstream(down);
    25993037        sigmsg->set_sii_handle(old_sii);
     3038        sigmsg->set_allow_translate(false);
     3039        sigmsg->send_or_delete();
     3040
     3041        context->lock();
     3042        ntlp::mri_pathcoupled *old_mri = context->get_old_mri();
     3043        context->unlock();
     3044        if (!old_mri || old_mri->get_sourceaddress() != rcvd_mri->get_sourceaddress() ||
     3045            old_mri->get_destaddress() != rcvd_mri->get_destaddress())
     3046                return;
     3047
     3048        sigmsg = new SignalingMsg();
     3049        sigmsg->set_sig_mri(old_mri);
     3050        sigmsg->set_msg(0);
     3051        sigmsg->set_downstream(true);
     3052        sigmsg->set_invalidate(true);
     3053        sigmsg->send_or_delete();
     3054
     3055        sigmsg = new SignalingMsg();
     3056        sigmsg->set_sig_mri(old_mri);
     3057        sigmsg->set_msg(0);
     3058        sigmsg->set_downstream(true);
     3059        sigmsg->set_invalidate(true);
     3060        sigmsg->send_or_delete();
     3061}
     3062
     3063void state_manager::send_notify_on_the_old_path(NSLP_Context* context, const ntlp::sessionid* rcvd_sid,
     3064                                                   const ntlp::mri_pathcoupled* rcvd_mri, bool down,
     3065                                                   info_spec::errorclass_t e_class, info_spec::errorcode_t e_code)
     3066{
     3067        ILog("QOS_STATEMODULE", "send_notify_down_on_the_old_path()");
     3068
     3069        uint128 sid_number;
     3070        uint32 old_sii;
     3071        known_nslp_pdu* pdu = NULL;
     3072        notifymsg* send_n = new notifymsg();
     3073
     3074        // For simplicity, extract v4-mapped address for v4 case
     3075        in6_addr addr6;
     3076        netaddress *na = addresses->get_first(AddressList::ConfiguredAddr_P,
     3077                                      rcvd_mri->get_destaddress().is_ipv4());
     3078        na->get_ip(addr6);
     3079        delete(na);
     3080
     3081        info_spec* send_error = new info_spec(&addr6, e_class, e_code, 0);
     3082        send_n->set_errorobject(send_error);
     3083
     3084        pdu = dynamic_cast<known_nslp_pdu*>(send_n);
     3085
     3086        context->lock();
     3087        context->get_old_downstream_sii(old_sii);
     3088        context->unlock();
     3089
     3090        SignalingMsg* sigmsg = new SignalingMsg();
     3091        sigmsg->set_msg(pdu);
     3092        sigmsg->set_sig_mri(rcvd_mri);
     3093        sid_number = *rcvd_sid;
     3094        sigmsg->set_sid(sid_number);
     3095        sigmsg->set_downstream(down);
     3096        sigmsg->set_sii_handle(old_sii);
     3097        sigmsg->set_allow_translate(false);
    26003098        sigmsg->send_or_delete();
    26013099}
     
    27143212/** This function processes SII handle either with a message or from NetworkNotification.
    27153213 * @param sii_hanlde the received SII handle.
    2716  * @param down set to TRUE, if the direction is downstream, otherwise set to FALSE.
     3214 * @param down set to TRUE, if the SII handle is for the downstream peer.
    27173215 * @param my_sid the session id the current message belongs to.
    27183216 * @param rcvd_mri the MRI of the current session.
    27193217 */
    2720 void state_manager::process_sii_handle(uint32 sii_handle, bool down, const ntlp::sessionid* my_sid, const ntlp::mri_pathcoupled* rcvd_mri)
     3218void state_manager::process_sii_handle(uint32 sii_handle, bool down, const ntlp::sessionid* my_sid, const ntlp::mri_pathcoupled* rcvd_mri, APIMsg::error_t status)
    27213219{
     3220        bool ctx_down;
     3221
    27223222        DLog(state_manager::modname, " process_sii_handle()");
    27233223        NSLP_Context* context = my_sid ? contextmap.find(*my_sid) : 0;
     
    27293229
    27303230        // context is found, update it if necessary
    2731         uint32 sii;
     3231        uint32 sii, old_sii;
    27323232        if (down) {
    27333233                context->lock();
    27343234                context->get_current_downstream_sii(sii);
     3235                context->get_old_downstream_sii(old_sii);
     3236                ctx_down = context->get_downstream();
    27353237                context->unlock();
    27363238                ILog(state_manager::modname, "DOWNSTREAM");
     
    27393241                context->lock();
    27403242                context->get_current_upstream_sii(sii);
     3243                context->get_old_upstream_sii(old_sii);
     3244                ctx_down = context->get_downstream();
    27413245                context->unlock();
    27423246                ILog(state_manager::modname, "UPSTREAM");
    27433247        }
    27443248
    2745         if (sii == 0) {
    2746                 ILog(state_manager::modname, "curr_sii is 0. This is first SII handle. Set sii to " << sii_handle);
    2747                 if (down) {
     3249        switch (status) {
     3250        case APIMsg::error_msg_delivered:
     3251        case APIMsg::route_changed_status_good:
     3252        {
     3253                if (sii == 0) {
     3254                        ILog(state_manager::modname, "curr_sii is 0. This is first SII handle. Set sii to " << sii_handle);
     3255                        if (down) {
     3256                                context->lock();
     3257                                context->set_current_downstream_sii(sii_handle);
     3258                                context->unlock();
     3259                        }
     3260                        else {
     3261                                context->lock();
     3262                                context->set_current_upstream_sii(sii_handle);
     3263                                context->unlock();
     3264                        }
     3265                }
     3266                else if (sii != sii_handle) {
     3267                        ILog(state_manager::modname, "curr_sii is " << sii << " and received sii is " << sii_handle << " and old sii is " << old_sii);
     3268                        if (!down) {
     3269                                context->lock();
     3270                                context->set_old_upstream_sii(sii);
     3271                                context->set_current_upstream_sii(sii_handle);
     3272                                context->set_rsn_upstream(0);
     3273                                if (ctx_down)
     3274                                        context->set_mergingNode(true);
     3275                                else
     3276                                        context->set_branchingNode(true);
     3277                                context->unlock();
     3278                        }
     3279                        else {
     3280                                context->lock();
     3281                                context->set_old_downstream_sii(sii);
     3282                                context->set_current_downstream_sii(sii_handle);
     3283                                if (ctx_down)
     3284                                        context->set_branchingNode(true);
     3285                                else
     3286                                        context->set_mergingNode(true);
     3287                                context->set_rsn_downstream(0);
     3288/*     
     3289                                if (context->get_replace()) {
     3290                                        context->unlock();
     3291                                        rii* new_rii = new rii();
     3292                                        new_rii->generate_new();
     3293                                        new_rii->set_is_reserve(true);
     3294                                        new_rii->set_own(true);
     3295                                        context->lock();
     3296                                        qspec_object* qspec_for_rii = context->get_context_qspec();
     3297                                        context->set_branchingNode(true);
     3298                                        context->unlock();
     3299                                        new_rii->set_qspec(qspec_for_rii);
     3300                                        retransmit_message(context, new_rii, false, my_sid, rcvd_mri);
     3301                                }
     3302                                else
     3303*/
     3304                                context->unlock();
     3305
     3306                        }
     3307                }
     3308                break;
     3309        }
     3310        case APIMsg::route_changed_status_bad:
     3311        {
     3312                if (sii_handle == sii) {
     3313                        ntlp::mri_pathcoupled* ctx_mri;
    27483314                        context->lock();
    2749                         context->set_current_upstream_sii(sii_handle);
     3315                        ctx_mri = context->get_mri()->copy();
     3316                        context->unlock();
     3317                        if (!ctx_mri ||
     3318                            ctx_mri->get_destaddress() != rcvd_mri->get_destaddress() ||
     3319                            ctx_mri->get_sourceaddress() != rcvd_mri->get_sourceaddress()) {
     3320                                if (ctx_mri)
     3321                                        ILog(state_manager::modname, "Current peer change, but w/ old MRI: " << *ctx_mri << *rcvd_mri);
     3322                                else
     3323                                        ILog(state_manager::modname, "Current peer change, but w/ old MRI: NULL" << endl << *rcvd_mri);
     3324                                break;
     3325                        }
     3326                       
     3327                        // If the upstream peer goes away and we are in sender-initiated mode
     3328                        if (!down && ctx_down) {
     3329                                context->lock();
     3330                                if (context->get_is_maybe_dead_end()) {
     3331                                        context->set_is_maybe_dead_end(false);
     3332                                } else {
     3333                                        context->unlock();
     3334                                        delete_context(context);
     3335                                        return;
     3336                                }
     3337                                context->unlock();
     3338                                ILog(state_manager::modname, "Current upstream peer is no longer available sending RESERVE(T)");
     3339
     3340                                // Send RESERVE(T)
     3341                                uint128 sid_number;
     3342                                uint32 rsn_number;
     3343                                rsn* send_rsn;
     3344                                known_nslp_pdu* pdu = NULL;
     3345                                reservereq* send_r = new reservereq();
     3346                                context->lock();
     3347                                context->get_rsn_own(rsn_number);
     3348                                context->unlock();
     3349                                send_rsn = new rsn(rsn_number);
     3350                                send_r->set_rsn(send_rsn);
     3351
     3352                                context->lock();
     3353                                qspec_object* send_qspec = context->get_context_qspec();
     3354                                context->unlock();
     3355                                send_r->set_qspec(send_qspec);
     3356                                send_r->set_originator(true);
     3357                                pdu = dynamic_cast<known_nslp_pdu*>(send_r);
     3358                                pdu->set_tear_flag();
     3359
     3360                                SignalingMsg* sigmsg = new SignalingMsg();
     3361                                sigmsg->set_msg(pdu);
     3362                                sigmsg->set_sig_mri(rcvd_mri);
     3363                                sid_number = *my_sid;
     3364                                sigmsg->set_sid(sid_number);
     3365                                sigmsg->set_downstream(true);
     3366
     3367                                sigmsg->send_or_delete();
     3368
     3369                                delete_context(context);
     3370                        } else {
     3371                                delete_context(context);
     3372                        }
     3373                }
     3374        }
     3375        default:
     3376                break;
     3377        }
     3378}
     3379
     3380void
     3381state_manager::process_mobility(ntlp::mri_pathcoupled *rcvd_mri, ntlp::APIMsg::error_t status)
     3382{
     3383        ContextMap::search_context sc;
     3384        NSLP_Context *context;
     3385        ntlp::Flowstatus *fs;
     3386
     3387#ifdef USE_FLOWINFO
     3388        // Lookup the translation for this
     3389        fs = fi_service->get_flowinfo(*rcvd_mri);
     3390#endif
     3391        ILog("MOBILITY-DBG 1", "Flowstatus:" << fs->type << endl << fs->orig_mri << *fs->new_mri << endl);
     3392
     3393        for (context = contextmap.find_first(*rcvd_mri, sc); context != 0;
     3394            context = contextmap.find_next(sc)) {
     3395                send_mobility_refresh(context, fs);
     3396        }
     3397}
     3398
     3399/**
     3400 * Check context and flowstatus and send a QUERY/RESERVE if applicable
     3401 * @param context the affected context
     3402 * @param fs the new flowstatus
     3403 */
     3404void
     3405state_manager::send_mobility_refresh(NSLP_Context *context, ntlp::Flowstatus *fs)
     3406{
     3407        NSLP_Context::qn_type_t type;
     3408        ntlp::mri_pathcoupled *my_mri;
     3409        uint128 my_sid;
     3410        uint32 my_rsn;
     3411        qspec_object *my_qspec;
     3412        bool down;
     3413        known_nslp_pdu *pdu;
     3414        rii* send_new_rii;
     3415        bool replace = false;
     3416
     3417        ILog("MOBILITY-DBG 2", "For " << *context->get_logical_mri() << "Flowstatus:" << fs->type << endl << fs->orig_mri << *fs->new_mri << endl);
     3418
     3419        switch (fs->type) {
     3420        case ntlp::Flowstatus::fs_tunnel:
     3421        {
     3422                // XXX: Revisit!
     3423                ILog("MOBILITY", "TUNNEL");
     3424
     3425                context->lock();
     3426                if (!context->get_bound_s_id(my_sid)) {
     3427                        id_t check_id;
     3428
     3429                        context->get_s_id(my_sid);
     3430                        context->get_timer_id_for_tunnel(check_id);
     3431                        context->unlock();
     3432                        if (check_id == 0) {
     3433                                // Start timer for tunnel reservation
     3434                                TimerMsg *tmsg = new TimerMsg(message::qaddr_qos_nslp_timerprocessing);
     3435
     3436                                id_t check_id;
     3437                                check_id = tmsg->get_id();
     3438                                context->lock();
     3439                                context->set_timer_id_for_tunnel(check_id);
     3440                                context->unlock();
     3441
     3442                                notifymsg* t_notify = new notifymsg();
     3443                                ntlp::sessionid* rcvd_sid = new sessionid(my_sid);
     3444                                tmsg->start_relative(10, 0, rcvd_sid, t_notify);
     3445                                if (tmsg->send_to(message::qaddr_timer)) {
     3446                                        ILog(state_manager::modname, "send_mobility_refresh, Timer for Tunnel-RESERVE " << check_id << " set to " << 10);
     3447                                }
     3448                                tmsg = NULL;
     3449
     3450                                return;
     3451                        }
     3452                }
     3453                context->unlock();
     3454
     3455//              // Lookup the context for the bound session
     3456//              sessionid sid(my_sid);
     3457//              context = contextmap.find(sid);
     3458//
     3459//              if (!context)
     3460                        return;
     3461                // FALLTHROUGH
     3462        }
     3463        case ntlp::Flowstatus::fs_normal:
     3464        case ntlp::Flowstatus::fs_nothing:
     3465        {
     3466                // Lock context for update and state retrival
     3467                context->lock();
     3468                type = context->get_qn_type();
     3469                down = context->get_downstream();
     3470                context->unlock();
     3471
     3472                if (type == NSLP_Context::QNE) {
     3473                        ILog("MOBILITY", "I'm QNE - nothing I can do");
     3474                        // XXX: This should never happen
     3475                        return;
     3476                }
     3477                if (type == NSLP_Context::QNR && down) {
     3478                        ILog("MOBILITY", "I'm QNR - nothing I can do (for now)");
     3479                        return;
     3480                }
     3481                if (type == NSLP_Context::QNR && !down) {
     3482                        ILog("MOBILITY", "I'm QNR - sending QUERY ... maybe");
     3483                        // Get a new lifetime
     3484                        uint32 new_refr_p, new_lifetime;
     3485                        rp *refr_period = new rp(REFRESH_PERIOD_default);
     3486                        refr_period->get_rand_wait(REFRESH_PERIOD_default, new_refr_p);
     3487                        refr_period->get_rand_lifetime(REFRESH_PERIOD_default, new_lifetime);
     3488                        delete refr_period;
     3489
     3490                        context->lock();
     3491                        // Update the MRI
     3492                        my_mri = context->get_mri()->copy();
     3493                        if (my_mri->get_sourceaddress() != fs->new_mri->get_sourceaddress()) {
     3494                                my_mri->set_sourceaddress(fs->new_mri->get_sourceaddress());
     3495                                replace = true;
     3496                        }
     3497                        if (my_mri->get_destaddress() != fs->new_mri->get_destaddress()) {
     3498                                my_mri->set_destaddress(fs->new_mri->get_destaddress());
     3499                                replace = true;
     3500                        }
     3501                        if (!replace) {
     3502                                ILog("MOBILITY", "mri unchanged");
     3503                                context->unlock();
     3504                                return;
     3505                        }
     3506
     3507                        // REFRESH TIMER
     3508                        timer_t t_lifetime = time(NULL) + new_lifetime;
     3509                        context->set_time_to_live(t_lifetime);
     3510                        if (!context->get_reserved()) {
     3511                                id_t query_timer_id;
     3512                                context->get_timer_id_for_reserve_or_query(query_timer_id);
     3513                                context->unlock();                     
     3514
     3515                                TimerMsg* tmsg = new TimerMsg(message::qaddr_qos_nslp_timerprocessing);
     3516                                bool stop;
     3517                                stop = tmsg->stop(query_timer_id);
     3518                                tmsg->send_to(message::qaddr_timer);
     3519                                if (stop) { Log(INFO_LOG,LOG_NORMAL,state_manager::modname,"RESERVE timer " << query_timer_id << " stopped!"); }
     3520                        }
     3521
     3522                        context->set_mri(my_mri);
     3523                        context->get_s_id(my_sid);
     3524                        context->set_reserved(false);
     3525                        my_qspec = context->get_context_qspec();
     3526                        context->unlock();
     3527
     3528                        querymsg *query = new querymsg();
     3529                        packet_classifier* new_pc = new packet_classifier();
     3530                        new_pc->set_spi_flag();
     3531                        query->set_packet_classifier(new_pc);
     3532                        query->set_originator(true);
     3533                        query->set_qspec(my_qspec);
     3534                        query->set_reserve_init_flag();
     3535               
     3536                        pdu = dynamic_cast<known_nslp_pdu*>(query);
     3537                        SignalingMsg* sigmsg = new SignalingMsg();
     3538                        sigmsg->set_msg(pdu);
     3539                        sigmsg->set_sig_mri(my_mri);
     3540                        sigmsg->set_downstream(!down);
     3541                        sigmsg->set_sid(my_sid);
     3542                        sigmsg->send_or_delete();
     3543
     3544                        return;
     3545                }
     3546                if (!down) {
     3547                        ILog("MOBILITY", "This might be wrong, but I'll just sit on my hands for the moment");
     3548                        return;
     3549                }
     3550
     3551                context->lock();
     3552                if (context->get_bound_s_id(my_sid)) {
     3553                        context->unset_bound_s_id();
     3554                        context->unlock();
     3555
     3556                        ntlp::sessionid sid(my_sid);
     3557                        NSLP_Context *t_context = contextmap.find(sid);
     3558                        if (t_context)
     3559                                delete_context(t_context);
     3560                } else {
    27503561                        context->unlock();
    27513562                }
    2752                 else {
     3563
     3564                ILog("MOBILITY", "I'm QNI - sending RESERVE ... maybe");
     3565                // We are QNI and this is a sender-initiated session
     3566                // Let's send a RESERVE
     3567
     3568                // Get a new lifetime
     3569                uint32 new_refr_p, new_lifetime;
     3570                rp *refr_period = new rp(REFRESH_PERIOD_default);
     3571                refr_period->get_rand_wait(REFRESH_PERIOD_default, new_refr_p);
     3572                refr_period->get_rand_lifetime(REFRESH_PERIOD_default, new_lifetime);
     3573                delete refr_period;
     3574
     3575                context->lock();
     3576                // Update the MRI
     3577                my_mri = context->get_mri()->copy();
     3578                if (my_mri->get_sourceaddress() != fs->new_mri->get_sourceaddress()) {
     3579                        my_mri->set_sourceaddress(fs->new_mri->get_sourceaddress());
     3580                        replace = true;
     3581                }
     3582                if (my_mri->get_destaddress() != fs->new_mri->get_destaddress()) {
     3583                        my_mri->set_destaddress(fs->new_mri->get_destaddress());
     3584                        replace = true;
     3585                }
     3586                if (!replace) {
     3587                        ILog("MOBILITY", "mri unchanged");
     3588                        context->unlock();
     3589                        return;
     3590                }
     3591
     3592                // REFRESH TIMER
     3593                timer_t t_lifetime = time(NULL) + new_lifetime;
     3594                context->set_time_to_live(t_lifetime);
     3595                if (!context->get_reserved()) {
     3596                        id_t query_timer_id;
     3597                        context->get_timer_id_for_reserve_or_query(query_timer_id);
     3598                        context->unlock();                     
     3599
     3600                        TimerMsg* tmsg = new TimerMsg(message::qaddr_qos_nslp_timerprocessing);
     3601                        bool stop;
     3602                        stop = tmsg->stop(query_timer_id);
     3603                        tmsg->send_to(message::qaddr_timer);
     3604                        if (stop) { Log(INFO_LOG,LOG_NORMAL,state_manager::modname,"RESERVE timer " << query_timer_id << " stopped!"); }
     3605                }
     3606
     3607                context->set_mri(my_mri);
     3608                context->get_s_id(my_sid);
     3609                context->set_reserved(false);
     3610                my_qspec = context->get_context_qspec();
     3611                // Set RSN = RSN+2
     3612                context->increment_down_rsn();
     3613                context->increment_down_rsn();
     3614                context->get_rsn_own(my_rsn);
     3615                context->unlock();
     3616
     3617                reservereq *res = new reservereq();
     3618                rsn* send_rsn = new rsn();
     3619                send_rsn->set(my_rsn);
     3620                res->set_rsn(send_rsn);
     3621                res->set_originator(true);
     3622                send_new_rii = new rii();
     3623                send_new_rii->generate_new();
     3624                send_new_rii->set_own(true);
     3625                send_new_rii->set_is_reserve(true);
     3626                res->set_rii(send_new_rii);
     3627                res->set_qspec(my_qspec);
     3628                res->set_replace_flag();
     3629               
     3630                pdu = dynamic_cast<known_nslp_pdu*>(res);
     3631                SignalingMsg* sigmsg = new SignalingMsg();
     3632                sigmsg->set_msg(pdu);
     3633                sigmsg->set_sig_mri(my_mri);
     3634                sigmsg->set_downstream(down);
     3635                sigmsg->set_sid(my_sid);
     3636                sigmsg->send_or_delete();
     3637
     3638        }
     3639        default:
     3640                return;
     3641        }
     3642}
     3643
     3644void
     3645state_manager::create_tunnel_reserve(NSLP_Context *context)
     3646{
     3647        NSLP_Context::qn_type_t type;
     3648        uint128 my_sid;
     3649        bool down;
     3650        ntlp::Flowstatus *fs;
     3651        ntlp::mri_pathcoupled *lmri;
     3652
     3653        if (!context)
     3654                return;
     3655
     3656        context->lock();
     3657        lmri = context->get_logical_mri()->copy();
     3658        context->unlock();
     3659
     3660        if (!lmri)
     3661                return;
     3662
     3663#ifdef USE_FLOWINFO
     3664        // Lookup the translation for this
     3665        fs = fi_service->get_flowinfo(*lmri);
     3666#endif
     3667
     3668        context->lock();
     3669
     3670        if (fs->type != ntlp::Flowstatus::fs_tunnel) {
     3671                context->set_timer_id_for_tunnel(0);
     3672                context->unlock();
     3673                return;
     3674        }
     3675
     3676        context->set_timer_id_for_tunnel(0);
     3677        if (!context->get_bound_s_id(my_sid)) {
     3678                type = context->get_qn_type();
     3679                down = context->get_downstream();
     3680                context->unlock();
     3681
     3682                if (type == NSLP_Context::QNI && down) {
     3683                        ILog("MOBILITY-DBG 2", "I'm QNI, we are in tunnel mode and there is no tunnel reservation, creating one");
     3684                        uint128 tsid;
     3685
     3686                        reservereq* tunnel_res = new reservereq();
     3687
     3688                        packet_classifier* new_pc = new packet_classifier();
     3689                        new_pc->set_spi_flag();
     3690                        tunnel_res->set_packet_classifier(new_pc);
     3691
     3692                        rsn* new_rsn = new rsn();
     3693                        new_rsn->generate_new();
     3694                        tunnel_res->set_rsn(new_rsn);
     3695
     3696                        rii* new_rii = new rii();
     3697                        new_rii->generate_new();
     3698                        new_rii->set_own(true);
     3699                        tunnel_res->set_rii(new_rii);
     3700
    27533701                        context->lock();
    2754                         context->set_current_downstream_sii(sii_handle);
     3702                        qos_nslp::qspec_object* new_qspec = context->get_context_qspec()->copy();
    27553703                        context->unlock();
     3704                        tunnel_res->set_qspec(new_qspec);
     3705
     3706                        tunnel_res->set_originator(true);
     3707
     3708                        known_nslp_pdu *pdu = dynamic_cast<known_nslp_pdu*>(tunnel_res);
     3709                        SignalingMsg* sigmsg = new SignalingMsg();
     3710                        sigmsg->set_msg(pdu);
     3711
     3712                        ntlp::mri_pathcoupled *logical_tmri = fs->new_mri->copy();
     3713                        logical_tmri->set_sourceaddress(fs->orig_mri.get_sourceaddress());
     3714                        sigmsg->set_sig_mri(logical_tmri);
     3715
     3716                        sigmsg->set_downstream(true);
     3717
     3718                        ntlp::sessionid* sid = new sessionid();
     3719                        sid->generate_random();
     3720                        tsid = *sid;
     3721
     3722                        context->lock();
     3723                        context->set_bound_s_id(tsid);
     3724                        context->unlock();
     3725               
     3726                        sigmsg->set_sid(tsid);
     3727                        sigmsg->send_or_delete();
    27563728                }
    2757         }
    2758         else {
    2759                 ILog(state_manager::modname, "curr_sii is " << sii << " and received sii is " << sii_handle);
    2760                 if (down) {
     3729                if (type == NSLP_Context::QNR && !down) {
     3730                        ILog("MOBILITY-DBG 2", "I'm QNR, we are in tunnel mode and there is no tunnel reservation, creating one");
     3731                        uint128 tsid;
     3732
     3733                        querymsg* tunnel_query = new querymsg();
     3734                        tunnel_query->set_reserve_init_flag();
     3735
     3736                        packet_classifier* new_pc = new packet_classifier();
     3737                        new_pc->set_spi_flag();
     3738                        tunnel_query->set_packet_classifier(new_pc);
     3739
    27613740                        context->lock();
    2762                         context->set_old_upstream_sii(sii);
    2763                         context->set_current_upstream_sii(sii_handle);
    2764                         context->set_mergingNode(true);
     3741                        qos_nslp::qspec_object* new_qspec = context->get_context_qspec()->copy();
    27653742                        context->unlock();
     3743                        tunnel_query->set_qspec(new_qspec);
     3744
     3745                        tunnel_query->set_originator(true);
     3746                        known_nslp_pdu *pdu = dynamic_cast<known_nslp_pdu*>(tunnel_query);
     3747                        SignalingMsg* sigmsg = new SignalingMsg();
     3748                        sigmsg->set_msg(pdu);
     3749
     3750                        ntlp::mri_pathcoupled *logical_tmri = fs->new_mri->copy();
     3751                        logical_tmri->set_sourceaddress(fs->orig_mri.get_sourceaddress());
     3752                        sigmsg->set_sig_mri(logical_tmri);
     3753
     3754                        sigmsg->set_downstream(!down);
     3755
     3756                        ntlp::sessionid* sid = new sessionid();
     3757                        sid->generate_random();
     3758                        tsid = *sid;
     3759
     3760                        context->lock();
     3761                        context->set_bound_s_id(tsid);
     3762                        context->unlock();
     3763
     3764                        sigmsg->set_sid(tsid);
     3765                        sigmsg->send_or_delete();
    27663766                }
    2767                 else {
    2768                         context->lock();
    2769                         context->set_old_downstream_sii(sii);
    2770                         context->set_current_downstream_sii(sii_handle);
    2771 
    2772                         if (context->get_replace()) {
    2773                                 context->unlock();
    2774                                 rii* new_rii = new rii();
    2775                                 new_rii->generate_new();
    2776                                 new_rii->set_is_reserve(true);
    2777                                 new_rii->set_own(true);
    2778                                 context->lock();
    2779                                 qspec_object* qspec_for_rii = context->get_context_qspec();
    2780                                 context->set_branchingNode(true);
    2781                                 context->unlock();
    2782                                 new_rii->set_qspec(qspec_for_rii);
    2783                                 retransmit_message(context, new_rii, false, my_sid, rcvd_mri);
    2784                         }
    2785                         else
    2786                                 context->unlock();
    2787 
    2788                 }
    2789         }
     3767
     3768                return;
     3769        }
     3770        context->unlock();
    27903771}
    27913772
  • qos-nslp/branches/20090723-multicast/src/TestConsole.cpp

    r3600 r4213  
    489489
    490490}
    491 
  • qos-nslp/branches/20090723-multicast/src/nslp_context.cpp

    r3673 r4213  
    5151    own_rsn->get(rsn_own);
    5252    set_rsn_upstream(0);
     53    set_rsn_downstream(0);
    5354    b_sid_exists = false;
    5455    reserved = true;
     
    6768    set_mergingNode(false);
    6869    set_branchingNode(false);
     70    set_is_maybe_dead_end(false);
    6971    set_is_in_an_aggregate(false);
    7072    //set_aggregator_type(nslp_aggregate::not_set);
    7173    set_qn_type(QNE);
     74    context_mri = logical_mri = old_mri = 0;
    7275} // end constructor
    7376
     
    7881  pthread_mutexattr_destroy(&mutex_attr);
    7982  context_mri = NULL;
     83  logical_mri = NULL;
    8084  context_qspec = NULL;
    8185}
     
    173177}
    174178
     179/** Set function for the downstream RSN object of the current NSLP_Context.
     180  * @param r the value of the downstream RSN of the current NSLP_Context will be set to the value of this variable.
     181  */
     182void NSLP_Context::set_rsn_downstream(uint32 r) {
     183    rsn_downstream = r;
     184}
     185
    175186/** Get function for the upstream RSN object of the current NSLP_Context.
    176187  * @param r into this variable the value of the upstream RSN of the current NSLP_Context will be written.
     
    178189void NSLP_Context::get_rsn_upstream(uint32& r) {
    179190    r = rsn_upstream;
     191}
     192
     193/** Get function for the downstream RSN object of the current NSLP_Context.
     194  * @param r into this variable the value of the downstream RSN of the current NSLP_Context will be written.
     195  */
     196void NSLP_Context::get_rsn_downstream(uint32& r) {
     197    r = rsn_downstream;
    180198}
    181199
     
    282300}
    283301
     302bool
     303NSLP_Context::get_is_maybe_dead_end()
     304{
     305  return maybe_dead_end;
     306}
     307
     308void
     309NSLP_Context::set_is_maybe_dead_end(bool dead_end)
     310{
     311  maybe_dead_end = true;
     312}
     313
    284314/** This function sets the value of the timer id for the RESERVE or QUERY.
    285315  * @param t the value of the timer id for the RESERVE or QUERY.
     
    303333}
    304334
     335void NSLP_Context::set_timer_id_for_tunnel(id_t t) {
     336    timer_id_for_tunnel = t;
     337}
     338
    305339/** This function gets the value of the timer id for the liefetime.
    306340  * @param t the value of the timer id for the lifetime of the current NSLP_Context will be written into this variable.
     
    308342void NSLP_Context::get_timer_id_for_lifetime(id_t& t) {
    309343    t = timer_id_for_lifetime;
     344}
     345
     346void NSLP_Context::get_timer_id_for_tunnel(id_t& t) {
     347    t = timer_id_for_tunnel;
    310348}
    311349
     
    394432    b_s_id.w3 = b_sid.w3;
    395433    b_s_id.w4 = b_sid.w4;
     434}
     435
     436void NSLP_Context::unset_bound_s_id() {
     437    b_sid_exists = false;
    396438}
    397439
     
    503545  * @param set_mri the MRI of the current NSLP_Context.
    504546  */
     547// XXX: LEAK LEAK LEAK ...
    505548void NSLP_Context::set_mri(const ntlp::mri_pathcoupled* set_mri)
    506549{
    507550  if (set_mri) {
     551    if (context_mri && *set_mri != *context_mri) {
     552      if ((old_mri && context_mri->get_downstream() == old_mri->get_downstream()) || !old_mri) {
     553        ILog("NSLP_Context", "Changing MRI: " << *context_mri << *set_mri);
     554        old_mri = context_mri;
     555      }
     556    }
    508557    context_mri = set_mri->copy();
    509558  }
     
    519568{
    520569  return context_mri;
     570}
     571
     572/** This function sets the logical MRI of the current NSLP_Context.
     573  * @param set_mri the MRI of the current NSLP_Context.
     574  */
     575void NSLP_Context::set_logical_mri(const ntlp::mri_pathcoupled* set_mri)
     576{
     577  if (set_mri) {
     578    logical_mri = set_mri->copy();
     579  }
     580  else {
     581    logical_mri = NULL;
     582  }
     583}
     584
     585/** This function gets the logical MRI of the current NSLP_Context.
     586  * @return MRI of the current NSLP_Context.
     587  */
     588const ntlp::mri_pathcoupled* NSLP_Context::get_logical_mri() const
     589{
     590  if (logical_mri) {
     591    return logical_mri->copy();
     592  }
     593  else {
     594    return NULL;
     595  }
     596}
     597
     598/** This function gets the MRI of the current NSLP_Context.
     599  * @return MRI of the current NSLP_Context.
     600  */
     601ntlp::mri_pathcoupled* NSLP_Context::get_old_mri()
     602{
     603  if (old_mri) {
     604    return old_mri->copy();
     605  }
     606  else {
     607    return NULL;
     608  }
    521609}
    522610
  • qos-nslp/branches/20090723-multicast/src/qos_nslp_contextmap.cpp

    r3673 r4213  
    3737}
    3838
     39NSLP_Context*
     40ContextMap::find_first(const mri_pathcoupled& mri, search_context &sc)
     41{
     42  NSLP_Context *context = 0;
     43
     44  lock();
     45  if (sc.sidlist)
     46    sc.sidlist->clear();
     47  else
     48    sc.sidlist = new list<simple_sid>;
     49  mri2context_map_it_t lb, ub, it;
     50  lb = mri2context_map.lower_bound(&mri);
     51  ub = mri2context_map.upper_bound(&mri);
     52  for (it = lb; it != ub && it != mri2context_map.end(); it++)
     53      sc.sidlist->push_front((*it).second);
     54  sc.slit = sc.sidlist->begin();
     55  while (sc.slit != sc.sidlist->end() && context == 0) {
     56    context_hashmap_const_it_t hit= context_hashmap.find((*sc.slit));
     57    context = (hit!=context_hashmap.end()) ? hit->second : 0;
     58    sc.slit++;
     59  }
     60  unlock();
     61
     62  return context;
     63}
     64
     65NSLP_Context*
     66ContextMap::find_next(search_context &sc)
     67{
     68  NSLP_Context *context = 0;
     69
     70  if (sc.sidlist == 0)
     71    return 0;
     72
     73  lock();
     74  while (sc.slit != sc.sidlist->end() && context == 0) {
     75    context_hashmap_const_it_t hit= context_hashmap.find((*sc.slit));
     76    context = (hit!=context_hashmap.end()) ? hit->second : 0;
     77    sc.slit++;
     78  }
     79  unlock();
     80
     81  return context;
     82}
    3983
    4084/**
     
    4690  pair<uint64, NSLP_Context*> tmppair;
    4791  pair<context_hashmap_it_t, bool> tmpiterator;
     92  const mri_pathcoupled *lmri = context->get_logical_mri();
    4893
    4994  tmppair.first = sid.get_hash();
     
    5196  lock();
    5297  tmpiterator = context_hashmap.insert(tmppair);
     98  if (tmpiterator.second && lmri != 0)
     99    mri2context_map.insert(pair<const mri_pathcoupled *, simple_sid>(lmri, sid.get_hash()));
    53100  unlock();
    54101  /*
     
    74121  lock();
    75122  context_hashmap.erase( sid.get_hash() );
     123  mri2context_map_it_t it = mri2context_map.begin();
     124  while (it != mri2context_map.end()) {
     125    if ((*it).second == sid.get_hash())
     126      mri2context_map.erase(it);
     127    it++;
     128  }
    76129  unlock();
    77130}
  • qos-nslp/branches/20090723-multicast/src/qosnslp_starter.cpp

    r4116 r4213  
    3434QoSNSLPStarterParam::QoSNSLPStarterParam(ntlp::NTLPStarterParam *ntlppar)
    3535        : ThreadParam(ThreadParam::default_sleep_time, "QoS NSLP Starter"),
    36           ntlppar(ntlppar)
     36          ntlppar(ntlppar), addresses()
    3737{
    3838}
     
    6868                // start ProcessingModule (will need four threads)
    6969                ProcessingModuleParam sim_cl_par(ThreadParam::default_sleep_time,
    70                                                  ntlp::gconf.getparref< hostaddresslist_t >(gistconf_localaddrv4).front(),
    71                                                  ntlp::gconf.getparref< hostaddresslist_t >(gistconf_localaddrv6).front());
     70                                                 *param.addresses, *param.fi_service);
    7271
    7372                ThreadStarter<ProcessingModule, ProcessingModuleParam> processing_module(4, sim_cl_par);
  • qos-nslp/branches/20090723-multicast/src/qosnslpd.cpp

    r4116 r4213  
    143143                  cfgfile.load(gconf.getparref<string>(gistconf_conffilename));
    144144                }
     145
    145146                catch(configParException& cfgerr)
    146147                {
     
    149150                  return 1;
    150151                }
     152 
     153                AddressList *addresses = new AddressList();
     154
     155                hostaddresslist_t& ntlpv4addr= gconf.getparref< hostaddresslist_t >(gistconf_localaddrv4);
     156                hostaddresslist_t& ntlpv6addr= gconf.getparref< hostaddresslist_t >(gistconf_localaddrv6);
     157
     158                if (ntlpv4addr.size() == 0 && ntlpv6addr.size() == 0) {
     159                        addresses->add_host_prop(NULL, AddressList::ConfiguredAddr_P);
     160                        addresses->add_host_prop(NULL, AddressList::ConfiguredAddr_P);
     161                        addresses->add_host_prop(NULL, AddressList::ConfiguredAddr_P);
     162                }
     163
     164                // fill in configured IPv4 addresses
     165                if (ntlpv4addr.size() != 0) {
     166                        hostaddresslist_t::const_iterator it;
     167                        for (it = ntlpv4addr.begin(); it != ntlpv4addr.end(); it++) {
     168                                netaddress na((*it));
     169                                addresses->add_property(na);
     170                        }
     171                }
     172
     173                // fill in configured IPv6 addresses
     174                if (ntlpv6addr.size() != 0) {
     175                        hostaddresslist_t::const_iterator it;
     176                        for (it = ntlpv6addr.begin(); it != ntlpv6addr.end(); it++) {
     177                                netaddress na((*it));
     178                                addresses->add_property(na);
     179                        }
     180                }
     181
     182                // MOBILITY (mobility extension): configure net prefix of home network
     183                const netaddress& na= gconf.getparref<netaddress>(gistconf_home_netprefix);
     184                if (!na.is_ip_unspec()) {
     185                        addresses->add_property(na, AddressList::HomeNet_P);
     186                }
     187
     188                // MOBILITY: configure home address
     189                const hostaddress& homeaddr= gconf.getparref< hostaddress >(gistconf_home_address);
     190                if (!homeaddr.is_ip_unspec())
     191                {
     192                        const netaddress na(homeaddr);
     193                        addresses->add_property(na, AddressList::HomeAddr_P);
     194                        addresses->add_property(na, AddressList::ConfiguredAddr_P);
     195                }
     196
     197                // MOBILITY: care-of interfaces
     198                const string& coa_iface= gconf.getparref< string >(gistconf_coa_interfaces);
     199                if (!coa_iface.empty())
     200                {
     201                        std::stringstream in(coa_iface);
     202
     203                        while (in) {
     204                                std::string token;
     205                                in >> token;
     206                               
     207                                addresses->ignore_locals();
     208                                addresses->by_interface(true);
     209                                // XXX: memleak
     210                                addresses->add_interface(strdup(token.c_str()));
     211                        }
     212                }
     213
     214                // MOBILITY: home agent address
     215                const hostaddress& homeagent_addr= gconf.getparref< hostaddress >(gistconf_homeagent_address);
     216                if (!homeagent_addr.is_ip_unspec())
     217                {
     218                        const netaddress na(homeagent_addr);
     219                        addresses->add_property(na, AddressList::HAAddr_P);
     220                        addresses->add_property(na, AddressList::ConfiguredAddr_P);
     221                }
     222
     223                // MOBILITY: home agent address
     224                const hostaddress& alt_homeagent_addr= gconf.getparref< hostaddress >(gistconf_homeagent_address_alt);
     225                if (!alt_homeagent_addr.is_ip_unspec())
     226                {
     227                        const netaddress na(alt_homeagent_addr);
     228                        addresses->add_property(na, AddressList::AltHAAddr_P);
     229                        addresses->add_property(na, AddressList::ConfiguredAddr_P);
     230                }
     231
     232                QoSNSLPStarterParam qospar;
     233
     234                qospar.addresses = addresses;
     235
     236#ifdef USE_FLOWINFO
     237                // Create a flowinfoservice thread
     238                FlowinfoParam fiparam;
     239                ThreadStarter<Flowinfo, FlowinfoParam> fithread(1, fiparam);
     240                fithread.start_processing();
     241
     242                // record the flowinfoservice thread in the ntlp_param
     243                qospar.fi_service = fithread.get_thread_object();
     244#else
     245                qospar.fi_service = NULL;
     246#endif
    151247
    152248                // override parameters given from command line
    153249                // read_cmdline();
    154250
    155                 QoSNSLPStarterParam qospar;
    156 
    157                 // give the parameters to NTLP Starter
    158251                ntlp::NTLPStarterParam ntlppar;
    159 
    160252                qospar.ntlppar = &ntlppar;
    161253
Note: See TracChangeset for help on using the changeset viewer.