aodv.h

MAODV代码和安装程序 hen nan找啊

/*** added for multicast ***/
class PacketID {
        friend class AODV;
public:
        PacketID(nsaddr_t i, u_int32_t b) { src = i; id = b;  }

protected:
        LIST_ENTRY(PacketID) plink;
        nsaddr_t        src;
        u_int32_t       id;
        double          expire;         // now + BCAST_ID_SAVE ms
};

LIST_HEAD(aodv_pcache, PacketID);
/***************************/


/*
  The Routing Agent
*/
class AODV: public Agent {

  /*
   * make some friends first 
   */

        friend class aodv_rt_entry;
       
        /*** added for multicast ***/
        friend class aodv_mt_entry;
        friend class aodv_glt_entry;
        /****************************/

        friend class BroadcastTimer;
        friend class HelloTimer;

        /*** added for multicast ***/
        friend class GroupHelloTimer;
        /**************************/

        friend class NeighborTimer;
        friend class RouteCacheTimer;
        friend class LocalRepairTimer;

        /*** added for multicast ***/
        friend class RREPWaitTimer;
        friend class PruneTimer;
        friend class PacketTimer;
        /**************************/

 public:
        AODV(nsaddr_t id);

        void		recv(Packet *p, Handler *);

 protected:
        int             command(int, const char *const *);
        int             initialized() { return 1 && target_; }

        /*
         * Route Table Management
         */
        void            rt_resolve(Packet *p);
        void            rt_update(aodv_rt_entry *rt, u_int32_t seqnum,
		     	  	u_int16_t metric, nsaddr_t nexthop,
		      		double expire_time);
        void            rt_down(aodv_rt_entry *rt);
        void            local_rt_repair(aodv_rt_entry *rt, Packet *p);
 public:
        void            rt_ll_failed(Packet *p);
        void            handle_link_failure(nsaddr_t id);

 protected:
        void            rt_purge(void);

        void            enque(aodv_rt_entry *rt, Packet *p);
        Packet*         deque(aodv_rt_entry *rt);

        /*
         * Neighbor Management
         */
        void            nb_insert(nsaddr_t id);
        AODV_Neighbor*       nb_lookup(nsaddr_t id);
        void            nb_delete(nsaddr_t id);
        void            nb_purge(void);

        /*
         * Broadcast ID Management
         */

        void            id_insert(nsaddr_t id, u_int32_t bid);
        bool	        id_lookup(nsaddr_t id, u_int32_t bid);
        void            id_purge(void);


        /*** added for multicast ***/
        /* Packet ID Management */
        void            pid_insert(nsaddr_t addr, u_int32_t pid);
        bool	        pid_lookup(nsaddr_t addr, u_int32_t pid);
        void            pid_purge(void);
        /****************************/

        /*
         * Packet TX Routines
         */
        void            forward(aodv_rt_entry *rt, Packet *p, double delay);
        void            sendHello(void);
        void            sendRequest(nsaddr_t dst);

        /*** modified for multicast ***/
       // void            sendReply(nsaddr_t ipdst, u_int32_t hop_count,
       //                           nsaddr_t rpdst, u_int32_t rpseq,
       //                           u_int32_t lifetime, double timestamp);
        void            sendReply(nsaddr_t ipdst, u_int8_t flags, u_int32_t hop_count,
                                  nsaddr_t rpdst, u_int32_t rpseq,
                                  u_int32_t lifetime, double timestamp,
                                  u_int8_t hops_grp_leader=0, nsaddr_t grp_leader_addr=0);
        /*******************************/

        void            sendError(Packet *p, bool jitter = true);
                                          
        /*
         * Packet RX Routines
         */
        void            recvAODV(Packet *p);
        void            recvHello(Packet *p);
        void            recvRequest(Packet *p);
        void            recvReply(Packet *p);
        void            recvError(Packet *p);

        /*** added for multicast ***/
        void            mt_forward(Packet *p, double delay);
        void            mt_prune(nsaddr_t dst);
        void            mt_resolve(Packet *p);
        void            mt_nb_fail(nsaddr_t next_hop);
        void            mt_repair(aodv_mt_entry *mt, aodv_nh_entry *nh);
        void            mt_link_purge();

