mac-802_11.h

ns2.1b5版本中cbrp碼

/* -*- c++ -*-
   mac-802_11.h

   $Id: mac-802_11.h,v 1.9 1998/09/21 19:26:31 dmaltz Exp $
   */
#ifndef __mac_80211_h__
#define __mac_80211_h__

#include <cmu/mac-timers.h>

#include <cmu/marshall.h>

#define GET_ETHER_TYPE(x)		GET2BYTE((x))
#define SET_ETHER_TYPE(x,y)               {u_int16_t t = (y); STORE2BYTE(x,&t);}

/* ======================================================================
   Frame Formats
   ====================================================================== */

#define	MAC_ProtocolVersion	0x00

#define MAC_Type_Management	0x00
#define MAC_Type_Control	0x01
#define MAC_Type_Data		0x02
#define MAC_Type_Reserved	0x03

#define MAC_Subtype_RTS		0x0B
#define MAC_Subtype_CTS		0x0C
#define MAC_Subtype_ACK		0x0D
#define MAC_Subtype_Data	0x00

struct frame_control {
	u_char		fc_subtype		: 4;
	u_char		fc_type			: 2;
	u_char		fc_protocol_version	: 2;

	u_char		fc_order		: 1;
	u_char		fc_wep			: 1;
	u_char		fc_more_data		: 1;
	u_char		fc_pwr_mgt		: 1;
	u_char		fc_retry		: 1;
	u_char		fc_more_frag		: 1;
	u_char		fc_from_ds		: 1;
	u_char		fc_to_ds		: 1;
};

struct rts_frame {
	struct frame_control	rf_fc;
	u_int16_t		rf_duration;
	u_char			rf_ra[ETHER_ADDR_LEN];
	u_char			rf_ta[ETHER_ADDR_LEN];
	u_char			rf_fcs[ETHER_FCS_LEN];
};

struct cts_frame {
	struct frame_control	cf_fc;
	u_int16_t		cf_duration;
	u_char			cf_ra[ETHER_ADDR_LEN];
	u_char			cf_fcs[ETHER_FCS_LEN];
};

struct ack_frame {
	struct frame_control	af_fc;
	u_int16_t		af_duration;
	u_char			af_ra[ETHER_ADDR_LEN];
	u_char			af_fcs[ETHER_FCS_LEN];
};

struct hdr_mac802_11 {
	struct frame_control	dh_fc;
	u_int16_t		dh_duration;
	u_char			dh_da[ETHER_ADDR_LEN];
	u_char			dh_sa[ETHER_ADDR_LEN];
	u_char			dh_bssid[ETHER_ADDR_LEN];
	u_int16_t		dh_scontrol;
	u_char			dh_body[0];
};


/* ======================================================================
   Definitions
   ====================================================================== */
#define ETHER_HDR_LEN				\
	((phymib->PreambleLength >> 3) +	\
	 (phymib->PLCPHeaderLength >> 3) +	\
	 sizeof(struct hdr_mac802_11) +		\
	 ETHER_FCS_LEN)

#define ETHER_RTS_LEN				\
	((phymib->PreambleLength >> 3) +        \
         (phymib->PLCPHeaderLength >> 3) +      \
	 sizeof(struct rts_frame))

#define ETHER_CTS_LEN				\
        ((phymib->PreambleLength >> 3) +        \
         (phymib->PLCPHeaderLength >> 3) +      \
         sizeof(struct cts_frame))

#define ETHER_ACK_LEN				\
        ((phymib->PreambleLength >> 3) +        \
         (phymib->PLCPHeaderLength >> 3) +      \
	 sizeof(struct ack_frame))

#define	RTS_Time	(8 * ETHER_RTS_LEN / bitRate)
#define CTS_Time	(8 * ETHER_CTS_LEN / bitRate)
#define ACK_Time	(8 * ETHER_ACK_LEN / bitRate)
#define DATA_Time(len)	(8 * (len) / bitRate)

