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 "BasicLayer.h"
#include "Mac80211Pkt_m.h"
#include "Consts80211.h"
#include "RadioState.h"
#include "Bitrate.h"
#include <ActiveChannel.h>
#include "SingleChannelRadio.h"
#include <MediumIndication.h>

class  Mac80211 : public BasicLayer
{
protected:
    typedef std::list<Mac80211Pkt*> MacPktList;

    enum timerType {
      TIMEOUT,
      NAV,
      CONTENTION,
      END_SIFS
    };

    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:
    Module_Class_Members(Mac80211, BasicLayer, 0);

    virtual void initialize(int);
    virtual void finish();
    
  protected:
    virtual void receiveBBItem(int category, const BBItem *details, int scopeModuleId);

    virtual void handleSelfMsg(cMessage*);

    virtual void handleUpperMsg(cMessage*);

    virtual void handleLowerMsg(cMessage*);

    virtual void handleLowerControl(cMessage*);

    virtual void handleEndContentionTimer();
    
    void handleMsgNotForMe(cMessage *af, double 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*);

    virtual void sendDATAframe(Mac80211Pkt*);

    void sendACKframe(Mac80211Pkt*);

    void sendCTSframe(Mac80211Pkt*);

    virtual void sendRTSframe();

    void sendBROADCASTframe();

    Mac80211Pkt* encapsMsg(cMessage *netw);

    cMessage* decapsMsg(Mac80211Pkt *frame);
    
    virtual void beginNewCycle();

    double backoff();

    int contentionWindow();

    void testMaxAttempts();

    double timeOut(frameType_802_11 type, double br);

    double packetDuration(double bits, double br);

    const char *stateName(State state);

    void setState(State state);

    bool rtsCts(Mac80211Pkt* m) {
        return m->length() - 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;
    }
    
protected:
    int myMacAddr;

    // TIMERS:

    cMessage* timeout;

    cMessage* nav;

    cMessage* contention;
    
    cMessage* endSifs;

    State state;

    RadioState::States radioState;
    int catRadioState;
    
    MediumIndication::States medium;

    int catMedium;

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

    SingleChannelRadio* radio;

    unsigned queueLength;

    bool nextIsBroadcast;

    MacPktList fromUpperLayer;

    unsigned longRetryCounter;

    unsigned shortRetryCounter;
    
    simtime_t remainingBackoff;
    
    int rtsCtsThreshold;

    double delta;

    unsigned neighborhoodCacheSize;
    simtime_t neighborhoodCacheMaxAge;

    NeighborList neighbors;

    bool switching;

    int fsc;
};

#endif

---