        void            sendMRQ(aodv_mt_entry *mt, u_int8_t flags);
        void            recvMRQ_NOFLAG(Packet *p);
        void            recvMRQ_J(Packet *p);
        void            recvMRQ_R(Packet *p);
        void            recvMRQ_JR(Packet *p);
        void            recvMRP_J(Packet *p);
        void            recvMRP_R(Packet *p);
        void            recvMRP_JR(Packet *p);
        void            sendMACT(nsaddr_t dst, u_int8_t flags, u_int8_t hop_count, nsaddr_t next_hop);
        void            recvMACT(Packet *p);
        void            recvMACT_J(Packet *p);
        void            recvMACT_P(Packet *p);
        void            recvMACT_U(Packet *p);
        void            recvMACT_GL(Packet *p);
        void            sendMWARN(nsaddr_t dst, u_int8_t flags, double breaktime, nsaddr_t next_hop);
        void            recvMWARN(Packet *p);
        void            sendMGRPH();
        void            recvMGRPH(Packet *p);
        void            sendMGRPH_U(aodv_mt_entry *mt, nsaddr_t next_hop = INFINITY8);
        void            recvMGRPH_U(Packet *p);
        void            becomeLeader(aodv_mt_entry *mt);
        void            selectLeader(aodv_mt_entry *mt, nsaddr_t next_hop);
        void            afterWaitRREP(nsaddr_t dst);
        void            clearMReqState(aodv_mt_entry *mt);
        void            clearMRpyState(aodv_mt_entry *mt);
        void            clearMGrpMerge(aodv_mt_entry *mt);
        void            recordMRpy(aodv_mt_entry *mt, Packet *p);
        void            downMT(aodv_mt_entry *mt);
        void            controlNextHello();
        void            setPruneTimer(aodv_mt_entry *mt);
public:
        void            mt_ll_failed(Packet *p);
protected:

        /***************************************/


        /*** added for prediction in unicast ***/
        void  recvLPW(nsaddr_t prev, double breakTime);
        void  sendLPW(nsaddr_t prev, double breakTime);
        void  sendRPE(Packet *p);
        void  recvRPE(Packet *p);
        void  recvRequest_P(Packet *p);
        /*****************************************/


	/*
	 * History management
	 */
	
	double 		PerHopTime(aodv_rt_entry *rt);


        nsaddr_t        index;                  // IP Address of this node
        u_int32_t       seqno;                  // Sequence Number
        int             bid;                    // Broadcast ID

        aodv_rtable         rthead;                 // routing table
        aodv_ncache         nbhead;                 // Neighbor Cache
        aodv_bcache          bihead;                 // Broadcast ID Cache

        /*** added for multicast ***/
        aodv_pcache        pihead;
	double             hello_timeout;
        /*******************************/

        /*
         * Timers
         */
        BroadcastTimer  btimer;
        HelloTimer      htimer;

        /*** added for multicast ***/
        GroupHelloTimer grphtimer;
        /***************************/

        NeighborTimer   ntimer;
        RouteCacheTimer rtimer;
        LocalRepairTimer lrtimer;

        /*** added for multicast ***/
        RREPWaitTimer rtetimer;
	PruneTimer prune_timer;
        PacketTimer         p_timer;
        /****************************/

        /*
         * Routing Table
         */
        aodv_rtable			rtable;
     
        /*** added for multicast ***/
        aodv_mtable                     mtable;  
        aodv_gltable                    gltable;
        /****************************/

        /*
         *  A "drop-front" queue used by the routing layer to buffer
         *  packets to which it does not have a route.
         */
        aodv_rqueue         rqueue;

        /*
         * A mechanism for logging the contents of the routing
         * table.
         */
        Trace           *logtarget;

        /*
         * A pointer to the network interface queue that sits
         * between the "classifier" and the "link layer".
         */
        PriQueue        *ifqueue;

        /*
         * Logging stuff
         */
        void            log_link_del(nsaddr_t dst);
        void            log_link_broke(Packet *p);
        void            log_link_kept(nsaddr_t dst);
};

#endif /* __aodv_h__ */