inet::NextHopForwarding Class Reference

Implements a next hop forwarding protocol that routes datagrams through the network. More...

#include <NextHopForwarding.h>

Inheritance diagram for inet::NextHopForwarding:

Classes
struct	QueuedDatagramForHook
	Represents an NextHopDatagram, queued by a Hook. More...
struct	SocketDescriptor

Public Member Functions
	NextHopForwarding ()
	~NextHopForwarding ()
virtual void	handleRegisterService (const Protocol &protocol, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterProtocol (const Protocol &protocol, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	registerHook (int priority, IHook *hook) override
	Adds the provided hook to the list of registered hooks that will be called by the network layer when it processes datagrams. More...
virtual void	unregisterHook (IHook *hook) override
	Removes the provided hook from the list of registered hooks. More...
virtual void	dropQueuedDatagram (const Packet *datagram) override
	Requests the network layer to drop the datagram, because it's no longer needed. More...
virtual void	reinjectQueuedDatagram (const Packet *datagram) override
	Requests the network layer to restart the processing of the datagram. 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::NetfilterBase
virtual	~NetfilterBase ()
Public Member Functions inherited from inet::INetfilter
virtual	~INetfilter ()
Public Member Functions inherited from inet::INetworkProtocol
virtual	~INetworkProtocol ()
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 Types
typedef std::list< QueuedDatagramForHook >	DatagramQueueForHooks
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State

Protected Member Functions
virtual const NetworkInterface *	getSourceInterfaceFrom (Packet *packet)
virtual void	refreshDisplay () const override
virtual void	handlePacketFromNetwork (Packet *datagram)
	Handle NextHopDatagram messages arriving from lower layer. More...
virtual void	handlePacketFromHL (Packet *packet)
	Handle packets from transport or ICMP. More...
virtual void	routePacket (Packet *datagram, const NetworkInterface *destIE, const L3Address &nextHop, bool fromHL)
	Performs routing. More...
virtual void	routeMulticastPacket (Packet *datagram, const NetworkInterface *destIE, const NetworkInterface *fromIE)
	Forwards packets to all multicast destinations, using sendDatagramToOutput(). More...
virtual void	encapsulate (Packet *transportPacket, const NetworkInterface *&destIE)
	Encapsulate packet coming from higher layers into NextHopDatagram, using the control info attached to the packet. More...
virtual void	decapsulate (Packet *datagram)
	Decapsulate and return encapsulated packet. More...
virtual void	sendDatagramToHL (Packet *datagram)
	Send datagrams up to the higher layers. More...
virtual void	sendDatagramToOutput (Packet *datagram, const NetworkInterface *ie, L3Address nextHop)
	Last TTL check, then send datagram on the given interface. More...
virtual void	datagramPreRouting (Packet *datagram, const NetworkInterface *inIE, const NetworkInterface *destIE, const L3Address &nextHop)
virtual void	datagramLocalIn (Packet *datagram, const NetworkInterface *inIE)
virtual void	datagramLocalOut (Packet *datagram, const NetworkInterface *destIE, const L3Address &nextHop)
virtual IHook::Result	datagramPreRoutingHook (Packet *datagram)
virtual IHook::Result	datagramForwardHook (Packet *datagram)
virtual IHook::Result	datagramPostRoutingHook (Packet *datagram)
virtual IHook::Result	datagramLocalInHook (Packet *datagram)
virtual IHook::Result	datagramLocalOutHook (Packet *datagram)
virtual void	initialize (int stage) override
	Initialization. More...
virtual void	handleMessageWhenUp (cMessage *msg) override
void	handleCommand (Request *msg)
virtual bool	isInitializeStage (int stage) const override
	ILifecycle method. More...
virtual bool	isModuleStartStage (int stage) const override
virtual bool	isModuleStopStage (int stage) const override
virtual void	handleStartOperation (LifecycleOperation *operation) override
virtual void	handleStopOperation (LifecycleOperation *operation) override
virtual void	handleCrashOperation (LifecycleOperation *operation) override
virtual void	stop ()
virtual void	start ()
virtual void	flush ()
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 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
ModuleRefByPar< NextHopRoutingTable >	routingTable
ModuleRefByPar< IArp >	arp
int	defaultHopLimit
std::set< const Protocol * >	upperProtocols
std::map< int, SocketDescriptor * >	socketIdToSocketDescriptor
DatagramQueueForHooks	queuedDatagramsForHooks
int	numLocalDeliver
int	numDropped
int	numUnroutable
int	numForwarded
Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState
simtime_t	lastChange
Operation	activeOperation
cMessage *	activeOperationTimeout
cMessage *	activeOperationExtraTimer
Protected Attributes inherited from inet::NetfilterBase
std::multimap< int, IHook * >	hooks

Detailed Description

Implements a next hop forwarding protocol that routes datagrams through the network.

Routing decisions are based on a next hop routing table, but it also supports the netfilter interface to allow routing protocols to kick in. It doesn't provide datagram fragmentation and reassembling.

Member Typedef Documentation

DatagramQueueForHooks

typedef std::list<QueuedDatagramForHook> inet::NextHopForwarding::DatagramQueueForHooks

protected

Constructor & Destructor Documentation

NextHopForwarding()

inet::NextHopForwarding::NextHopForwarding

(

)

                                     :
    defaultHopLimit(-1),
    numLocalDeliver(0),
    numDropped(0),
    numUnroutable(0),
    numForwarded(0)
{
}

~NextHopForwarding()

inet::NextHopForwarding::~NextHopForwarding

(

)

{
    for (auto it : socketIdToSocketDescriptor)
        delete it.second;
    for (auto& elem : queuedDatagramsForHooks) {
        delete elem.datagram;
    }
    queuedDatagramsForHooks.clear();
}

Member Function Documentation

datagramForwardHook()

INetfilter::IHook::Result inet::NextHopForwarding::datagramForwardHook ( Packet *  datagram )

protectedvirtual

{
    for (auto& elem : hooks) {
        IHook::Result r = elem.second->datagramForwardHook(datagram);
        switch (r) {
            case IHook::ACCEPT:
                break; // continue iteration
 
            case IHook::DROP:
                delete datagram;
                return r;
 
            case IHook::QUEUE:
                queuedDatagramsForHooks.push_back(QueuedDatagramForHook(datagram, INetfilter::IHook::FORWARD));
                return r;
 
            case IHook::STOLEN:
                return r;
 
            default:
                throw cRuntimeError("Unknown Hook::Result value: %d", (int)r);
        }
    }
    return IHook::ACCEPT;
}

datagramLocalIn()

void inet::NextHopForwarding::datagramLocalIn ( Packet *  datagram, const NetworkInterface *  inIE  )

protectedvirtual

{
    sendDatagramToHL(packet);
}

Referenced by reinjectQueuedDatagram().

datagramLocalInHook()

INetfilter::IHook::Result inet::NextHopForwarding::datagramLocalInHook ( Packet *  datagram )

protectedvirtual

{
    L3Address address;
    for (auto& elem : hooks) {
        IHook::Result r = elem.second->datagramLocalInHook(datagram);
        switch (r) {
            case IHook::ACCEPT:
                break; // continue iteration
 
            case IHook::DROP:
                delete datagram;
                return r;
 
            case IHook::QUEUE:
                queuedDatagramsForHooks.push_back(QueuedDatagramForHook(datagram, INetfilter::IHook::LOCALIN));
                return r;
 
            case IHook::STOLEN:
                return r;
 
            default:
                throw cRuntimeError("Unknown Hook::Result value: %d", (int)r);
        }
    }
    return IHook::ACCEPT;
}

Referenced by routePacket().

datagramLocalOut()

void inet::NextHopForwarding::datagramLocalOut ( Packet *  datagram, const NetworkInterface *  destIE, const L3Address &  nextHop  )

protectedvirtual

{
    const auto& header = datagram->peekAtFront<NextHopForwardingHeader>();
    // route packet
    if (!header->getDestinationAddress().isMulticast())
        routePacket(datagram, destIE, nextHop, true);
    else
        routeMulticastPacket(datagram, destIE, nullptr);
}

Referenced by handlePacketFromHL(), and reinjectQueuedDatagram().

datagramLocalOutHook()

INetfilter::IHook::Result inet::NextHopForwarding::datagramLocalOutHook ( Packet *  datagram )

protectedvirtual

{
    for (auto& elem : hooks) {
        IHook::Result r = elem.second->datagramLocalOutHook(datagram);
        switch (r) {
            case IHook::ACCEPT:
                break; // continue iteration
 
            case IHook::DROP:
                delete datagram;
                return r;
 
            case IHook::QUEUE:
                queuedDatagramsForHooks.push_back(QueuedDatagramForHook(datagram, INetfilter::IHook::LOCALOUT));
                return r;
 
            case IHook::STOLEN:
                return r;
 
            default:
                throw cRuntimeError("Unknown Hook::Result value: %d", (int)r);
        }
    }
    return IHook::ACCEPT;
}

Referenced by handlePacketFromHL().

datagramPostRoutingHook()

INetfilter::IHook::Result inet::NextHopForwarding::datagramPostRoutingHook ( Packet *  datagram )

protectedvirtual

{
    for (auto& elem : hooks) {
        IHook::Result r = elem.second->datagramPostRoutingHook(datagram);
        switch (r) {
            case IHook::ACCEPT:
                break; // continue iteration
 
            case IHook::DROP:
                delete datagram;
                return r;
 
            case IHook::QUEUE:
                queuedDatagramsForHooks.push_back(QueuedDatagramForHook(datagram, INetfilter::IHook::POSTROUTING));
                return r;
 
            case IHook::STOLEN:
                return r;
 
            default:
                throw cRuntimeError("Unknown Hook::Result value: %d", (int)r);
        }
    }
    return IHook::ACCEPT;
}

datagramPreRouting()

void inet::NextHopForwarding::datagramPreRouting ( Packet *  datagram, const NetworkInterface *  inIE, const NetworkInterface *  destIE, const L3Address &  nextHop  )

protectedvirtual

{
    const auto& header = datagram->peekAtFront<NextHopForwardingHeader>();
    // route packet
    if (!header->getDestinationAddress().isMulticast())
        routePacket(datagram, destIE, nextHop, false);
    else
        routeMulticastPacket(datagram, destIE, inIE);
}

Referenced by handlePacketFromNetwork(), and reinjectQueuedDatagram().

datagramPreRoutingHook()

INetfilter::IHook::Result inet::NextHopForwarding::datagramPreRoutingHook ( Packet *  datagram )

protectedvirtual

{
    for (auto& elem : hooks) {
        IHook::Result r = elem.second->datagramPreRoutingHook(datagram);
        switch (r) {
            case IHook::ACCEPT:
                break; // continue iteration
 
            case IHook::DROP:
                delete datagram;
                return r;
 
            case IHook::QUEUE:
                if (datagram->getOwner() != this)
                    throw cRuntimeError("Model error: netfilter hook changed the owner of queued datagram '%s'", datagram->getFullName());
                queuedDatagramsForHooks.push_back(QueuedDatagramForHook(datagram, INetfilter::IHook::PREROUTING));
                return r;
 
            case IHook::STOLEN:
                return r;
 
            default:
                throw cRuntimeError("Unknown Hook::Result value: %d", (int)r);
        }
    }
    return IHook::ACCEPT;
}

Referenced by handlePacketFromNetwork().

decapsulate()

void inet::NextHopForwarding::decapsulate ( Packet *  datagram )

protectedvirtual

Decapsulate and return encapsulated packet.

{
    // decapsulate transport packet
    const NetworkInterface *fromIE = getSourceInterfaceFrom(packet);
    const auto& header = packet->popAtFront<NextHopForwardingHeader>();
 
    // create and fill in control info
    if (fromIE) {
        auto ifTag = packet->addTagIfAbsent<InterfaceInd>();
        ifTag->setInterfaceId(fromIE->getInterfaceId());
    }
 
    ASSERT(header->getPayloadLengthField() <= packet->getDataLength());
    // drop padding
    packet->setBackOffset(packet->getFrontOffset() + header->getPayloadLengthField());
 
    // attach control info
    auto payloadProtocol = header->getProtocol();
    packet->addTagIfAbsent<PacketProtocolTag>()->setProtocol(payloadProtocol);
    packet->addTagIfAbsent<DispatchProtocolReq>()->setProtocol(payloadProtocol);
    auto networkProtocolInd = packet->addTagIfAbsent<NetworkProtocolInd>();
    networkProtocolInd->setProtocol(&Protocol::nextHopForwarding);
    networkProtocolInd->setNetworkProtocolHeader(header);
    auto l3AddressInd = packet->addTagIfAbsent<L3AddressInd>();
    l3AddressInd->setSrcAddress(header->getSourceAddress());
    l3AddressInd->setDestAddress(header->getDestinationAddress());
    packet->addTagIfAbsent<HopLimitInd>()->setHopLimit(header->getHopLimit());
}

Referenced by sendDatagramToHL().

dropQueuedDatagram()

void inet::NextHopForwarding::dropQueuedDatagram ( const Packet *  daragram )

overridevirtual

Requests the network layer to drop the datagram, because it's no longer needed.

This function may be used by a reactive routing protocol when it cancels the route discovery process.

Implements inet::INetfilter.

{
    Enter_Method("dropDatagram()");
    for (auto iter = queuedDatagramsForHooks.begin(); iter != queuedDatagramsForHooks.end(); iter++) {
        if (iter->datagram == datagram) {
            delete datagram;
            queuedDatagramsForHooks.erase(iter);
            return;
        }
    }
}

encapsulate()

void inet::NextHopForwarding::encapsulate ( Packet *  transportPacket, const NetworkInterface *&  destIE  )

protectedvirtual

Encapsulate packet coming from higher layers into NextHopDatagram, using the control info attached to the packet.

{
    auto header = makeShared<NextHopForwardingHeader>();
    header->setChunkLength(B(par("headerLength")));
    auto& l3AddressReq = transportPacket->removeTag<L3AddressReq>();
    L3Address src = l3AddressReq->getSrcAddress();
    L3Address dest = l3AddressReq->getDestAddress();
 
    header->setProtocol(transportPacket->getTag<PacketProtocolTag>()->getProtocol());
 
    auto& hopLimitReq = transportPacket->removeTagIfPresent<HopLimitReq>();
    short ttl = (hopLimitReq != nullptr) ? hopLimitReq->getHopLimit() : -1;
 
    // set source and destination address
    header->setDestinationAddress(dest);
 
    // multicast interface option, but allow interface selection for unicast packets as well
    const auto& ifTag = transportPacket->findTag<InterfaceReq>();
    destIE = ifTag ? interfaceTable->getInterfaceById(ifTag->getInterfaceId()) : nullptr;
 
    // when source address was given, use it; otherwise it'll get the address
    // of the outgoing interface after routing
    if (!src.isUnspecified()) {
        // if interface parameter does not match existing interface, do not send datagram
        if (routingTable->getInterfaceByAddress(src) == nullptr)
            throw cRuntimeError("Wrong source address %s in (%s)%s: no interface with such address",
                    src.str().c_str(), transportPacket->getClassName(), transportPacket->getFullName());
        header->setSourceAddress(src);
    }
 
    // set other fields
    if (ttl != -1) {
        ASSERT(ttl > 0);
    }
    else if (false) // TODO datagram->getDestinationAddress().isLinkLocalMulticast())
        ttl = 1;
    else
        ttl = defaultHopLimit;
 
    header->setHopLimit(ttl);
 
    // setting NextHopForwarding options is currently not supported
 
    delete transportPacket->removeControlInfo();
    header->setPayloadLengthField(transportPacket->getDataLength());
 
    insertNetworkProtocolHeader(transportPacket, Protocol::nextHopForwarding, header);
}

Referenced by handlePacketFromHL().

flush()

void inet::NextHopForwarding::flush ( )

protectedvirtual

{
    EV_DEBUG << "NextHopForwarding::flush(): packets in hooks: " << queuedDatagramsForHooks.size() << endl;
    for (auto& elem : queuedDatagramsForHooks) {
        delete elem.datagram;
    }
    queuedDatagramsForHooks.clear();
 
// fragbuf.flush();
}

Referenced by stop().

getSourceInterfaceFrom()

const NetworkInterface * inet::NextHopForwarding::getSourceInterfaceFrom ( Packet *  packet )

protectedvirtual

{
    const auto& interfaceInd = packet->findTag<InterfaceInd>();
    return interfaceInd != nullptr ? interfaceTable->getInterfaceById(interfaceInd->getInterfaceId()) : nullptr;
}

Referenced by decapsulate().

handleCommand()

void inet::NextHopForwarding::handleCommand ( Request *  msg )

protected

{
    if (auto *command = dynamic_cast<L3SocketBindCommand *>(request->getControlInfo())) {
        int socketId = request->getTag<SocketReq>()->getSocketId();
        SocketDescriptor *descriptor = new SocketDescriptor(socketId, command->getProtocol()->getId(), command->getLocalAddress());
        socketIdToSocketDescriptor[socketId] = descriptor;
        delete request;
    }
    else if (auto *command = dynamic_cast<L3SocketConnectCommand *>(request->getControlInfo())) {
        int socketId = request->getTag<SocketReq>()->getSocketId();
        if (!containsKey(socketIdToSocketDescriptor, socketId))
            throw cRuntimeError("L3Socket: should use bind() before connect()");
        socketIdToSocketDescriptor[socketId]->remoteAddress = command->getRemoteAddress();
        delete request;
    }
    else if (dynamic_cast<L3SocketCloseCommand *>(request->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 request;
    }
    else if (dynamic_cast<L3SocketDestroyCommand *>(request->getControlInfo()) != nullptr) {
        int socketId = request->getTag<SocketReq>()->getSocketId();
        auto it = socketIdToSocketDescriptor.find(socketId);
        if (it != socketIdToSocketDescriptor.end()) {
            delete it->second;
            socketIdToSocketDescriptor.erase(it);
        }
        delete request;
    }
    else
        throw cRuntimeError("Invalid command: (%s)%s", request->getClassName(), request->getName());
}

Referenced by handleMessageWhenUp().

handleCrashOperation()

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

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    stop();
}

handleMessageWhenUp()

void inet::NextHopForwarding::handleMessageWhenUp ( cMessage *  msg )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    if (msg->arrivedOn("transportIn")) { // TODO packet->getArrivalGate()->getBaseId() == transportInGateBaseId
        if (auto request = dynamic_cast<Request *>(msg))
            handleCommand(request);
        else
            handlePacketFromHL(check_and_cast<Packet *>(msg));
    }
    else if (msg->arrivedOn("queueIn")) { // from network
        EV_INFO << "Received " << msg << " from network.\n";
        handlePacketFromNetwork(check_and_cast<Packet *>(msg));
    }
    else
        throw cRuntimeError("message arrived on unknown gate '%s'", msg->getArrivalGate()->getName());
}

handlePacketFromHL()

void inet::NextHopForwarding::handlePacketFromHL ( Packet *  packet )

protectedvirtual

Handle packets from transport or ICMP.

Invokes encapsulate(), then routePacket().

{
    // if no interface exists, do not send datagram
    if (interfaceTable->getNumInterfaces() == 0) {
        EV_INFO << "No interfaces exist, dropping packet\n";
        PacketDropDetails details;
        details.setReason(NO_INTERFACE_FOUND);
        emit(packetDroppedSignal, packet, &details);
        delete packet;
        return;
    }
 
    // encapsulate and send
    const NetworkInterface *destIE; // will be filled in by encapsulate()
    encapsulate(packet, destIE);
 
    L3Address nextHop;
    if (datagramLocalOutHook(packet) != IHook::ACCEPT)
        return;
 
    const auto& destIeTag = packet->findTag<InterfaceReq>();
    destIE = destIeTag ? interfaceTable->getInterfaceById(destIeTag->getInterfaceId()) : nullptr;
    const auto& nextHopTag = packet->findTag<NextHopAddressReq>();
    nextHop = (nextHopTag) ? nextHopTag->getNextHopAddress() : L3Address();
 
    datagramLocalOut(packet, destIE, nextHop);
}

Referenced by handleMessageWhenUp().

handlePacketFromNetwork()

void inet::NextHopForwarding::handlePacketFromNetwork ( Packet *  datagram )

protectedvirtual

Handle NextHopDatagram messages arriving from lower layer.

Decrements TTL, then invokes routePacket().

{
    if (packet->hasBitError()) {
        // TODO emit packetDropped signal
        EV_WARN << "CRC error found, drop packet\n";
        PacketDropDetails details;
        details.setReason(INCORRECTLY_RECEIVED);
        emit(packetDroppedSignal, packet, &details);
        delete packet;
        return;
    }
 
    const auto& header = packet->peekAtFront<NextHopForwardingHeader>();
    packet->addTagIfAbsent<NetworkProtocolInd>()->setProtocol(&Protocol::nextHopForwarding);
    packet->addTagIfAbsent<NetworkProtocolInd>()->setNetworkProtocolHeader(header);
    B totalLength = header->getChunkLength() + header->getPayloadLengthField();
    if (totalLength > packet->getDataLength()) {
        EV_WARN << "length error found, drop packet\n";
        PacketDropDetails details;
        details.setReason(INCORRECTLY_RECEIVED);
        emit(packetDroppedSignal, packet, &details);
        delete packet;
        return;
    }
 
    // remove lower layer paddings:
    if (totalLength < packet->getDataLength()) {
        packet->setBackOffset(packet->getFrontOffset() + totalLength);
    }
 
    const NetworkInterface *inIE = interfaceTable->getInterfaceById(packet->getTag<InterfaceInd>()->getInterfaceId());
    const NetworkInterface *destIE = nullptr;
 
    EV_DETAIL << "Received datagram `" << packet->getName() << "' with dest=" << header->getDestAddr() << " from " << header->getSrcAddr() << " in interface" << inIE->getInterfaceName() << "\n";
 
    if (datagramPreRoutingHook(packet) != IHook::ACCEPT)
        return;
 
    inIE = interfaceTable->getInterfaceById(packet->getTag<InterfaceInd>()->getInterfaceId());
    const auto& destIeTag = packet->findTag<InterfaceReq>();
    destIE = destIeTag ? interfaceTable->getInterfaceById(destIeTag->getInterfaceId()) : nullptr;
    const auto& nextHopTag = packet->findTag<NextHopAddressReq>();
    L3Address nextHop = (nextHopTag) ? nextHopTag->getNextHopAddress() : L3Address();
    datagramPreRouting(packet, inIE, destIE, nextHop);
}

Referenced by handleMessageWhenUp().

handleRegisterProtocol()

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

overridevirtual

Reimplemented from inet::DefaultProtocolRegistrationListener.

{
    Enter_Method("handleRegisterProtocol");
    if (!strcmp("transportOut", gate->getBaseName()))
        upperProtocols.insert(&protocol);
}

handleRegisterService()

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

overridevirtual

Reimplemented from inet::DefaultProtocolRegistrationListener.

{
    Enter_Method("handleRegisterService");
}

handleStartOperation()

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

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    start();
}

