/Users/yzchen/ns/ns-allinone-2.33/ns-2.33/um-olsr-0.8.8/OLSR.h

/***************************************************************************
 *   Copyright (C) 2004 by Francisco J. Ros                                *
 *   fjrm@dif.um.es                                                        *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/


#ifndef __OLSR_h__
#define __OLSR_h__

#include <olsr/OLSR_pkt.h>
#include <olsr/OLSR_state.h>
#include <olsr/OLSR_rtable.h>
#include <olsr/OLSR_repositories.h>
#include <olsr/cdswl.h>
#include <trace.h>
#include <classifier-port.h>
#include <agent.h>
#include <packet.h>
#include <timer-handler.h>
#include <random.h>
#include <vector>

/********** Useful macros **********/

#ifndef MAX
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
#endif

#ifndef MIN
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#endif

#ifndef NULL
#define NULL 0
#endif

#define CURRENT_TIME    Scheduler::instance().clock()

#define DELAY(time) (((time) < (CURRENT_TIME)) ? (0.000001) : \
        (time - CURRENT_TIME + 0.000001))

#define OLSR_C          0.0625


/********** Intervals **********/

#define OLSR_HELLO_INTERVAL     2

#define OLSR_TC_INTERVAL        5

#define OLSR_MID_INTERVAL       OLSR_TC_INTERVAL

#define OLSR_REFRESH_INTERVAL   2


/********** Holding times **********/

#define OLSR_NEIGHB_HOLD_TIME   3*OLSR_REFRESH_INTERVAL

#define OLSR_TOP_HOLD_TIME      3*OLSR_TC_INTERVAL

#define OLSR_DUP_HOLD_TIME      30

#define OLSR_MID_HOLD_TIME      3*OLSR_MID_INTERVAL


/********** Link types **********/

#define OLSR_UNSPEC_LINK        0

#define OLSR_ASYM_LINK          1

#define OLSR_SYM_LINK           2

#define OLSR_LOST_LINK          3

/********** Neighbor types **********/

#define OLSR_NOT_NEIGH          0

#define OLSR_SYM_NEIGH          1

#define OLSR_MPR_NEIGH          2


/********** Willingness **********/

#define OLSR_WILL_NEVER         0

#define OLSR_WILL_LOW           1

#define OLSR_WILL_DEFAULT       3

#define OLSR_WILL_HIGH          6

#define OLSR_WILL_ALWAYS        7


/********** Miscellaneous constants **********/

#define OLSR_MAXJITTER          OLSR_HELLO_INTERVAL/4

#define OLSR_MAX_SEQ_NUM        65535

#define OLSR_STATUS_NOT_SYM     0

#define OLSR_STATUS_SYM         1

#define JITTER                  (Random::uniform()*OLSR_MAXJITTER)

/************** CDSWL parameters *************/
// Added by YPC 20090727
#define CDSWL_STATUS_INIT               0
#define CDSWL_STATUS_HELLO              1
#define CDSWL_STATUS_NVEX               2
#define CDSWL_STATUS_INITDECL   3
#define CDSWL_STATUS_RESGDECL   4
#define CDSWL_STATUS_DOMDECL    5

#define CDSWL_HELLO_INTERVAL    6
#define CDSWL_PHASE_INTERVAL    1
#define CDSWL_HELLO_JITTER              (Random::uniform()*CDSWL_PHASE_INTERVAL/4)
#define CDSWL_PHASE_JITTER              (Random::uniform()*CDSWL_PHASE_INTERVAL/4)

class OLSR;                     // forward declaration


/********** Timers **********/


class OLSR_MsgTimer : public TimerHandler {
public:
        OLSR_MsgTimer(OLSR* agent) : TimerHandler() {
                agent_  = agent;
        }
protected:
        OLSR*   agent_;                 
        virtual void expire(Event* e);
};

class OLSR_HelloTimer : public TimerHandler {
public:
        OLSR_HelloTimer(OLSR* agent) : TimerHandler() { agent_ = agent; }
protected:
        OLSR*   agent_;                 
        virtual void expire(Event* e);
};


class OLSR_TcTimer : public TimerHandler {
public:
        OLSR_TcTimer(OLSR* agent) : TimerHandler() { agent_ = agent; }
protected:
        OLSR*   agent_;                 
        virtual void expire(Event* e);
};


class OLSR_MidTimer : public TimerHandler {
public:
        OLSR_MidTimer(OLSR* agent) : TimerHandler() { agent_ = agent; }
protected:
        OLSR*   agent_;                 
        virtual void expire(Event* e);
};


// Timer for CDSWL clustering -- Added by YPC 20090726
class CDSWL_PktTimer : public TimerHandler {
public:
        CDSWL_PktTimer(OLSR* agent) : TimerHandler() {
                agent_ = agent;
        }
protected:
        OLSR* agent_;
        virtual void expire(Event* e);
};


