inet::AckingMac Class Reference

Implements a simplified ideal MAC. More...

#include <AckingMac.h>

Inheritance diagram for inet::AckingMac:

Public Member Functions
	AckingMac ()
virtual	~AckingMac ()
virtual queueing::IPassivePacketSource *	getProvider (cGate *gate) override
	Returns the passive packet source from where packets are pulled or nullptr if the connected module doesn't implement the interface. More...
virtual void	handleCanPullPacketChanged (cGate *gate) override
	Notifies about a change in the possibility of pulling some packet from the passive packet source at the given gate. More...
virtual void	handlePullPacketProcessed (Packet *packet, cGate *gate, bool successful) override
	Notifies about the completion of the packet processing for a packet that was pulled earlier independently whether the packet is passed or streamed. More...
Public Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual	~OperationalMixin ()
	}@ More...
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()
Public Member Functions inherited from inet::IMacProtocol
virtual	~IMacProtocol ()
Public Member Functions inherited from inet::queueing::IActivePacketSink
virtual	~IActivePacketSink ()

Protected Member Functions
virtual void	configureNetworkInterface () override
	implements MacBase functions More...
virtual void	startTransmitting ()
virtual bool	dropFrameNotForUs (Packet *frame)
virtual void	encapsulate (Packet *msg)
virtual void	decapsulate (Packet *frame)
virtual void	acked (Packet *packet)
virtual void	receiveSignal (cComponent *src, simsignal_t id, intval_t value, cObject *details) override
virtual void	handleUpperPacket (Packet *packet) override
	implements MacProtocolBase functions More...
virtual void	handleLowerPacket (Packet *packet) override
virtual void	handleSelfMessage (cMessage *message) override
virtual void	handleStartOperation (LifecycleOperation *operation) override
virtual void	handleStopOperation (LifecycleOperation *operation) override
virtual void	handleCrashOperation (LifecycleOperation *operation) override
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	processUpperPacket ()
Protected Member Functions inherited from inet::MacProtocolBase
	MacProtocolBase ()
virtual	~MacProtocolBase ()
virtual void	registerInterface ()
virtual MacAddress	parseMacAddressParameter (const char *addrstr)
virtual void	deleteCurrentTxFrame ()
virtual void	dropCurrentTxFrame (PacketDropDetails &details)
virtual void	handleMessageWhenDown (cMessage *msg) override
virtual void	sendUp (cMessage *message)
virtual void	sendDown (cMessage *message)
virtual bool	isUpperMessage (cMessage *message) const override
virtual bool	isLowerMessage (cMessage *message) const override
virtual bool	isInitializeStage (int stage) const override
virtual bool	isModuleStartStage (int stage) const override
virtual bool	isModuleStopStage (int stage) const override
virtual void	flushQueue (PacketDropDetails &details)
	should clear queue and emit signal "packetDropped" with entire packets More...