handleStopOperation()

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

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    stop();
}

initialize()

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

overrideprotectedvirtual

Initialization.

Reimplemented from inet::OperationalMixin< cSimpleModule >.

{
    OperationalBase::initialize(stage);
 
    if (stage == INITSTAGE_LOCAL) {
        interfaceTable.reference(this, "interfaceTableModule", true);
        routingTable.reference(this, "routingTableModule", true);
        arp.reference(this, "arpModule", true);
 
        defaultHopLimit = par("hopLimit");
        numLocalDeliver = numDropped = numUnroutable = numForwarded = 0;
 
        WATCH(numLocalDeliver);
        WATCH(numDropped);
        WATCH(numUnroutable);
        WATCH(numForwarded);
    }
    else if (stage == INITSTAGE_NETWORK_LAYER) {
        registerService(Protocol::nextHopForwarding, gate("transportIn"), gate("transportOut"));
        registerProtocol(Protocol::nextHopForwarding, gate("queueOut"), gate("queueIn"));
    }
}

isInitializeStage()

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

inlineoverrideprotectedvirtual

ILifecycle method.

Implements inet::OperationalMixin< cSimpleModule >.

{ return stage == INITSTAGE_NETWORK_LAYER; }

isModuleStartStage()

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

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ return stage == ModuleStartOperation::STAGE_NETWORK_LAYER; }