class OLSR_DupTupleTimer : public TimerHandler {
public:
        OLSR_DupTupleTimer(OLSR* agent, OLSR_dup_tuple* tuple) : TimerHandler() {
                agent_ = agent;
                tuple_ = tuple;
        }
protected:
        OLSR*           agent_; 
        OLSR_dup_tuple* tuple_; 

        virtual void expire(Event* e);
};


class OLSR_LinkTupleTimer : public TimerHandler {
        bool                    first_time_;
public:
        OLSR_LinkTupleTimer(OLSR* agent, OLSR_link_tuple* tuple) : TimerHandler() {
                agent_          = agent;
                tuple_          = tuple;
                first_time_     = true;
        }
protected:
        OLSR*                   agent_; 
        OLSR_link_tuple*        tuple_; 

        virtual void expire(Event* e);
};


class OLSR_Nb2hopTupleTimer : public TimerHandler {
public:
        OLSR_Nb2hopTupleTimer(OLSR* agent, OLSR_nb2hop_tuple* tuple) : TimerHandler() {
                agent_ = agent;
                tuple_ = tuple;
        }
protected:
        OLSR*                   agent_; 
        OLSR_nb2hop_tuple*      tuple_; 

        virtual void expire(Event* e);
};


class OLSR_MprSelTupleTimer : public TimerHandler {
public:
        OLSR_MprSelTupleTimer(OLSR* agent, OLSR_mprsel_tuple* tuple) : TimerHandler() {
                agent_ = agent;
                tuple_ = tuple;
        }
protected:
        OLSR*                   agent_; 
        OLSR_mprsel_tuple*      tuple_; 

        virtual void expire(Event* e);
};


class OLSR_TopologyTupleTimer : public TimerHandler {
public:
        OLSR_TopologyTupleTimer(OLSR* agent, OLSR_topology_tuple* tuple) : TimerHandler() {
                agent_ = agent;
                tuple_ = tuple;
        }
protected:
        OLSR*                   agent_; 
        OLSR_topology_tuple*    tuple_; 

        virtual void expire(Event* e);
};


class OLSR_IfaceAssocTupleTimer : public TimerHandler {
public:
        OLSR_IfaceAssocTupleTimer(OLSR* agent, OLSR_iface_assoc_tuple* tuple) : TimerHandler() {
                agent_ = agent;
                tuple_ = tuple;
        }
protected:
        OLSR*                   agent_; 
        OLSR_iface_assoc_tuple* tuple_; 

        virtual void expire(Event* e);
};


/*********** hierarchical link metric **************/
// Added by YPC -- 20090316
class HierMetric
{
public:
        nsaddr_t        from;                   // from
        nsaddr_t        to;                             // to
        int                     nLevels;                // number of levels in the hierarchy
        int*            cost;                   // cost of the all levels
        HierMetric(nsaddr_t f, nsaddr_t t, int l, int* c) {
                from = f;
                to = t;
                nLevels = l;
                cost = c;

        }
        ~HierMetric()
        {
                delete [] cost;
        }
        bool lessThan(HierMetric*);
        HierMetric* addBy(HierMetric*);
        string toString();
};

/*********** CDSWL **************/
// Added by YPC -- 20090727
class NeighborInfo {
        nsaddr_t        id;
        double          lastSeen;
        map<nsaddr_t, NeighborInfo>     *nbrList;
        bool            dominator;
public:
        NeighborInfo(nsaddr_t addr) {
                id      = addr;
                lastSeen = Scheduler::instance().clock();
                nbrList = NULL;
                dominator = false;
        }
        ~NeighborInfo() {
                nbrList->clear();
                delete nbrList;
        }
};

/********** OLSR Agent **********/
class OLSR : public Agent {
        // Makes some friends.
        friend class OLSR_HelloTimer;
        friend class OLSR_TcTimer;
        friend class OLSR_MidTimer;
        friend class OLSR_DupTupleTimer;
        friend class OLSR_LinkTupleTimer;
        friend class OLSR_Nb2hopTupleTimer;
        friend class OLSR_MprSelTupleTimer;
        friend class OLSR_TopologyTupleTimer;
        friend class OLSR_IfaceAssocTupleTimer;
        friend class OLSR_MsgTimer;
        friend class CDSWL_PktTimer;

        nsaddr_t        ra_addr_;

        u_int16_t       pkt_seq_;
        u_int16_t       msg_seq_;
        u_int16_t       ansn_;

        int             hello_ival_;
        int             tc_ival_;
        int             mid_ival_;
        int             willingness_;
        int             use_mac_;

        OLSR_rtable             rtable_;
        OLSR_state              state_;
        std::vector<OLSR_msg>   msgs_;

        // Added for mmc - YPC - 20090309
        static int *hAddr;
        static int      nNodes;
        static int      nLevels;
        int* initHierAddr();
        int print_nodes(nsaddr_t, std::set<nsaddr_t>, std::vector<OLSR_topology_tuple*>);
        bool isNeighborFromTo(nsaddr_t, nsaddr_t, std::vector<OLSR_topology_tuple*>);
        HierMetric* getLinkCost(nsaddr_t, nsaddr_t, std::vector<HierMetric*>);
        void dumpDistVector(std::map<nsaddr_t, HierMetric*>, std::map<nsaddr_t, nsaddr_t>);

