/Users/yzchen/ns/ns-allinone-2.33/ns-2.33/mac/mac-802_3.h

#ifndef __mac_802_3_h__
#define __mac_802_3_h__

#include <assert.h>
#include "mac.h"

#define min(x, y)       ((x) < (y) ? (x) : (y))
#define ETHER_HDR_LEN           ((ETHER_ADDR_LEN << 1) + ETHER_TYPE_LEN)

/*
 10Mbps:
#define IEEE_8023_SLOT          0.000051200     // 512 bit times
#define IEEE_8023_IFS           0.000009600     // 9.6us interframe spacing
 100Mbps:
#define IEEE_8023_SLOT                0.0000051200    //512 bit time
#define IEEE_8023_IFS                 0.0000009600    //0.96us interframe spacing
*/
#define IEEE_8023_SLOT_BITS             512.0 //when we divide these by the bandwidth
#define IEEE_8023_IFS_BITS               96.0 //we'll have what we want

#define IEEE_8023_ALIMIT        16              // attempt limit
#define IEEE_8023_BLIMIT        10              // backoff limit
#define IEEE_8023_JAMSIZE       32              // bits
#define IEEE_8023_MAXFRAME      1518            // bytes
#define IEEE_8023_MINFRAME      64              // bytes
#define INVALID_UID             -1              // Used for mac level traces
#define INVALID_TIME            -1

/* ======================================================================
   Handler Functions
   ====================================================================== */
class Mac802_3;

class MacHandler : public Handler {
public:
        MacHandler(Mac802_3* m) :  callback(0), mac(m), busy_(false) {}
        virtual void handle(Event *e) = 0;
        virtual inline void cancel();
        bool busy(void) { return busy_; }
        double expire(void) { return intr.time_; }
protected:
        Handler         *callback;
        Mac802_3        *mac;
        Event           intr;
        bool            busy_;
};


class Mac8023HandlerSend : public MacHandler {
 public:
        Mac8023HandlerSend(Mac802_3* m) : MacHandler(m), p_(0) {}
        void handle(Event*);
        void schedule(const Packet *p, double t);
        void cancel();
        const Packet *packet() const { return p_; }
 protected:
        const Packet *p_;
};

class MacHandlerRecv : public MacHandler {
public:
        MacHandlerRecv(Mac802_3* m) : MacHandler(m), p_(0) {}
        void handle(Event*);
        void schedule(Packet *p, double t);
        virtual void cancel();
private:
        Packet *p_;
};

class MacHandlerRetx : public MacHandler {
 public:
        MacHandlerRetx(Mac802_3* m) : MacHandler(m), p_(0), try_(1) {}
        void reset() {
                // before calling reset, you MUST free or drop p_
                if (busy_) cancel();
                try_= 1;
                p_= 0;
        }
        void handle(Event*);
        bool schedule(double delta=0.0);
        void cancel();
        void free() { 
                if (p_) {
                        Packet::free(p_);
                        p_= 0;
                }
        }
        Packet* packet() const { return p_; }
        void packet(Packet *p) { p_= p; }
private:
        Packet *p_;
        int try_;
};
                
class MacHandlerIFS : public MacHandler {
 public:
        MacHandlerIFS(Mac802_3* m) : MacHandler(m) {}
        void handle (Event*); 
        void schedule(double t);
        void cancel();
};


/* ======================================================================
   MAC data structure
   ====================================================================== */
class Mac802_3 : public Mac {
        friend class MacHandler;
        friend class MacHandlerRecv;
        friend class Mac8023HandlerSend;
        friend class MacHandlerRetx;
        friend class MacHandlerIFS;
 public:
        Mac802_3();

        void recv(Packet* p, Handler* h) {
                BiConnector::recv(p, h);
        }

 protected:
        void sendDown(Packet* p, Handler* h);
        void sendUp(Packet* p, Handler* h);
        /*
        inline int      hdr_dst(char* hdr, u_int32_t dst = -2);
        inline int      hdr_src(char* hdr, u_int32_t src = -2);
        inline int      hdr_type(char* hdr, u_int16_t type = 0);
        */
        
        void            recv_complete(Packet *p);
        virtual void    resume();

        //protected:
        virtual void    transmit(Packet* p);
        int trace_;      // To turn on MAC level collision traces 
private:
        //void          send(Packet *p, Handler *h);
        void            collision(Packet *p);

        //int           pktTxcnt;

        MacHandlerRecv  mhRecv_;
        MacHandlerRetx  mhRetx_;
        MacHandlerIFS   mhIFS_;
        Mac8023HandlerSend      mhSend_;
        
};


#endif /* __mac_802_3_h__ */