isModuleStopStage()

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

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ return stage == ModuleStopOperation::STAGE_NETWORK_LAYER; }

refreshDisplay()

void inet::NextHopForwarding::refreshDisplay ( ) const

overrideprotectedvirtual

{
    OperationalBase::refreshDisplay();
 
    char buf[80] = "";
    if (numForwarded > 0)
        sprintf(buf + strlen(buf), "fwd:%d ", numForwarded);
    if (numLocalDeliver > 0)
        sprintf(buf + strlen(buf), "up:%d ", numLocalDeliver);
    if (numDropped > 0)
        sprintf(buf + strlen(buf), "DROP:%d ", numDropped);
    if (numUnroutable > 0)
        sprintf(buf + strlen(buf), "UNROUTABLE:%d ", numUnroutable);
    getDisplayString().setTagArg("t", 0, buf);
}

registerHook()

void inet::NextHopForwarding::registerHook ( int  priority, IHook *  hook  )

overridevirtual

Adds the provided hook to the list of registered hooks that will be called by the network layer when it processes datagrams.

Reimplemented from inet::NetfilterBase.

{
    Enter_Method("registerHook()");
    NetfilterBase::registerHook(priority, hook);
}

reinjectQueuedDatagram()

void inet::NextHopForwarding::reinjectQueuedDatagram ( const Packet *  datagram )