        // Added for CDSWL - YPC 20090727
        int     cdswl_status_;
        map<nsaddr_t, NeighborInfo> nbr_list_;

protected:
        PortClassifier* dmux_;          
        Trace*          logtarget_;     

        OLSR_HelloTimer hello_timer_;   
        OLSR_TcTimer    tc_timer_;              
        OLSR_MidTimer   mid_timer_;             

        CDSWL_PktTimer  cdswl_timer_;   //      CDSWL timer --- Added by YPC 20090726

        inline u_int16_t        pkt_seq() {
                pkt_seq_ = (pkt_seq_ + 1)%(OLSR_MAX_SEQ_NUM + 1);
                return pkt_seq_;
        }
        inline u_int16_t        msg_seq() {
                msg_seq_ = (msg_seq_ + 1)%(OLSR_MAX_SEQ_NUM + 1);
                return msg_seq_;
        }

        inline nsaddr_t&        ra_addr()       { return ra_addr_; }

        inline int&             hello_ival()    { return hello_ival_; }
        inline int&             tc_ival()       { return tc_ival_; }
        inline int&             mid_ival()      { return mid_ival_; }
        inline int&             willingness()   { return willingness_; }
        inline int&             use_mac()       { return use_mac_; }

        inline linkset_t&       linkset()       { return state_.linkset(); }
        inline mprset_t&        mprset()        { return state_.mprset(); }
        inline mprselset_t&     mprselset()     { return state_.mprselset(); }
        inline nbset_t&         nbset()         { return state_.nbset(); }
        inline nb2hopset_t&     nb2hopset()     { return state_.nb2hopset(); }
        inline topologyset_t&   topologyset()   { return state_.topologyset(); }
        inline dupset_t&        dupset()        { return state_.dupset(); }
        inline ifaceassocset_t& ifaceassocset() { return state_.ifaceassocset(); }

        void            recv_olsr(Packet*);
        void            recv_cdswl_pkt(Packet*);

        void            mpr_computation();
        void            rtable_computation();
        void            rtable_computation_h();         // Hierarchical addresses for OSP; YPC 20090314

        void            process_hello(OLSR_msg&, nsaddr_t, nsaddr_t);
        void            process_tc(OLSR_msg&, nsaddr_t);
        void            process_mid(OLSR_msg&, nsaddr_t);
        void            process_cdswl_hello(Packet*);

        void            forward_default(Packet*, OLSR_msg&, OLSR_dup_tuple*, nsaddr_t);
        void            forward_data(Packet*);

        void            enque_msg(OLSR_msg&, double);
        void            send_hello();
        void            send_tc();
        void            send_mid();
        void            send_pkt();
        void            send_cdswl_pkt(int pkt_type, int pkt_subtype = 0);              // Packet type as defined in cdswl.h
        void            reset_cdswl_pkt_timer();

        void            link_sensing(OLSR_msg&, nsaddr_t, nsaddr_t);
        void            populate_nbset(OLSR_msg&);
        void            populate_nb2hopset(OLSR_msg&);
        void            populate_mprselset(OLSR_msg&);

        void            set_hello_timer();
        void            set_tc_timer();
        void            set_mid_timer();

        void            nb_loss(OLSR_link_tuple*);
        void            add_dup_tuple(OLSR_dup_tuple*);
        void            rm_dup_tuple(OLSR_dup_tuple*);
        void            add_link_tuple(OLSR_link_tuple*, u_int8_t);
        void            rm_link_tuple(OLSR_link_tuple*);
        void            updated_link_tuple(OLSR_link_tuple*);
        void            add_nb_tuple(OLSR_nb_tuple*);
        void            rm_nb_tuple(OLSR_nb_tuple*);
        void            add_nb2hop_tuple(OLSR_nb2hop_tuple*);
        void            rm_nb2hop_tuple(OLSR_nb2hop_tuple*);
        void            add_mprsel_tuple(OLSR_mprsel_tuple*);
        void            rm_mprsel_tuple(OLSR_mprsel_tuple*);
        void            add_topology_tuple(OLSR_topology_tuple*);
        void            rm_topology_tuple(OLSR_topology_tuple*);
        void            add_ifaceassoc_tuple(OLSR_iface_assoc_tuple*);
        void            rm_ifaceassoc_tuple(OLSR_iface_assoc_tuple*);

        nsaddr_t        get_main_addr(nsaddr_t);
        int                     degree(OLSR_nb_tuple*);

        static bool     seq_num_bigger_than(u_int16_t, u_int16_t);

public:
        OLSR(nsaddr_t);
        int             command(int, const char*const*);
        void    recv(Packet*, Handler*);
        void    mac_failed(Packet*);

        static double           emf_to_seconds(u_int8_t);
        static u_int8_t         seconds_to_emf(double);
        static int                      node_id(nsaddr_t);
};

#endif