bcast.h

code that can compile NS-2.27 on Fedora Core 4

/*******************************************************************
 Copyright (C) 2004 Thomas Kunz, CRC Canada, BCAST for IPv4.
 DISTRIBUTED WITH NO WARRANTY, EXPRESS OR IMPLIED.
 See the GNU Library General Public License (file COPYING in the
 MANET_multicast directory) for conditions of use and redistribution.
*********************************************************************/

/*
Copyright (c) 1997, 1998 Carnegie Mellon University.  All Rights
Reserved. 

Permission to use, copy, modify, and distribute this
software and its documentation is hereby granted (including for
commercial or for-profit use), provided that both the copyright 
notice and this permission notice appear in all copies of the 
software, derivative works, or modified versions, and any portions 
thereof, and that both notices appear in supporting documentation, 
and that credit is given to Carnegie Mellon University in all 
publications reporting on direct or indirect use of this code 
or its derivatives.

ALL CODE, SOFTWARE, PROTOCOLS, AND ARCHITECTURES DEVELOPED BY THE CMU
MONARCH PROJECT ARE EXPERIMENTAL AND ARE KNOWN TO HAVE BUGS, SOME OF
WHICH MAY HAVE SERIOUS CONSEQUENCES. CARNEGIE MELLON PROVIDES THIS
SOFTWARE OR OTHER INTELLECTUAL PROPERTY IN ITS ``AS IS'' CONDITION,
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY
BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE OR
INTELLECTUAL PROPERTY, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.

Carnegie Mellon encourages (but does not require) users of this
software or intellectual property to return any improvements or
extensions that they make, and to grant Carnegie Mellon the rights 
to redistribute these changes without encumbrance.

The AODV code developed by the CMU/MONARCH group was optimized and 
tuned by Samir Das and Mahesh Marina, University of Cincinnati. 
The work was partially done in Sun Microsystems.

*/

/* 
 * The original AODV code was modified to support efficient broadcasting 
 * (BCAST) by Thomas Kunz.
 */

#ifndef __bcast_h__
#define __bcast_h__

#include <cmu-trace.h>
#include <priqueue.h>
#include <classifier/classifier-port.h>
#include <MANET_multicast/mttable.h>
#include <MANET_multicast/unique_id.h>
#include <MANET_multicast/cache.h>
#include <bcast/bcast_queue.h>

class BCAST;

// Should be set by the user using best guess (conservative) 
#define NETWORK_DIAMETER	30		// 30 hops

// how much to delay packet retransmission (scaling factor)
#define BCAST_DELAY		0.100		// in seconds

/*
  Timers
*/

/* The NackTimer is used to re-trigger NACKs up to MAX_NACK times for
   a specific packet that is deemed lost. After trying for MAX_NACK times,
   we will give up. The timer is cancelled when the requested packet is
   received.
 */

#define MAX_NACK 3
#define NACK_INITIAL_DELAY 1.0	// upper bound on initial delay for NACK 
#define NACK_TIMEOUT 1.0	// timeout and try again after x second
// constants to control frequency of NACKs
#define MIN_DIFF	0.7	// do not send too many NACKs per unit time
#define PACKET_COUNT	30	// track back that many NACKs

class NackTimer_bcast : public Handler {
public:
        NackTimer_bcast(BCAST* a) : agent(a) 
		{count = 0; packet_ptr = 0; }
        void	handle(Event*);
	void	start_nack_timer(nsaddr_t p_src, unsigned int p_seqno, 
			double delay); 
	void	cancel_nack_timer(nsaddr_t p_src, unsigned int p_seqno);
	void	save_packet_time(double t_packet);
	int	control_nack_flood(); // limit flooding of NACKs
private:
        BCAST    *agent;
	Event	 intr;
	int	 count;			// how many NACKs have we tracked
	int	 packet_ptr;		// next field to store tracked NACK
	double	 packet_times[PACKET_COUNT];
	nsaddr_t src;			// source address of missing packet
	unsigned int seqno;		// sequence number of missing packet
	unsigned int retry_count;	// number of retry attempts
};

/* The RetransmitTimer is used to delay the transmission of a duplicate
   packet P. Until the packet is retransmitted, a node listens for
   retransmissions by other nodes. If it overhears another node sending
   the same packet, it will cancel its own retransmission.
 */

