inet::NetworkProtocolBase Class Reference

#include <NetworkProtocolBase.h>

Inheritance diagram for inet::NetworkProtocolBase:

Classes
struct	SocketDescriptor

Public Member Functions
virtual void	handleRegisterService (const Protocol &protocol, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterProtocol (const Protocol &protocol, cGate *gate, ServicePrimitive servicePrimitive) override
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::DefaultProtocolRegistrationListener
virtual void	handleRegisterServiceGroup (const ProtocolGroup &protocolGroup, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterProtocolGroup (const ProtocolGroup &protocolGroup, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterAnyService (cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterAnyProtocol (cGate *gate, ServicePrimitive servicePrimitive) override

Protected Member Functions
	NetworkProtocolBase ()
virtual	~NetworkProtocolBase ()
virtual void	initialize (int stage) override
virtual void	sendUp (cMessage *message)
virtual void	sendDown (cMessage *message, int interfaceId=-1)
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	handleUpperCommand (cMessage *msg) override
virtual const Protocol &	getProtocol () const =0
Protected Member Functions inherited from inet::LayeredProtocolBase
virtual void	handleMessageWhenUp (cMessage *message) override
virtual void	handleSelfMessage (cMessage *message)
virtual void	handleUpperMessage (cMessage *message)
virtual void	handleLowerMessage (cMessage *message)
virtual void	handleLowerCommand (cMessage *message)
virtual void	handleUpperPacket (Packet *packet)
virtual void	handleLowerPacket (Packet *packet)
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 void	handleMessageWhenDown (cMessage *msg)
virtual bool	handleOperationStage (LifecycleOperation *operation, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual void	handleStartOperation (LifecycleOperation *operation)=0
virtual void	handleStopOperation (LifecycleOperation *operation)=0
virtual void	handleCrashOperation (LifecycleOperation *operation)=0
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
ModuleRefByPar< IInterfaceTable >	interfaceTable
std::set< const Protocol * >	upperProtocols
std::map< int, SocketDescriptor * >	socketIdToSocketDescriptor
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

Constructor & Destructor Documentation

NetworkProtocolBase()

inet::NetworkProtocolBase::NetworkProtocolBase ( )

protected

{
}

~NetworkProtocolBase()

virtual inet::NetworkProtocolBase::~NetworkProtocolBase ( )

inlineprotectedvirtual

{ for (auto entry : socketIdToSocketDescriptor) delete entry.second; }

Member Function Documentation

getProtocol()

virtual const Protocol& inet::NetworkProtocolBase::getProtocol ( ) const

protectedpure virtual

Implemented in inet::Flooding, inet::WiseRoute, and inet::ProbabilisticBroadcast.

Referenced by initialize(), and sendUp().

handleRegisterProtocol()

void inet::NetworkProtocolBase::handleRegisterProtocol ( const Protocol &  protocol, cGate *  gate, ServicePrimitive  servicePrimitive  )

overridevirtual

Reimplemented from inet::DefaultProtocolRegistrationListener.

{
    Enter_Method("handleRegisterProtocol");
    if (gate->isName("transportOut"))
        upperProtocols.insert(&protocol);
}

handleRegisterService()

void inet::NetworkProtocolBase::handleRegisterService ( const Protocol &  protocol, cGate *  gate, ServicePrimitive  servicePrimitive  )

overridevirtual

Reimplemented from inet::DefaultProtocolRegistrationListener.

{
    Enter_Method("handleRegisterService");
}

handleUpperCommand()

void inet::NetworkProtocolBase::handleUpperCommand ( cMessage *  msg )

overrideprotectedvirtual

Reimplemented from inet::LayeredProtocolBase.

{
    auto request = dynamic_cast<Request *>(msg);
    if (auto *command = dynamic_cast<L3SocketBindCommand *>(msg->getControlInfo())) {
        int socketId = request->getTag<SocketReq>()->getSocketId();
        SocketDescriptor *descriptor = new SocketDescriptor(socketId, command->getProtocol()->getId(), command->getLocalAddress());
        socketIdToSocketDescriptor[socketId] = descriptor;
        delete msg;
    }
    else if (auto *command = dynamic_cast<L3SocketConnectCommand *>(msg->getControlInfo())) {
        int socketId = request->getTag<SocketReq>()->getSocketId();
        if (!containsKey(socketIdToSocketDescriptor, socketId))
            throw cRuntimeError("Ipv4Socket: should use bind() before connect()");
        socketIdToSocketDescriptor[socketId]->remoteAddress = command->getRemoteAddress();
        delete msg;
    }
    else if (dynamic_cast<L3SocketCloseCommand *>(msg->getControlInfo()) != nullptr) {
        int socketId = request->getTag<SocketReq>()->getSocketId();
        auto it = socketIdToSocketDescriptor.find(socketId);
        if (it != socketIdToSocketDescriptor.end()) {
            delete it->second;
            socketIdToSocketDescriptor.erase(it);
            auto indication = new Indication("closed", L3_I_SOCKET_CLOSED);
            auto ctrl = new L3SocketClosedIndication();
            indication->setControlInfo(ctrl);
            indication->addTag<SocketInd>()->setSocketId(socketId);
            send(indication, "transportOut");
        }
        delete msg;
    }
    else
        LayeredProtocolBase::handleUpperCommand(msg);
}

initialize()

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

overrideprotectedvirtual

Reimplemented from inet::OperationalMixin< cSimpleModule >.

Reimplemented in inet::Flooding, inet::WiseRoute, inet::ProbabilisticBroadcast, and inet::AdaptiveProbabilisticBroadcast.

{
    LayeredProtocolBase::initialize(stage);
    if (stage == INITSTAGE_LOCAL)
        interfaceTable.reference(this, "interfaceTableModule", true);
    else if (stage == INITSTAGE_NETWORK_LAYER) {
        registerService(getProtocol(), gate("transportIn"), gate("transportOut"));
        registerProtocol(getProtocol(), gate("queueOut"), gate("queueIn"));
    }
}

Referenced by inet::ProbabilisticBroadcast::initialize(), and inet::Flooding::initialize().

isInitializeStage()

virtual bool inet::NetworkProtocolBase::isInitializeStage ( int  stage ) const

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ return stage == INITSTAGE_NETWORK_LAYER; }

isLowerMessage()

bool inet::NetworkProtocolBase::isLowerMessage ( cMessage *  message ) const

overrideprotectedvirtual

Implements inet::LayeredProtocolBase.

{
    return message->getArrivalGate()->isName("queueIn");
}

isModuleStartStage()

virtual bool inet::NetworkProtocolBase::isModuleStartStage ( int  stage ) const

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ return stage == ModuleStartOperation::STAGE_NETWORK_LAYER; }

isModuleStopStage()

virtual bool inet::NetworkProtocolBase::isModuleStopStage ( int  stage ) const

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ return stage == ModuleStopOperation::STAGE_NETWORK_LAYER; }

isUpperMessage()

bool inet::NetworkProtocolBase::isUpperMessage ( cMessage *  message ) const

overrideprotectedvirtual

Implements inet::LayeredProtocolBase.

{
    return message->getArrivalGate()->isName("transportIn");
}

sendDown()

void inet::NetworkProtocolBase::sendDown ( cMessage *  message, int  interfaceId = -1  )

protectedvirtual

{
    if (message->isPacket())
        emit(packetSentToLowerSignal, message);
    if (interfaceId != -1) {
        auto& tags = check_and_cast<ITaggedObject *>(message)->getTags();
        tags.addTagIfAbsent<InterfaceReq>()->setInterfaceId(interfaceId);
        auto networkInterface = interfaceTable->getInterfaceById(interfaceId);
        auto protocol = networkInterface->getProtocol();
        if (protocol != nullptr)
            tags.addTagIfAbsent<DispatchProtocolReq>()->setProtocol(protocol);
        else
            tags.removeTagIfPresent<DispatchProtocolReq>();
        send(message, "queueOut");
    }
    else {
        for (int i = 0; i < interfaceTable->getNumInterfaces(); i++) {
            NetworkInterface *networkInterface = interfaceTable->getInterface(i);
            if (networkInterface && !networkInterface->isLoopback()) {
                cMessage *duplicate = utils::dupPacketAndControlInfo(message);
                auto& tags = check_and_cast<ITaggedObject *>(duplicate)->getTags();
                tags.addTagIfAbsent<InterfaceReq>()->setInterfaceId(networkInterface->getInterfaceId());
                auto protocol = networkInterface->getProtocol();
                if (protocol != nullptr)
                    tags.addTagIfAbsent<DispatchProtocolReq>()->setProtocol(protocol);
                else
                    tags.removeTagIfPresent<DispatchProtocolReq>();
                send(duplicate, "queueOut");
            }
        }
        delete message;
    }
}

Referenced by inet::Flooding::handleLowerPacket(), inet::ProbabilisticBroadcast::handleSelfMessage(), and inet::Flooding::handleUpperPacket().

sendUp()

void inet::NetworkProtocolBase::sendUp ( cMessage *  message )

protectedvirtual

{
    if (Packet *packet = dynamic_cast<Packet *>(message)) {
        const Protocol *protocol = packet->getTag<PacketProtocolTag>()->getProtocol();
        const auto& addr = packet->getTag<L3AddressInd>();
        auto remoteAddress(addr->getSrcAddress());
        auto localAddress(addr->getDestAddress());
        bool hasSocket = false;
        for (const auto& elem : socketIdToSocketDescriptor) {
            if (elem.second->protocolId == protocol->getId() &&
                (elem.second->localAddress.isUnspecified() || elem.second->localAddress == localAddress) &&
                (elem.second->remoteAddress.isUnspecified() || elem.second->remoteAddress == remoteAddress))
            {
                auto *packetCopy = packet->dup();
                packetCopy->setKind(L3_I_DATA);
                packetCopy->addTagIfAbsent<SocketInd>()->setSocketId(elem.second->socketId);
                EV_INFO << "Passing up to socket " << elem.second->socketId << "\n";
                emit(packetSentToUpperSignal, packetCopy);
                send(packetCopy, "transportOut");
                hasSocket = true;
            }
        }
        if (contains(upperProtocols, protocol)) {
            EV_INFO << "Passing up to protocol " << protocol->getName() << "\n";
            emit(packetSentToUpperSignal, packet);
            send(packet, "transportOut");
        }
        else {
            if (!hasSocket) {
                EV_ERROR << "Transport protocol '" << protocol->getName() << "' not connected, discarding packet\n";
                // TODO send an ICMP error: protocol unreachable
//                sendToIcmp(datagram, inputInterfaceId, ICMP_DESTINATION_UNREACHABLE, ICMP_DU_PROTOCOL_UNREACHABLE);
            }
            delete packet;
        }
    }
    else
        send(message, "transportOut");
}

Referenced by inet::ProbabilisticBroadcast::handleLowerPacket(), and inet::Flooding::handleLowerPacket().

Member Data Documentation

interfaceTable

ModuleRefByPar<IInterfaceTable> inet::NetworkProtocolBase::interfaceTable

protected

Referenced by inet::Flooding::handleLowerPacket(), initialize(), inet::ProbabilisticBroadcast::initialize(), inet::Flooding::initialize(), and sendDown().

socketIdToSocketDescriptor

std::map<int, SocketDescriptor *> inet::NetworkProtocolBase::socketIdToSocketDescriptor

protected

Referenced by handleUpperCommand(), and sendUp().

upperProtocols

std::set<const Protocol *> inet::NetworkProtocolBase::upperProtocols

protected

Referenced by handleRegisterProtocol(), and sendUp().

---

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

• NetworkProtocolBase.h
• NetworkProtocolBase.cc