/*
 *  IEEE 802.11 Spec, section 9.2.5.7
 *	- After transmitting an RTS, a node waits CTSTimeout
 *	  seconds for a CTS.
 *
 *  IEEE 802.11 Spec, section 9.2.8
 *	- After transmitting DATA, a node waits ACKTimeout
 *	  seconds for an ACK.
 *
 *  IEEE 802.11 Spec, section 9.2.5.4
 *	- After hearing an RTS, a node waits NAVTimeout seconds
 *	  before resetting its NAV.  I've coined the variable
 *	  NAVTimeout.
 *
 */
#define CTSTimeout	((RTS_Time + CTS_Time) + 2 * sifs)
#define ACKTimeout(len)	(DATA_Time(len) + ACK_Time + sifs + difs)
#define NAVTimeout	(2 * phymib->SIFSTime + CTS_Time + 2 * phymib->SlotTime)



#define RTS_DURATION(pkt)	\
	usec(sifs + CTS_Time + sifs + TX_Time(pkt) + sifs + ACK_Time)

#define CTS_DURATION(d)		\
	usec((d * 1e-6) - (CTS_Time + sifs))

#define DATA_DURATION()		\
	usec(ACK_Time + sifs)

#define ACK_DURATION()	0x00		// we're not doing fragments now

/*
 * IEEE 802.11 Spec, section 15.3.2
 *	- default values for the DSSS PHY MIB
 */
#define DSSS_CWMin			31
#define DSSS_CWMax			1023
#define DSSS_SlotTime			0.000020	// 20us
#define	DSSS_CCATime			0.000015	// 15us
#define DSSS_RxTxTurnaroundTime		0.000005	// 5us
#define DSSS_SIFSTime			0.000010	// 10us
#define DSSS_PreambleLength		144		// 144 bits
#define DSSS_PLCPHeaderLength		48		// 48 bits

class PHY_MIB {
public:
	u_int32_t	CWMin;
	u_int32_t	CWMax;
	double		SlotTime;
	double		CCATime;
	double		RxTxTurnaroundTime;
	double		SIFSTime;
	u_int32_t	PreambleLength;
	u_int32_t	PLCPHeaderLength;
};


/*
 * IEEE 802.11 Spec, section 11.4.4.2
 *      - default values for the MAC Attributes
 */
#define MAC_RTSThreshold		3000		// bytes
#define MAC_ShortRetryLimit		7		// retransmittions
#define MAC_LongRetryLimit		4		// retransmissions
#define MAC_FragmentationThreshold	2346		// bytes
#define MAC_MaxTransmitMSDULifetime	512		// time units
#define MAC_MaxReceiveLifetime		512		// time units

class MAC_MIB {
public:
	//		MACAddress;
	//		GroupAddresses;
	u_int32_t	RTSThreshold;
	u_int32_t	ShortRetryLimit;
	u_int32_t	LongRetryLimit;
	u_int32_t	FragmentationThreshold;
	u_int32_t	MaxTransmitMSDULifetime;
	u_int32_t	MaxReceiveLifetime;
	//		ManufacturerID;
	//		ProductID;

	u_int32_t	TransmittedFragmentCount;
	u_int32_t	MulticastTransmittedFrameCount;
	u_int32_t	FailedCount;	
	u_int32_t	RetryCount;
	u_int32_t	MultipleRetryCount;
	u_int32_t	FrameDuplicateCount;
	u_int32_t	RTSSuccessCount;
	u_int32_t	RTSFailureCount;
	u_int32_t	ACKFailureCount;
	u_int32_t	ReceivedFragmentCount;
	u_int32_t	MulticastReceivedFrameCount;
	u_int32_t	FCSErrorCount;
};


/* ======================================================================
   The following destination class is used for duplicate detection.
   ====================================================================== */
class Host {
public:
	LIST_ENTRY(Host) link;
	u_int32_t	index;
	u_int32_t	seqno;
};


/* ======================================================================
   The actual 802.11 MAC class.
   ====================================================================== */
class Mac802_11 : public Mac {
	friend class DeferTimer;
	friend class BackoffTimer;
	friend class IFTimer;
	friend class NavTimer;
	friend class RxTimer;
	friend class TxTimer;
public:
	Mac802_11(PHY_MIB* p, MAC_MIB *m);
	void		recv(Packet *p, Handler *h);
	inline int	hdr_dst(char* hdr, u_int32_t dst = 0);
	inline int	hdr_src(char* hdr, u_int32_t src = 0);
	inline int	hdr_type(char* hdr, u_int16_t type = 0);

protected:
	void	backoffHandler(void);
	void	deferHandler(void);
	void	navHandler(void);
	void	recvHandler(void);
	void	sendHandler(void);
	void	txHandler(void);

private:
	int		command(int argc, const char*const* argv);