overridevirtual

Requests the network layer to restart the processing of the datagram.

This function may be used by a reactive routing protocol when it completes the route discovery process.

Implements inet::INetfilter.

{
    Enter_Method("reinjectDatagram()");
    for (auto iter = queuedDatagramsForHooks.begin(); iter != queuedDatagramsForHooks.end(); iter++) {
        if (iter->datagram == datagram) {
            Packet *datagram = iter->datagram;
            const NetworkInterface *inIE = iter->inIE;
            const NetworkInterface *outIE = iter->outIE;
            const L3Address& nextHop = iter->nextHop;
            INetfilter::IHook::Type hookType = iter->hookType;
            switch (hookType) {
                case INetfilter::IHook::PREROUTING:
                    datagramPreRouting(datagram, inIE, outIE, nextHop);
                    break;
 
                case INetfilter::IHook::LOCALIN:
                    datagramLocalIn(datagram, inIE);
                    break;
 
                case INetfilter::IHook::LOCALOUT:
                    datagramLocalOut(datagram, outIE, nextHop);
                    break;
 
                default:
                    throw cRuntimeError("Re-injection of datagram queued for this hook not implemented");
                    break;
            }
            queuedDatagramsForHooks.erase(iter);
            return;
        }
    }
}

routeMulticastPacket()