virtual void	clearQueue ()
	should clear queue silently More...
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override
queueing::IPacketQueue *	getQueue (cGate *gate) const
virtual bool	canDequeuePacket () const
virtual Packet *	dequeuePacket ()
Protected Member Functions inherited from inet::LayeredProtocolBase
virtual void	handleMessageWhenUp (cMessage *message) override
virtual void	handleUpperMessage (cMessage *message)
virtual void	handleLowerMessage (cMessage *message)
virtual void	handleUpperCommand (cMessage *message)
virtual void	handleLowerCommand (cMessage *message)
Protected Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual int	numInitStages () const override
virtual void	refreshDisplay () const override
virtual void	handleMessage (cMessage *msg) override
virtual bool	handleOperationStage (LifecycleOperation *operation, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual State	getInitialOperationalState () const
	Returns initial operational state: OPERATING or NOT_OPERATING. More...
virtual void	handleActiveOperationTimeout (cMessage *message)
virtual bool	isUp () const
	utility functions More...
virtual bool	isDown () const
virtual void	setOperationalState (State newState)
virtual void	scheduleOperationTimeout (simtime_t timeout)
virtual void	setupActiveOperation (LifecycleOperation *operation, IDoneCallback *doneCallback, State)
virtual void	delayActiveOperationFinish (simtime_t timeout)
virtual void	startActiveOperationExtraTime (simtime_t delay=SIMTIME_ZERO)
virtual void	startActiveOperationExtraTimeOrFinish (simtime_t extraTime)
virtual void	finishActiveOperation ()

Protected Attributes
int	headerLength = 0
double	bitrate = 0
bool	promiscuous = false
bool	fullDuplex = false
bool	useAck = true
physicallayer::IRadio *	radio = nullptr
physicallayer::IRadio::TransmissionState	transmissionState = physicallayer::IRadio::TRANSMISSION_STATE_UNDEFINED
simtime_t	ackTimeout
cMessage *	ackTimeoutMsg = nullptr
Protected Attributes inherited from inet::MacProtocolBase
int	upperLayerInGateId = -1
	Gate ids. More...
int	upperLayerOutGateId = -1
int	lowerLayerInGateId = -1
int	lowerLayerOutGateId = -1
opp_component_ptr< NetworkInterface >	networkInterface
opp_component_ptr< cModule >	hostModule
Packet *	currentTxFrame = nullptr
	Currently transmitted frame if any. More...
opp_component_ptr< queueing::IPacketQueue >	txQueue
	Messages received from upper layer and to be transmitted later. More...
Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState
simtime_t	lastChange
Operation	activeOperation
cMessage *	activeOperationTimeout
cMessage *	activeOperationExtraTimer

Additional Inherited Members
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State

Detailed Description

Implements a simplified ideal MAC.

See the NED file for details.

Constructor & Destructor Documentation

AckingMac()

inet::AckingMac::AckingMac

(

)

{
}

~AckingMac()

inet::AckingMac::~AckingMac ( )

virtual

{
    cancelAndDelete(ackTimeoutMsg);
}

Member Function Documentation

acked()

void inet::AckingMac::acked ( Packet *  packet )

protectedvirtual

{
    Enter_Method("acked");
    ASSERT(useAck);
 
    if (currentTxFrame == nullptr)
        throw cRuntimeError("Unexpected ACK received");
 
    EV_DEBUG << "AckingMac::acked(" << frame->getFullName() << ") is accepted\n";
    cancelEvent(ackTimeoutMsg);
    deleteCurrentTxFrame();
    if (transmissionState != IRadio::TRANSMISSION_STATE_TRANSMITTING && canDequeuePacket())
        processUpperPacket();
}

Referenced by handleLowerPacket().

configureNetworkInterface()

void inet::AckingMac::configureNetworkInterface ( )

overrideprotectedvirtual

implements MacBase functions

Implements inet::MacProtocolBase.

{
    MacAddress address = parseMacAddressParameter(par("address"));
 
    // data rate
    networkInterface->setDatarate(bitrate);
 
    // generate a link-layer address to be used as interface token for IPv6
    networkInterface->setMacAddress(address);
    networkInterface->setInterfaceToken(address.formInterfaceIdentifier());
 
    // MTU: typical values are 576 (Internet de facto), 1500 (Ethernet-friendly),
    // 4000 (on some point-to-point links), 4470 (Cisco routers default, FDDI compatible)
    networkInterface->setMtu(par("mtu"));
 
    // capabilities
    networkInterface->setMulticast(true);
    networkInterface->setBroadcast(true);
}

decapsulate()

void inet::AckingMac::decapsulate ( Packet *  frame )

protectedvirtual

{
    const auto& macHeader = packet->popAtFront<AckingMacHeader>();
    auto macAddressInd = packet->addTagIfAbsent<MacAddressInd>();
    macAddressInd->setSrcAddress(macHeader->getSrc());
    macAddressInd->setDestAddress(macHeader->getDest());
    packet->addTagIfAbsent<InterfaceInd>()->setInterfaceId(networkInterface->getInterfaceId());
    auto payloadProtocol = ProtocolGroup::ethertype.getProtocol(macHeader->getNetworkProtocol());
    packet->addTagIfAbsent<DispatchProtocolReq>()->setProtocol(payloadProtocol);
    packet->addTagIfAbsent<PacketProtocolTag>()->setProtocol(payloadProtocol);
}

dropFrameNotForUs()

bool inet::AckingMac::dropFrameNotForUs ( Packet *  frame )

protectedvirtual

{
    auto macHeader = packet->peekAtFront<AckingMacHeader>();
    // Current implementation does not support the configuration of multicast
    // MAC address groups. We rather accept all multicast frames (just like they were
    // broadcasts) and pass it up to the higher layer where they will be dropped
    // if not needed.
    // All frames must be passed to the upper layer if the interface is
    // in promiscuous mode.
 
    if (macHeader->getDest().equals(networkInterface->getMacAddress()))
        return false;
 
    if (macHeader->getDest().isBroadcast())
        return false;
 
    if (promiscuous || macHeader->getDest().isMulticast())
        return false;
 
    EV << "Frame '" << packet->getName() << "' not destined to us, discarding\n";
    PacketDropDetails details;
    details.setReason(NOT_ADDRESSED_TO_US);
    emit(packetDroppedSignal, packet, &details);
    delete packet;
    return true;
}

encapsulate()

void inet::AckingMac::encapsulate ( Packet *  msg )

protectedvirtual

{
    auto macHeader = makeShared<AckingMacHeader>();
    macHeader->setChunkLength(B(headerLength));
    auto macAddressReq = packet->getTag<MacAddressReq>();
    macHeader->setSrc(macAddressReq->getSrcAddress());
    macHeader->setDest(macAddressReq->getDestAddress());
    MacAddress dest = macAddressReq->getDestAddress();
    if (dest.isBroadcast() || dest.isMulticast() || dest.isUnspecified())
        macHeader->setSrcModuleId(-1);
    else
        macHeader->setSrcModuleId(getId());
    macHeader->setNetworkProtocol(ProtocolGroup::ethertype.getProtocolNumber(packet->getTag<PacketProtocolTag>()->getProtocol()));
    packet->insertAtFront(macHeader);
    auto macAddressInd = packet->addTagIfAbsent<MacAddressInd>();
    macAddressInd->setSrcAddress(macHeader->getSrc());
    macAddressInd->setDestAddress(macHeader->getDest());
    packet->getTagForUpdate<PacketProtocolTag>()->setProtocol(&Protocol::ackingMac);
}

getProvider()

queueing::IPassivePacketSource * inet::AckingMac::getProvider ( cGate *  gate )

overridevirtual

Returns the passive packet source from where packets are pulled or nullptr if the connected module doesn't implement the interface.

The gate parameter must be a valid gate of this module.

Implements inet::queueing::IActivePacketSink.

{
    return (gate->getId() == upperLayerInGateId) ? txQueue.get() : nullptr;
}

handleCanPullPacketChanged()

void inet::AckingMac::handleCanPullPacketChanged ( cGate *  gate )

overridevirtual

Notifies about a change in the possibility of pulling some packet from the passive packet source at the given gate.

This method is called, for example, when a new packet is inserted into a queue. It allows the sink to pull a new packet from the queue.

The gate parameter must be a valid gate of this module.

Implements inet::queueing::IActivePacketSink.

{
    Enter_Method("handleCanPullPacketChanged");
    if (currentTxFrame == nullptr    // not an active transmission
            && transmissionState != IRadio::TRANSMISSION_STATE_TRANSMITTING
            && canDequeuePacket()
            )
        processUpperPacket();
}

handleCrashOperation()

void inet::AckingMac::handleCrashOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Reimplemented from inet::MacProtocolBase.

{
    MacProtocolBase::handleCrashOperation(operation);
    if (useAck) {
        cancelEvent(ackTimeoutMsg);
    }
}

handleLowerPacket()

void inet::AckingMac::handleLowerPacket ( Packet *  packet )

overrideprotectedvirtual

Reimplemented from inet::LayeredProtocolBase.

{
    auto macHeader = packet->peekAtFront<AckingMacHeader>();
    if (packet->hasBitError()) {
        EV << "Received frame '" << packet->getName() << "' contains bit errors or collision, dropping it\n";
        PacketDropDetails details;
        details.setReason(INCORRECTLY_RECEIVED);
        emit(packetDroppedSignal, packet, &details);
        delete packet;
        return;
    }
 
    if (!dropFrameNotForUs(packet)) {
        // send Ack if needed
        auto dest = macHeader->getDest();
        bool needsAck = !(dest.isBroadcast() || dest.isMulticast() || dest.isUnspecified()); // same condition as in sender
        if (needsAck) {
            int senderModuleId = macHeader->getSrcModuleId();
            AckingMac *senderMac = check_and_cast<AckingMac *>(getSimulation()->getModule(senderModuleId));
            if (senderMac->useAck)
                senderMac->acked(packet);
        }
 
        // decapsulate and attach control info
        decapsulate(packet);
        EV << "Passing up contained packet '" << packet->getName() << "' to higher layer\n";
        sendUp(packet);
    }
}

handlePullPacketProcessed()

void inet::AckingMac::handlePullPacketProcessed ( Packet *  packet, cGate *  gate, bool  successful  )

overridevirtual

Notifies about the completion of the packet processing for a packet that was pulled earlier independently whether the packet is passed or streamed.

This method is called, for example, when a previously pulled packet is failed to be processed successfully. It allows the sink to retry the operation.

The gate parameter must be a valid gate of this module. The packet must not be nullptr.

Implements inet::queueing::IActivePacketSink.

{
    Enter_Method("handlePullPacketProcessed");
    throw cRuntimeError("Not supported callback");
}

handleSelfMessage()

void inet::AckingMac::handleSelfMessage ( cMessage *  message )

overrideprotectedvirtual

Reimplemented from inet::LayeredProtocolBase.

{
    if (message == ackTimeoutMsg) {
        EV_DETAIL << "AckingMac: timeout: " << currentTxFrame->getFullName() << " is lost\n";
        // packet lost
        emit(linkBrokenSignal, currentTxFrame);
        PacketDropDetails details;
        details.setReason(OTHER_PACKET_DROP);
        dropCurrentTxFrame(details);
        if (transmissionState != IRadio::TRANSMISSION_STATE_TRANSMITTING && canDequeuePacket())
            processUpperPacket();
    }
    else {
        MacProtocolBase::handleSelfMessage(message);
    }
}

handleStartOperation()

void inet::AckingMac::handleStartOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Reimplemented from inet::MacProtocolBase.

{
    if (transmissionState != IRadio::TRANSMISSION_STATE_TRANSMITTING && canDequeuePacket())
        processUpperPacket();
}

handleStopOperation()

void inet::AckingMac::handleStopOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Reimplemented from inet::MacProtocolBase.

{
    MacProtocolBase::handleStopOperation(operation);
    if (useAck) {
        cancelEvent(ackTimeoutMsg);
    }
}

handleUpperPacket()

void inet::AckingMac::handleUpperPacket ( Packet *  packet )

overrideprotectedvirtual

implements MacProtocolBase functions

Reimplemented from inet::LayeredProtocolBase.

{
    EV << "Received " << packet << " for transmission\n";
    if (currentTxFrame != nullptr || radio->getTransmissionState() == IRadio::TRANSMISSION_STATE_TRANSMITTING)
        throw cRuntimeError("AckingMac already in transmit state when packet arrived from upper layer");
    currentTxFrame = packet;
    startTransmitting();
}

initialize()

void inet::AckingMac::initialize ( int  stage )

overrideprotectedvirtual

Reimplemented from inet::MacProtocolBase.

{
    MacProtocolBase::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        bitrate = par("bitrate");
        headerLength = par("headerLength");
        promiscuous = par("promiscuous");
        fullDuplex = par("fullDuplex");
        useAck = par("useAck");
        ackTimeout = par("ackTimeout");
 
        cModule *radioModule = gate("lowerLayerOut")->getPathEndGate()->getOwnerModule();
        radioModule->subscribe(IRadio::transmissionStateChangedSignal, this);
        radio = check_and_cast<IRadio *>(radioModule);
        transmissionState = IRadio::TRANSMISSION_STATE_UNDEFINED;
 
        txQueue = getQueue(gate(upperLayerInGateId));
    }
    else if (stage == INITSTAGE_LINK_LAYER) {
        radio->setRadioMode(fullDuplex ? IRadio::RADIO_MODE_TRANSCEIVER : IRadio::RADIO_MODE_RECEIVER);
        transmissionState = radio->getTransmissionState();
        if (useAck)
            ackTimeoutMsg = new cMessage("link-break");
    }
}