	/*
	 * Called by the timers.
	 */
	void		recv_timer(void);
	void		send_timer(void);
	int		check_pktCTRL();
	int		check_pktRTS();
	int		check_pktTx();

	/*
	 * Packet Transmission Functions.
	 */
	void	send(Packet *p, Handler *h);
	void 	sendRTS(int dst);
	void	sendCTS(int dst, double duration);
	void	sendACK(int dst);
	void	sendDATA(Packet *p);
	void	RetransmitRTS();
	void	RetransmitDATA();

	/*
	 * Packet Reception Functions.
	 */
	void	recvRTS(Packet *p);
	void	recvCTS(Packet *p);
	void	recvACK(Packet *p);
	void	recvDATA(Packet *p);

	void		capture(Packet *p);
	void		collision(Packet *p);
	void		discard(Packet *p, const char* why);
	void		rx_resume(void);
	void		tx_resume(void);

	inline int	is_idle(void);

	/*
	 * Debugging Functions.
	 */
	void		trace_pkt(Packet *p);
	void		dump(char* fname);

	inline int initialized() {
		return (phymib && macmib && cache && logtarget_ && Mac::initialized());
	}

	void mac_log(Packet *p) {
		logtarget_->recv(p, (Handler*) 0);
	}

	inline double TX_Time(Packet *p) {
		struct hdr_cmn *ch = HDR_CMN(p);
		double t = DATA_Time(ch->size());

		if(t < 0.0) {
			drop(p, "XXX");
			exit(1);
		}
		return t;
	}

	inline void inc_cw() {
		cw = (cw << 1) + 1;
		if(cw > phymib->CWMax)
			cw = phymib->CWMax;
	}

	inline void rst_cw() { cw = phymib->CWMin; }

	inline void set_nav(u_int16_t us) {
		double now = Scheduler::instance().clock();
		double t = us * 1e-6;

		if((now + t) > nav) {
			nav = now + t;
			if(mhNav.busy())
				mhNav.stop();
			mhNav.start(t);
		}
	}

	inline u_int16_t usec(double t) {
		u_int16_t us = (u_int16_t) (t *= 1e6);
		if(us < t)
			us++;
		return us;
	}

protected:
	PHY_MIB		*phymib;
	MAC_MIB		*macmib;

private:
	/*
	 * Mac Timers
	 */
	IFTimer		mhIF;		// interface timer
	NavTimer	mhNav;		// NAV timer
	RxTimer		mhRecv;		// incoming packets
	TxTimer		mhSend;		// outgoing packets

	DeferTimer	mhDefer;	// defer timer
	BackoffTimer	mhBackoff;	// backoff timer

	/* ============================================================
	   Internal MAC State
	   ============================================================ */
	double		nav;		// Network Allocation Vector

	MacState	rx_state;	// incoming state (MAC_RECV or MAC_IDLE)
	MacState	tx_state;	// outgoint state
#if 1
	int		tx_active;	// transmitter is ACTIVE
#endif

	Packet		*pktRTS;	// outgoing RTS packet
	Packet		*pktCTRL;	// outgoing non-RTS packet

	u_int32_t	cw;		// Contention Window
	u_int32_t	ssrc;		// STA Short Retry Count
	u_int32_t	slrc;		// STA Long Retry Count
	double		sifs;		// Short Interface Space
	double		pifs;		// PCF Interframe Space
	double		difs;		// DCF Interframe Space
	double		eifs;		// Extended Interframe Space
	double		tx_sifs;
	double		tx_pifs;
	double		tx_difs;

	int		min_frame_len;

	NsObject*	logtarget_;

	/* ============================================================
	   Duplicate Detection state
	   ============================================================ */
	u_int16_t	sta_seqno;	// next seqno that I'll use
	int		cache_node_count;
	Host		*cache;
};


#endif /* __mac_80211_h__ */