void inet::NextHopForwarding::routeMulticastPacket ( Packet *  datagram, const NetworkInterface *  destIE, const NetworkInterface *  fromIE  )

protectedvirtual

Forwards packets to all multicast destinations, using sendDatagramToOutput().

{
    const auto& header = datagram->peekAtFront<NextHopForwardingHeader>();
    L3Address destAddr = header->getDestinationAddress();
    // if received from the network...
    if (fromIE != nullptr) {
        //TODO decrement hopLimit before forward frame to another host
 
        // check for local delivery
        if (routingTable->isLocalMulticastAddress(destAddr))
            sendDatagramToHL(datagram);
//
//        // don't forward if NextHopForwarding forwarding is off
//        if (!rt->isForwardingEnabled())
//        {
//            delete datagram;
//            return;
//        }
//
//        // don't forward if dest address is link-scope
//        if (destAddr.isLinkLocalMulticast())
//        {
//            delete datagram;
//            return;
//        }
    }
    else {
        //TODO
        for (int i = 0; i < interfaceTable->getNumInterfaces(); ++i) {
            const NetworkInterface *destIE = interfaceTable->getInterface(i);
            if (!destIE->isLoopback())
                sendDatagramToOutput(datagram->dup(), destIE, header->getDestinationAddress());
        }
        delete datagram;
    }
 
//    Address destAddr = datagram->getDestinationAddress();
//    EV << "Routing multicast datagram `" << datagram->getName() << "' with dest=" << destAddr << "\n";
//
//    numMulticast++;
//
//    // DVMRP: process datagram only if sent locally or arrived on the shortest
//    // route (provided routing table already contains srcAddr); otherwise
//    // discard and continue.
//    const NetworkInterface *shortestPathIE = rt->getInterfaceForDestinationAddr(datagram->getSourceAddress());
//    if (fromIE!=nullptr && shortestPathIE!=nullptr && fromIE!=shortestPathIE)
//    {
//        // FIXME count dropped
//        EV << "Packet dropped.\n";
//        delete datagram;
//        return;
//    }
//
//    // if received from the network...
//    if (fromIE!=nullptr)
//    {
//        // check for local delivery
//        if (rt->isLocalMulticastAddress(destAddr))
//        {
//            NextHopDatagram *datagramCopy = datagram->dup();
//
//            // FIXME code from the MPLS model: set packet dest address to routerId (???)
//            datagramCopy->setDestinationAddress(rt->getRouterId());
//
//            reassembleAndDeliver(datagramCopy);
//        }
//
//        // don't forward if NextHopForwarding forwarding is off
//        if (!rt->isForwardingEnabled())
//        {
//            delete datagram;
//            return;
//        }
//
//        // don't forward if dest address is link-scope
//        if (destAddr.isLinkLocalMulticast())
//        {
//            delete datagram;
//            return;
//        }
//
//    }
//
//    // routed explicitly via multicast interface
//    if (destIE!=nullptr)
//    {
//        ASSERT(datagram->getDestinationAddress().isMulticast());
//
//        EV << "multicast packet explicitly routed via output interface " << destIE->getName() << endl;
//
//        // set datagram source address if not yet set
//        if (datagram->getSourceAddress().isUnspecified())
//            datagram->setSourceAddress(destIE->getProtocolData<Ipv4InterfaceData>()->getGenericAddress());
//
//        // send
//        sendDatagramToOutput(datagram, destIE, datagram->getDestinationAddress());
//
//        return;
//    }
//
//    // now: routing
//    MulticastRoutes routes = rt->getMulticastRoutesFor(destAddr);
//    if (routes.size()==0)
//    {
//        // no destination: delete datagram
//        delete datagram;
//    }
//    else
//    {
//        // copy original datagram for multiple destinations
//        for (unsigned int i=0; i<routes.size(); i++)
//        {
//            const NetworkInterface *destIE = routes[i].interf;
//
//            // don't forward to input port
//            if (destIE && destIE!=fromIE)
//            {
//                NextHopDatagram *datagramCopy = datagram->dup();
//
//                // set datagram source address if not yet set
//                if (datagramCopy->getSourceAddress().isUnspecified())
//                    datagramCopy->setSourceAddress(destIE->getProtocolData<Ipv4InterfaceData>()->getGenericAddress());
//
//                // send
//                Address nextHop = routes[i].gateway;
//                sendDatagramToOutput(datagramCopy, destIE, nextHop);
//            }
//        }
//
//        // only copies sent, delete original datagram
//        delete datagram;
//    }
}

