inet::ieee80211::Ds Class Reference

The default implementation of IDs. More...

#include <Ds.h>

Inheritance diagram for inet::ieee80211::Ds:

Public Member Functions
virtual void	processDataFrame (Packet *frame, const Ptr< const Ieee80211DataHeader > &header) override
Public Member Functions inherited from inet::ieee80211::IDs
virtual	~IDs ()

Protected Member Functions
virtual void	initialize (int stage) override
virtual void	distributeDataFrame (Packet *frame, const Ptr< const Ieee80211DataOrMgmtHeader > &header)
	Utility function for APs: sends back a data frame we received from a STA to the wireless LAN, after tweaking fromDS/toDS bits and shuffling addresses as needed. More...

Protected Attributes
Ieee80211Mib *	mib = nullptr
Ieee80211Mac *	mac = nullptr

Detailed Description

The default implementation of IDs.

Member Function Documentation

distributeDataFrame()

void inet::ieee80211::Ds::distributeDataFrame ( Packet *  frame, const Ptr< const Ieee80211DataOrMgmtHeader > &  header  )

protectedvirtual

Utility function for APs: sends back a data frame we received from a STA to the wireless LAN, after tweaking fromDS/toDS bits and shuffling addresses as needed.

{
    EV_INFO << "Distributing data frame.\n";
    incomingFrame->trim();
    const auto& outgoingHeader = staticPtrCast<Ieee80211DataOrMgmtHeader>(incomingHeader->dupShared());
 
    // adjust toDS/fromDS bits, and shuffle addresses
    outgoingHeader->setToDS(false);
    outgoingHeader->setFromDS(true);
 
    // move destination address to address1 (receiver address),
    // and fill address3 with original source address;
    ASSERT(!outgoingHeader->getAddress3().isUnspecified());
    outgoingHeader->setReceiverAddress(incomingHeader->getAddress3());
    outgoingHeader->setAddress3(incomingHeader->getTransmitterAddress());
 
    auto outgoingFrame = new Packet(incomingFrame->getName(), incomingFrame->peekData());
    outgoingFrame->insertAtFront(outgoingHeader);
    const auto& trailer = makeShared<Ieee80211MacTrailer>();
    // TODO add module parameter, implement fcs computing
    // TODO trailer->setFcsMode(FCS_COMPUTED);
    outgoingFrame->insertAtBack(trailer);
    mac->processUpperFrame(outgoingFrame, outgoingHeader);
}

Referenced by processDataFrame().

initialize()

void inet::ieee80211::Ds::initialize ( int  stage )

overrideprotectedvirtual

{
    if (stage == INITSTAGE_LOCAL) {
        mac = check_and_cast<Ieee80211Mac *>(getContainingNicModule(this)->getSubmodule("mac"));
        mib = check_and_cast<Ieee80211Mib *>(getModuleByPath(par("mibModule")));
    }
}

processDataFrame()

void inet::ieee80211::Ds::processDataFrame ( Packet *  frame, const Ptr< const Ieee80211DataHeader > &  header  )

overridevirtual

Implements inet::ieee80211::IDs.

{
    Enter_Method("processDataFrame");
    take(frame);
    if (mib->mode == Ieee80211Mib::INDEPENDENT)
        mac->sendUp(frame);
    else if (mib->mode == Ieee80211Mib::INFRASTRUCTURE) {
        if (mib->bssStationData.stationType == Ieee80211Mib::ACCESS_POINT) {
            // check toDS bit
            if (!header->getToDS()) {
                // looks like this is not for us - discard
                EV_WARN << "Frame is not for us (toDS=false) -- discarding\n";
                PacketDropDetails details;
                details.setReason(NOT_ADDRESSED_TO_US);
                emit(packetDroppedSignal, frame, &details);
                delete frame;
                return;
            }
            // handle broadcast/multicast frames
            if (header->getAddress3().isMulticast()) {
                EV_INFO << "Handling multicast frame\n";
                distributeDataFrame(frame, header);
                mac->sendUp(frame);
                return;
            }
            // look up destination address in our STA list
            auto it = mib->bssAccessPointData.stations.find(header->getAddress3());
            if (it == mib->bssAccessPointData.stations.end()) {
                EV_WARN << "Frame's destination address is not in our STA list -- passing up\n";
                mac->sendUp(frame);
            }
            else {
                // dest address is our STA, but is it already associated?
                if (it->second == Ieee80211Mib::ASSOCIATED) {
                    distributeDataFrame(frame, header); // send it out to the destination STA
                    delete frame;
                }
                else {
                    EV_WARN << "Frame's destination STA is not in associated state -- dropping frame\n";
                    PacketDropDetails details;
                    details.setReason(OTHER_PACKET_DROP);
                    emit(packetDroppedSignal, frame, &details);
                    delete frame;
                }
            }
        }
        else if (mib->bssStationData.stationType == Ieee80211Mib::STATION) {
            if (!mib->bssStationData.isAssociated) {
                EV_WARN << "Rejecting data frame as STA is not associated with an AP" << endl;
                PacketDropDetails details;
                details.setReason(OTHER_PACKET_DROP);
                emit(packetDroppedSignal, frame, &details);
                delete frame;
            }
            else if (mib->bssData.bssid != header->getTransmitterAddress()) {
                EV_WARN << "Rejecting data frame received from another AP" << endl;
                PacketDropDetails details;
                details.setReason(OTHER_PACKET_DROP);
                emit(packetDroppedSignal, frame, &details);
                delete frame;
            }
            else
                mac->sendUp(frame);
        }
        else
            throw cRuntimeError("Unknown station type");
    }
    else
        throw cRuntimeError("Unknown mode");
}

Member Data Documentation

mac

Ieee80211Mac* inet::ieee80211::Ds::mac = nullptr

protected

Referenced by distributeDataFrame(), initialize(), and processDataFrame().

mib

Ieee80211Mib* inet::ieee80211::Ds::mib = nullptr

protected

Referenced by initialize(), and processDataFrame().

---

The documentation for this class was generated from the following files:

• Ds.h
• Ds.cc