Mac80211.h

/* -*- mode:c++ -*- ********************************************************
 * file:        Mac80211.h
 *
 * author:      David Raguin/Marc L�bbers
 *
 * copyright:   (C) 2004 Telecommunication Networks Group (TKN) at
 *              Technische Universitaet Berlin, Germany.
 *
 *              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.
 *              For further information see file COPYING
 *              in the top level directory
 ***************************************************************************
 * part of:     framework implementation developed by tkn
 **************************************************************************/


#ifndef MAC_80211_H
#define MAC_80211_H

#include <list>
#include <BaseMacLayer.h>
#include <Mac80211Pkt_m.h>
#include <Consts80211.h>
#include <ChannelSenseRequest_m.h>

class  Mac80211 : public BaseMacLayer
{
public:

  enum Mac80211MessageKinds {
    //between MAC layers of two nodes
    RTS = LAST_BASE_MAC_MESSAGE_KIND, // request to send
    CTS,                 // clear to send
    ACK,                 // acknowledgement
    DATA,
    BROADCAST,
    LAST_MAC_80211_MESSAGE_KIND
  };
protected:
    typedef std::list<Mac80211Pkt*> MacPktList;

    enum timerType {
      TIMEOUT,
      NAV
    };

    enum State {
      WFDATA = 0, // waiting for data packet
      QUIET = 1,  // waiting for the communication between two other nodes to end
      IDLE = 2,   // no packet to send, no packet receiving
      CONTEND = 3,// contention state (battle for the channel)
      WFCTS = 4,  // RTS sent, waiting for CTS
      WFACK = 5,  // DATA packet sent, waiting for ACK
      BUSY = 6    // during transmission of an ACK or a BROADCAST packet
    };

    struct NeighborEntry {
        int address;
        int fsc;
        simtime_t age;
        double bitrate;
    };

    typedef std::list<NeighborEntry> NeighborList;

  public:
    virtual ~Mac80211();

    virtual void initialize(int);
    virtual void finish();

 protected:

  virtual void handleSelfMsg(cMessage*);

  virtual void handleUpperMsg(cMessage* msg);

  virtual void handleLowerMsg(cMessage*);

  virtual void handleLowerControl(cMessage*);


    //virtual void receiveBBItem(int category, const BBItem *details, int scopeModuleId);

    virtual void handleEndContentionTimer();

    void handleMsgNotForMe(cMessage *af, simtime_t duration);
    void handleMsgForMe(Mac80211Pkt*);
    // ** @brief handle a Broadcast message*/
    void handleBroadcastMsg(Mac80211Pkt*);

    void handleEndTransmission();

    void handleEndSifsTimer();
    void handleTimeoutTimer();
    void handleNavTimer();

    void handleRTSframe(Mac80211Pkt*);

    void handleDATAframe(Mac80211Pkt*);

    void handleACKframe(Mac80211Pkt*);

    void handleCTSframe(Mac80211Pkt*);

    void dataTransmissionFailed();

    void rtsTransmissionFailed();

    virtual void sendDATAframe(Mac80211Pkt*);

    void sendACKframe(Mac80211Pkt*);

    void sendCTSframe(Mac80211Pkt*);

    virtual void sendRTSframe();

    void sendBROADCASTframe();

    Mac80211Pkt* encapsMsg(cPacket *netw);

    cMessage* decapsMsg(Mac80211Pkt *frame);

    virtual void beginNewCycle();

    simtime_t backoff(bool rtscts = true);

    void testMaxAttempts();

    simtime_t timeOut(Mac80211MessageKinds type, double br);

    simtime_t packetDuration(double bits, double br);

    const char *stateName(State state);

    void setState(State state);

    bool rtsCts(Mac80211Pkt* m) {
        return m->getBitLength() - MAC80211_HEADER_LENGTH > rtsCtsThreshold;
    }

    void suspendContention();

    double retrieveBitrate(int destAddress);

    void addNeighbor(Mac80211Pkt *af);

    NeighborList::iterator findNeighbor(int id)  {
        NeighborList::iterator it;
        for(it = neighbors.begin(); it != neighbors.end(); ++it) {
            if(it->address == id) break;
        }
        return it;
    }

    NeighborList::iterator findOldestNeighbor() {
        NeighborList::iterator it = neighbors.begin();
        NeighborList::iterator oldIt = neighbors.begin();
        simtime_t age = it->age;
        for(; it != neighbors.end(); ++it) {
            if(it->age < age) {
                age = it->age;
                oldIt = it;
            }
        }
        return oldIt;
    }


    void senseChannelWhileIdle(simtime_t duration);

    Signal* createSignal(simtime_t start, simtime_t length, double power, double bitrate);

protected:

    // TIMERS:

    cMessage* timeout;

    cMessage* nav;

    ChannelSenseRequest* contention;

    ChannelSenseRequest* endSifs;

    simtime_t chSenseStart;

    State state;

    double defaultBitrate;

    double txPower;

    double centerFreq;

    double bitrate;
    int catBitrate;
    bool autoBitrate;
    std::vector<double> snrThresholds;

    unsigned queueLength;

    bool nextIsBroadcast;

    MacPktList fromUpperLayer;

    unsigned longRetryCounter;

    unsigned shortRetryCounter;

    simtime_t remainingBackoff;

    simtime_t currentIFS;

    int rtsCtsThreshold;

    simtime_t delta;

    unsigned neighborhoodCacheSize;
    simtime_t neighborhoodCacheMaxAge;

    NeighborList neighbors;

    bool switching;

    int fsc;
};

#endif