Referenced by datagramLocalOut(), and datagramPreRouting().

routePacket()

void inet::NextHopForwarding::routePacket ( Packet *  datagram, const NetworkInterface *  destIE, const L3Address &  nextHop, bool  fromHL  )

protectedvirtual

Performs routing.

Based on the routing decision, it dispatches to sendDatagramToHL() for local packets, to sendDatagramToOutput() for forwarded packets, to handleMulticastPacket() for multicast packets, or drops the packet if it's unroutable or forwarding is off.

{
    // TODO add option handling code here
 
    auto header = datagram->peekAtFront<NextHopForwardingHeader>();
    L3Address destAddr = header->getDestinationAddress();
 
    EV_INFO << "Routing datagram `" << datagram->getName() << "' with dest=" << destAddr << ": ";
 
    // check for local delivery
    if (routingTable->isLocalAddress(destAddr)) {
        EV_INFO << "local delivery\n";
        if (fromHL && header->getSourceAddress().isUnspecified()) {
            datagram->trimFront();
            const auto& newHeader = removeNetworkProtocolHeader<NextHopForwardingHeader>(datagram);
            newHeader->setSourceAddress(destAddr); // allows two apps on the same host to communicate
            insertNetworkProtocolHeader(datagram, Protocol::nextHopForwarding, newHeader);
            header = newHeader;
        }
        numLocalDeliver++;
 
        if (datagramLocalInHook(datagram) != INetfilter::IHook::ACCEPT)
            return;
 
        sendDatagramToHL(datagram);
        return;
    }
 
    // if datagram arrived from input gate and forwarding is off, delete datagram
    if (!fromHL && !routingTable->isForwardingEnabled()) {
        EV_INFO << "forwarding off, dropping packet\n";
        numDropped++;
        delete datagram;
        return;
    }
 
    if (!fromHL) {
        datagram->trim();
    }
 
    // if output port was explicitly requested, use that, otherwise use NextHopForwarding routing
    // TODO see Ipv4, using destIE here leaves nextHope unspecified
    L3Address nextHop;
    if (destIE && !requestedNextHop.isUnspecified()) {
        EV_DETAIL << "using manually specified output interface " << destIE->getInterfaceName() << "\n";
        nextHop = requestedNextHop;
    }
    else {
        // use NextHopForwarding routing (lookup in routing table)
        const NextHopRoute *re = routingTable->findBestMatchingRoute(destAddr);
 
        // error handling: destination address does not exist in routing table:
        // throw packet away and continue
        if (re == nullptr) {
            EV_INFO << "unroutable, discarding packet\n";
            numUnroutable++;
            PacketDropDetails details;
            details.setReason(NO_ROUTE_FOUND);
            emit(packetDroppedSignal, datagram, &details);
            delete datagram;
            return;
        }
 
        // extract interface and next-hop address from routing table entry
        destIE = re->getInterface();
        nextHop = re->getNextHopAsGeneric();
    }
 
    if (!fromHL) {
        datagram->trimFront();
        const auto& newHeader = removeNetworkProtocolHeader<NextHopForwardingHeader>(datagram);
        newHeader->setHopLimit(header->getHopLimit() - 1);
        insertNetworkProtocolHeader(datagram, Protocol::nextHopForwarding, newHeader);
        header = newHeader;
    }
 
    // set datagram source address if not yet set
    if (header->getSourceAddress().isUnspecified()) {
        datagram->trimFront();
        const auto& newHeader = removeNetworkProtocolHeader<NextHopForwardingHeader>(datagram);
        newHeader->setSourceAddress(destIE->getProtocolData<NextHopInterfaceData>()->getAddress());
        insertNetworkProtocolHeader(datagram, Protocol::nextHopForwarding, newHeader);
        header = newHeader;
    }
 
    // default: send datagram to fragmentation
    EV_INFO << "output interface is " << destIE->getInterfaceName() << ", next-hop address: " << nextHop << "\n";
    numForwarded++;
 
    sendDatagramToOutput(datagram, destIE, nextHop);
}