numInitStages()

virtual int inet::AckingMac::numInitStages ( ) const

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

processUpperPacket()

void inet::AckingMac::processUpperPacket ( )

protectedvirtual

{
    auto packet = dequeuePacket();
    handleUpperPacket(packet);
 
}

receiveSignal()

void inet::AckingMac::receiveSignal ( cComponent *  src, simsignal_t  id, intval_t  value, cObject *  details  )

overrideprotectedvirtual

{
    Enter_Method("%s", cComponent::getSignalName(signalID));
 
    if (signalID == IRadio::transmissionStateChangedSignal) {
        IRadio::TransmissionState newRadioTransmissionState = static_cast<IRadio::TransmissionState>(value);
        if (transmissionState == IRadio::TRANSMISSION_STATE_TRANSMITTING && newRadioTransmissionState == IRadio::TRANSMISSION_STATE_IDLE) {
            radio->setRadioMode(fullDuplex ? IRadio::RADIO_MODE_TRANSCEIVER : IRadio::RADIO_MODE_RECEIVER);
            transmissionState = newRadioTransmissionState;
            if (currentTxFrame == nullptr && canDequeuePacket())
                processUpperPacket();
        }
        else
            transmissionState = newRadioTransmissionState;
    }
}

startTransmitting()

void inet::AckingMac::startTransmitting ( )