class RetransmitTimer_bcast : public Handler {
public:
        RetransmitTimer_bcast(BCAST* a) : agent(a) {}
        void	handle(Event*);
	void	start_rtx_timer(Packet *pck, double delay); 
	void	cancel_rtx_timer(nsaddr_t p_src, unsigned int p_seqno);
private:
        BCAST    *agent;
	Event	intr;
	nsaddr_t src;				// source address of retransmitted packet
	unsigned int seqno;			// sequence number of retransmitted packet
	Packet	*p;					// packet to be retransmitted
};

/* The HelloTimer periodically triggers the sending of HELLO messages to
   neighbors. Since this information is also available from other packets
   (i.e., piggybacked onto them), HELLO messages do get rescheduled whenever
   other data packets are transmitted.
 */

#define HELLO_INTERVAL          2               // in seconds
#define ALLOWED_HELLO_LOSS      1               // packets
#define MaxHelloInterval        (1.25 * HELLO_INTERVAL)
#define MinHelloInterval        (0.75 * HELLO_INTERVAL)

class HelloTimer_bcast : public Handler {
public:
        HelloTimer_bcast(BCAST* a) : agent(a) {}
        void	handle(Event*);
	void	reschedule();	// cancel and reschedule HELLO message
private:
        BCAST    *agent;
	Event	intr;
};

/* The NeighborTimer periodically cleans up the information about one-hop
   and two-hop neighbors. Unless this information is refreshed, it becomes
   stale and is removed.
 */

class NeighborTimer_bcast : public Handler {
public:
        NeighborTimer_bcast(BCAST* a) : agent(a) {}
        void	handle(Event*);
private:
        BCAST    *agent;
	Event	intr;
};

/*
   BCAST Neighbor Cache Entry
*/

class BCAST_Neighbor {
        friend class BCAST;
 public:
        BCAST_Neighbor(u_int32_t a) { nb_addr = a; nb_no_of_neighbors=0; }
 protected:
        LIST_ENTRY(BCAST_Neighbor) nb_link;
        nsaddr_t        nb_addr;
        double          nb_expire;      // ALLOWED_HELLO_LOSS * HELLO_INTERVAL
	int		nb_no_of_neighbors;
	nsaddr_t	nb_neighbors[NEIGHBOR_COUNT];
};

LIST_HEAD(bcast_ncache, BCAST_Neighbor);

#define CACHE_SIZE 10		// cache size for recently transmitted packets
#define ILLEGAL_NODE 1000	// higher than the highest legal node number
/*
  The Routing Agent
*/
class BCAST: public Agent {

	/*
	 * make some friends first 
	 */

	friend class NackTimer_bcast;
	friend class RetransmitTimer_bcast;
        friend class HelloTimer_bcast;
        friend class NeighborTimer_bcast;
	friend class BCASTHandler;

 public:
        BCAST(nsaddr_t id);

        void		recv(Packet *p, Handler *);

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

        /*
         * Neighbor Management
         */
        void            nb_insert(nsaddr_t id);
        BCAST_Neighbor* nb_lookup(nsaddr_t id);
        void            nb_delete(nsaddr_t id);
        void            nb_purge(void);
	void		add_neighbors(BCAST_Neighbor *nb, int num_neigbors,
						nsaddr_t *one_hop_neighors);
	void		nb_determine_degrees(int *max, int *n);
        /*
         * Packet TX Routines
         */
        void            forward(Packet *p);
        void            sendHello(void);
	void		sendNack(nsaddr_t id, u_int32_t bid);
	void		sendPacket(Packet *p, double delay);
                                          
        /*
         * Packet RX Routines
         */
	void		recvBCAST(Packet *p);
        void            recvHello(Packet *p);
	void		recvNack(Packet *p);

        nsaddr_t        index;          // IP Address of this node
        mttable		mtable;		// Multicast Groups node joined

        /*
         * Handle duplicate packets
         */

        UniqueIDHandler  uid_handler;

        bcast_ncache	 nbhead;                 // Neighbor Cache

        /*
         * Timers
         */
	NackTimer_bcast       nacktimer;
	RetransmitTimer_bcast rtxtimer;
        HelloTimer_bcast      htimer;
        NeighborTimer_bcast   ntimer;

        /*
         *  A queue used by the routing layer to buffer
         *  packets before it broadcasts them.
         */
        BCASTHandler	bcast_queue;

	/*
	 * A cache of recently transmitted packets
	 */
	PacketCache 	p_cache;

        /*
         * 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;

        /* for passing packets up to agents */
        PortClassifier *dmux_;

};

#endif /* __bcast_h__ */