Referenced by datagramLocalOut(), and datagramPreRouting().

sendDatagramToHL()

void inet::NextHopForwarding::sendDatagramToHL ( Packet *  datagram )

protectedvirtual

Send datagrams up to the higher layers.

{
    const auto& header = packet->peekAtFront<NextHopForwardingHeader>();
    const Protocol *protocol = header->getProtocol();
    decapsulate(packet);
    // deliver to sockets
    auto localAddress(header->getDestAddr());
    auto remoteAddress(header->getSrcAddr());
    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 << "\n";
        emit(packetSentToUpperSignal, packet);
        send(packet, "transportOut");
        numLocalDeliver++;
    }
    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;
    }
}

Referenced by datagramLocalIn(), routeMulticastPacket(), and routePacket().

sendDatagramToOutput()

void inet::NextHopForwarding::sendDatagramToOutput ( Packet *  datagram, const NetworkInterface *  ie, L3Address  nextHop  )

protectedvirtual

Last TTL check, then send datagram on the given interface.

{
    delete datagram->removeControlInfo();
 
    if (datagram->getByteLength() > ie->getMtu())
        throw cRuntimeError("datagram too large"); // TODO refine
 
    const auto& header = datagram->peekAtFront<NextHopForwardingHeader>();
    // hop counter check
    if (header->getHopLimit() <= 0) {
        EV_INFO << "datagram hopLimit reached zero, discarding\n";
        delete datagram; // TODO stats counter???
        return;
    }
 
    if (!ie->isBroadcast()) {
        EV_DETAIL << "output interface " << ie->getInterfaceName() << " is not broadcast, skipping ARP\n";
        // Peer to peer interface, no broadcast, no MACAddress. // packet->addTagIfAbsent<MACAddressReq>()->setDestinationAddress(macAddress);
        datagram->addTagIfAbsent<InterfaceReq>()->setInterfaceId(ie->getInterfaceId());
        datagram->addTagIfAbsent<DispatchProtocolInd>()->setProtocol(&Protocol::nextHopForwarding);
        datagram->addTagIfAbsent<PacketProtocolTag>()->setProtocol(&Protocol::nextHopForwarding);
        auto protocol = ie->getProtocol();
        if (protocol != nullptr)
            datagram->addTagIfAbsent<DispatchProtocolReq>()->setProtocol(protocol);
        else
            datagram->removeTagIfPresent<DispatchProtocolReq>();
        send(datagram, "queueOut");
        return;
    }
 
    // determine what address to look up in ARP cache
    if (nextHop.isUnspecified()) {
        nextHop = header->getDestinationAddress();
        EV_WARN << "no next-hop address, using destination address " << nextHop << " (proxy ARP)\n";
    }
 
    // send out datagram to NIC, with control info attached
    MacAddress nextHopMAC = arp->resolveL3Address(nextHop, ie);
    if (nextHopMAC == MacAddress::UNSPECIFIED_ADDRESS) {
        throw cRuntimeError("ARP couldn't resolve the '%s' address", nextHop.str().c_str());
    }
    else {
        // add control info with MAC address
        datagram->addTagIfAbsent<MacAddressReq>()->setDestAddress(nextHopMAC);
        datagram->addTagIfAbsent<InterfaceReq>()->setInterfaceId(ie->getInterfaceId());
        datagram->addTagIfAbsent<DispatchProtocolInd>()->setProtocol(&Protocol::nextHopForwarding);
        datagram->addTagIfAbsent<PacketProtocolTag>()->setProtocol(&Protocol::nextHopForwarding);
        auto protocol = ie->getProtocol();
        if (protocol != nullptr)
            datagram->addTagIfAbsent<DispatchProtocolReq>()->setProtocol(protocol);
        else
            datagram->removeTagIfPresent<DispatchProtocolReq>();
 
        // send out
        send(datagram, "queueOut");
    }
}