protectedvirtual

{
    // if there's any control info, remove it; then encapsulate the packet
    MacAddress dest = currentTxFrame->getTag<MacAddressReq>()->getDestAddress();
    Packet *msg = currentTxFrame;
    if (useAck && !dest.isBroadcast() && !dest.isMulticast() && !dest.isUnspecified()) { // unicast
        msg = currentTxFrame->dup();
        scheduleAfter(ackTimeout, ackTimeoutMsg);
    }
    else
        currentTxFrame = nullptr;
 
    encapsulate(msg);
 
    // send
    EV << "Starting transmission of " << msg << endl;
    radio->setRadioMode(fullDuplex ? IRadio::RADIO_MODE_TRANSCEIVER : IRadio::RADIO_MODE_TRANSMITTER);
    sendDown(msg);
}

Member Data Documentation

ackTimeout

simtime_t inet::AckingMac::ackTimeout

protected

ackTimeoutMsg

cMessage* inet::AckingMac::ackTimeoutMsg = nullptr

protected

bitrate

double inet::AckingMac::bitrate = 0

protected

fullDuplex

bool inet::AckingMac::fullDuplex = false

protected

headerLength

int inet::AckingMac::headerLength = 0

protected

promiscuous

bool inet::AckingMac::promiscuous = false

protected

radio

physicallayer::IRadio* inet::AckingMac::radio = nullptr

protected

transmissionState

physicallayer::IRadio::TransmissionState inet::AckingMac::transmissionState = physicallayer::IRadio::TRANSMISSION_STATE_UNDEFINED

protected

useAck

bool inet::AckingMac::useAck = true

protected

Referenced by handleLowerPacket().

---

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

• AckingMac.h
• AckingMac.cc