/Users/yzchen/ns/ns-allinone-2.33/ns-2.33/um-olsr-0.8.8/backup/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 <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)


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);
};


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);
};


/********** 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;
        
        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_;
        
protected:
        PortClassifier* dmux_;          
        Trace*          logtarget_;     
        
        OLSR_HelloTimer hello_timer_;   
        OLSR_TcTimer    tc_timer_;      
        OLSR_MidTimer   mid_timer_;     
        
        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            mpr_computation();
        void            rtable_computation();
        
        void            process_hello(OLSR_msg&, nsaddr_t, nsaddr_t);
        void            process_tc(OLSR_msg&, nsaddr_t);
        void            process_mid(OLSR_msg&, nsaddr_t);
        
        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            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