Referenced by routeMulticastPacket(), and routePacket().

start()

void inet::NextHopForwarding::start ( )

protectedvirtual

{
}

Referenced by handleStartOperation().

stop()

void inet::NextHopForwarding::stop ( )

protectedvirtual

{
    flush();
    for (auto it : socketIdToSocketDescriptor)
        delete it.second;
    socketIdToSocketDescriptor.clear();
}

Referenced by handleCrashOperation(), and handleStopOperation().

unregisterHook()

void inet::NextHopForwarding::unregisterHook ( IHook *  hook )

overridevirtual

Removes the provided hook from the list of registered hooks.

Reimplemented from inet::NetfilterBase.

{
    Enter_Method("unregisterHook()");
    NetfilterBase::unregisterHook(hook);
}

Member Data Documentation

arp

ModuleRefByPar<IArp> inet::NextHopForwarding::arp

protected

Referenced by initialize(), and sendDatagramToOutput().

defaultHopLimit

int inet::NextHopForwarding::defaultHopLimit

protected

Referenced by encapsulate(), and initialize().

interfaceTable

ModuleRefByPar<IInterfaceTable> inet::NextHopForwarding::interfaceTable

protected

Referenced by encapsulate(), getSourceInterfaceFrom(), handlePacketFromHL(), handlePacketFromNetwork(), initialize(), and routeMulticastPacket().

numDropped

int inet::NextHopForwarding::numDropped

protected

Referenced by initialize(), refreshDisplay(), and routePacket().

numForwarded

int inet::NextHopForwarding::numForwarded

protected

Referenced by initialize(), refreshDisplay(), and routePacket().

numLocalDeliver

int inet::NextHopForwarding::numLocalDeliver

protected

Referenced by initialize(), refreshDisplay(), routePacket(), and sendDatagramToHL().

numUnroutable

int inet::NextHopForwarding::numUnroutable

protected

Referenced by initialize(), refreshDisplay(), and routePacket().

queuedDatagramsForHooks

DatagramQueueForHooks inet::NextHopForwarding::queuedDatagramsForHooks

protected

Referenced by datagramForwardHook(), datagramLocalInHook(), datagramLocalOutHook(), datagramPostRoutingHook(), datagramPreRoutingHook(), dropQueuedDatagram(), flush(), reinjectQueuedDatagram(), and ~NextHopForwarding().

routingTable

ModuleRefByPar<NextHopRoutingTable> inet::NextHopForwarding::routingTable

protected

Referenced by encapsulate(), initialize(), routeMulticastPacket(), and routePacket().

socketIdToSocketDescriptor

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

protected

Referenced by handleCommand(), sendDatagramToHL(), stop(), and ~NextHopForwarding().

upperProtocols

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

protected

Referenced by handleRegisterProtocol(), and sendDatagramToHL().

---

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

• NextHopForwarding.h
• NextHopForwarding.cc