inet::Ipv4 Class Reference

Implements the Ipv4 protocol. More...

#include <Ipv4.h>

Inheritance diagram for inet::Ipv4:

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

Public Types
typedef std::map< Ipv4Address, cPacketQueue >	PendingPackets

Public Member Functions
	Ipv4 ()
virtual	~Ipv4 ()
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
	registers a Hook to be executed during datagram processing More...
virtual void	unregisterHook (IHook *hook) override
	unregisters a Hook to be executed during datagram processing More...
virtual void	dropQueuedDatagram (const Packet *datagram) override
	drop a previously queued datagram More...
virtual void	reinjectQueuedDatagram (const Packet *datagram) override
	re-injects a previously queued datagram More...
virtual bool	isInitializeStage (int stage) const override
	ILifecycle methods. 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	receiveSignal (cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override
	cListener method 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

Static Public Member Functions
static void	insertCrc (const Ptr< Ipv4Header > &ipv4Header)

Protected Types
typedef std::list< QueuedDatagramForHook >	DatagramQueueForHooks
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State

Protected Member Functions
virtual const NetworkInterface *	getSourceInterface (Packet *packet)
virtual const NetworkInterface *	getDestInterface (Packet *packet)
virtual Ipv4Address	getNextHop (Packet *packet)
virtual const NetworkInterface *	getShortestPathInterfaceToSource (const Ptr< const Ipv4Header > &ipv4Header) const
virtual void	refreshDisplay () const override
void	arpResolutionCompleted (IArp::Notification *entry)
void	arpResolutionTimedOut (IArp::Notification *entry)
bool	verifyCrc (const Ptr< const Ipv4Header > &ipv4Header)
void	setComputedCrc (Ptr< Ipv4Header > &ipv4Header)
virtual void	encapsulate (Packet *packet)
	Encapsulate packet coming from higher layers into Ipv4Header, using the given control info. More...
virtual void	handleIncomingDatagram (Packet *packet)
	Handle Ipv4Header messages arriving from lower layer. More...
virtual void	preroutingFinish (Packet *packet)
virtual void	handlePacketFromHL (Packet *packet)
	Handle messages (typically packets to be send in Ipv4) from transport or ICMP. More...
virtual void	datagramLocalOut (Packet *packet)
	Routes and sends datagram received from higher layers. More...
virtual void	routeUnicastPacket (Packet *packet)
	Performs unicast routing. More...
void	routeUnicastPacketFinish (Packet *packet)
virtual void	routeLocalBroadcastPacket (Packet *packet)
	Broadcasts the datagram on the specified interface. More...
virtual const NetworkInterface *	determineOutgoingInterfaceForMulticastDatagram (const Ptr< const Ipv4Header > &ipv4Header, const NetworkInterface *multicastIFOption)
	Determines the output interface for the given multicast datagram. More...
virtual void	forwardMulticastPacket (Packet *packet)
	Forwards packets to all multicast destinations, using fragmentAndSend(). More...
virtual void	reassembleAndDeliver (Packet *packet)
	Perform reassembly of fragmented datagrams, then send them up to the higher layers using sendToHL(). More...
virtual void	reassembleAndDeliverFinish (Packet *packet)
virtual void	decapsulate (Packet *packet)
	Decapsulate packet. More...
virtual void	fragmentPostRouting (Packet *datagram)
	Call PostRouting Hook and continue with fragmentAndSend() if accepted. More...
virtual void	fragmentAndSend (Packet *packet)
	Fragment packet if needed, then send it to the selected interface using sendDatagramToOutput(). More...
virtual void	sendDatagramToOutput (Packet *packet)
	Send datagram on the given interface. More...
virtual MacAddress	resolveNextHopMacAddress (cPacket *packet, Ipv4Address nextHopAddr, const NetworkInterface *destIE)
virtual void	sendPacketToNIC (Packet *packet)
virtual void	sendIcmpError (Packet *packet, int inputInterfaceId, IcmpType type, IcmpCode code)
virtual Packet *	prepareForForwarding (Packet *packet) const
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessageWhenUp (cMessage *msg) override
void	handleRequest (Request *request)
IHook::Result	datagramPreRoutingHook (Packet *datagram)
	called before a packet arriving from the network is routed More...
IHook::Result	datagramForwardHook (Packet *datagram)
	called before a packet arriving from the network is delivered via the network More...
IHook::Result	datagramPostRoutingHook (Packet *datagram)
	called before a packet is delivered via the network More...
IHook::Result	datagramLocalInHook (Packet *datagram)
	called before a packet arriving from the network is delivered locally More...
IHook::Result	datagramLocalOutHook (Packet *datagram)
	called before a packet arriving locally is delivered More...
virtual void	start ()
virtual void	stop ()
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< IIpv4RoutingTable >	rt
ModuleRefByPar< IInterfaceTable >	ift
ModuleRefByPar< IArp >	arp
ModuleRefByPar< Icmp >	icmp
int	transportInGateBaseId = -1
CrcMode	crcMode = CRC_MODE_UNDEFINED
int	defaultTimeToLive = -1
int	defaultMCTimeToLive = -1
simtime_t	fragmentTimeoutTime
bool	limitedBroadcast = false
std::string	directBroadcastInterfaces = ""
cPatternMatcher	directBroadcastInterfaceMatcher
uint16_t	curFragmentId = -1
Ipv4FragBuf	fragbuf
simtime_t	lastCheckTime
std::set< const Protocol * >	upperProtocols
std::map< int, SocketDescriptor * >	socketIdToSocketDescriptor
PendingPackets	pendingPackets
int	numMulticast = 0
int	numLocalDeliver = 0
int	numDropped = 0
int	numUnroutable = 0
int	numForwarded = 0
DatagramQueueForHooks	queuedDatagramsForHooks
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 the Ipv4 protocol.

Member Typedef Documentation

DatagramQueueForHooks

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

protected

PendingPackets

typedef std::map<Ipv4Address, cPacketQueue> inet::Ipv4::PendingPackets

Constructor & Destructor Documentation

Ipv4()

inet::Ipv4::Ipv4

(

)

{
}

~Ipv4()

inet::Ipv4::~Ipv4 ( )

virtual

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

Member Function Documentation

arpResolutionCompleted()

void inet::Ipv4::arpResolutionCompleted ( IArp::Notification *  entry )

protected

{
    if (entry->l3Address.getType() != L3Address::IPv4)
        return;
    auto it = pendingPackets.find(entry->l3Address.toIpv4());
    if (it != pendingPackets.end()) {
        cPacketQueue& packetQueue = it->second;
        EV << "ARP resolution completed for " << entry->l3Address << ". Sending " << packetQueue.getLength()
           << " waiting packets from the queue\n";
 
        while (!packetQueue.isEmpty()) {
            Packet *packet = check_and_cast<Packet *>(packetQueue.pop());
            EV << "Sending out queued packet " << packet << "\n";
            packet->addTagIfAbsent<InterfaceReq>()->setInterfaceId(entry->ie->getInterfaceId());
            packet->addTagIfAbsent<MacAddressReq>()->setDestAddress(entry->macAddress);
            sendPacketToNIC(packet);
        }
        pendingPackets.erase(it);
    }
}

Referenced by receiveSignal().

arpResolutionTimedOut()

void inet::Ipv4::arpResolutionTimedOut ( IArp::Notification *  entry )

protected

{
    if (entry->l3Address.getType() != L3Address::IPv4)
        return;
    auto it = pendingPackets.find(entry->l3Address.toIpv4());
    if (it != pendingPackets.end()) {
        cPacketQueue& packetQueue = it->second;
        EV << "ARP resolution failed for " << entry->l3Address << ",  dropping " << packetQueue.getLength() << " packets\n";
        for (int i = 0; i < packetQueue.getLength(); i++) {
            auto packet = packetQueue.get(i);
            PacketDropDetails details;
            details.setReason(ADDRESS_RESOLUTION_FAILED);
            emit(packetDroppedSignal, packet, &details);
        }
        packetQueue.clear();
        pendingPackets.erase(it);
    }
}

Referenced by receiveSignal().

datagramForwardHook()

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

protected

called before a packet arriving from the network is delivered via the network

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

Referenced by routeUnicastPacket().

datagramLocalInHook()

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

protected

called before a packet arriving from the network is delivered locally

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

Referenced by reassembleAndDeliver().

datagramLocalOut()

void inet::Ipv4::datagramLocalOut ( Packet *  packet )

protectedvirtual

Routes and sends datagram received from higher layers.

Invokes datagramLocalOutHook(), then routePacket().

{
    const NetworkInterface *destIE = getDestInterface(packet);
    Ipv4Address requestedNextHopAddress = getNextHop(packet);
 
    const auto& ipv4Header = packet->peekAtFront<Ipv4Header>();
    bool multicastLoop = false;
    const auto& mcr = packet->findTag<MulticastReq>();
    if (mcr != nullptr) {
        multicastLoop = mcr->getMulticastLoop();
    }
 
    // send
    Ipv4Address destAddr = ipv4Header->getDestAddress();
 
    EV_DETAIL << "Sending datagram '" << packet->getName() << "' with destination = " << destAddr << "\n";
 
    if (ipv4Header->getDestAddress().isMulticast()) {
        destIE = determineOutgoingInterfaceForMulticastDatagram(ipv4Header, destIE);
        packet->addTagIfAbsent<InterfaceReq>()->setInterfaceId(destIE ? destIE->getInterfaceId() : -1);
 
        // loop back a copy
        if (multicastLoop && (!destIE || !destIE->isLoopback())) {
            const NetworkInterface *loopbackIF = ift->findFirstLoopbackInterface();
            if (loopbackIF) {
                auto packetCopy = packet->dup();
                packetCopy->addTagIfAbsent<InterfaceReq>()->setInterfaceId(loopbackIF->getInterfaceId());
                packetCopy->addTagIfAbsent<NextHopAddressReq>()->setNextHopAddress(destAddr);
                fragmentPostRouting(packetCopy);
            }
        }
 
        if (destIE) {
            numMulticast++;
            packet->addTagIfAbsent<InterfaceReq>()->setInterfaceId(destIE->getInterfaceId()); // KLUDGE is it needed?
            packet->addTagIfAbsent<NextHopAddressReq>()->setNextHopAddress(destAddr);
            fragmentPostRouting(packet);
        }
        else {
            EV_ERROR << "No multicast interface, packet dropped\n";
            numUnroutable++;
            PacketDropDetails details;
            details.setReason(NO_INTERFACE_FOUND);
            emit(packetDroppedSignal, packet, &details);
            delete packet;
        }
    }
    else { // unicast and broadcast
           // check for local delivery
        if (rt->isLocalAddress(destAddr)) {
            EV_INFO << "Delivering " << packet << " locally.\n";
            if (destIE && !destIE->isLoopback()) {
                EV_DETAIL << "datagram destination address is local, ignoring destination interface specified in the control info\n";
                destIE = nullptr;
                packet->addTagIfAbsent<InterfaceReq>()->setInterfaceId(-1);
            }
            if (!destIE) {
                destIE = ift->findFirstLoopbackInterface();
                packet->addTagIfAbsent<InterfaceReq>()->setInterfaceId(destIE ? destIE->getInterfaceId() : -1);
            }
            ASSERT(destIE);
            packet->addTagIfAbsent<NextHopAddressReq>()->setNextHopAddress(destAddr);
            routeUnicastPacket(packet);
        }
        else if (destAddr.isLimitedBroadcastAddress() || rt->isLocalBroadcastAddress(destAddr))
            routeLocalBroadcastPacket(packet);
        else {
            packet->addTagIfAbsent<NextHopAddressReq>()->setNextHopAddress(requestedNextHopAddress);
            routeUnicastPacket(packet);
        }
    }
}

Referenced by handlePacketFromHL(), and reinjectQueuedDatagram().

datagramLocalOutHook()

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

protected

called before a packet arriving locally is delivered

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

Referenced by handlePacketFromHL().

datagramPostRoutingHook()

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

protected

called before a packet is delivered via the network

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

Referenced by fragmentPostRouting().

datagramPreRoutingHook()

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

protected

called before a packet arriving from the network is routed

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

Referenced by handleIncomingDatagram().

decapsulate()

void inet::Ipv4::decapsulate ( Packet *  packet )

protectedvirtual

Decapsulate packet.

{
    // decapsulate transport packet
    const auto& ipv4Header = packet->popAtFront<Ipv4Header>();
 
    // create and fill in control info
    packet->addTagIfAbsent<DscpInd>()->setDifferentiatedServicesCodePoint(ipv4Header->getDscp());
    packet->addTagIfAbsent<EcnInd>()->setExplicitCongestionNotification(ipv4Header->getEcn());
    packet->addTagIfAbsent<TosInd>()->setTos(ipv4Header->getTypeOfService());
 
    // original Ipv4 datagram might be needed in upper layers to send back ICMP error message
 
    auto transportProtocol = ProtocolGroup::ipprotocol.getProtocol(ipv4Header->getProtocolId());
    packet->addTagIfAbsent<PacketProtocolTag>()->setProtocol(transportProtocol);
    packet->addTagIfAbsent<DispatchProtocolReq>()->setProtocol(transportProtocol);
    auto l3AddressInd = packet->addTagIfAbsent<L3AddressInd>();
    l3AddressInd->setSrcAddress(ipv4Header->getSrcAddress());
    l3AddressInd->setDestAddress(ipv4Header->getDestAddress());
    packet->addTagIfAbsent<HopLimitInd>()->setHopLimit(ipv4Header->getTimeToLive());
}

Referenced by reassembleAndDeliverFinish().

determineOutgoingInterfaceForMulticastDatagram()

const NetworkInterface * inet::Ipv4::determineOutgoingInterfaceForMulticastDatagram ( const Ptr< const Ipv4Header > &  ipv4Header, const NetworkInterface *  multicastIFOption  )

protectedvirtual

Determines the output interface for the given multicast datagram.

{
    const NetworkInterface *ie = nullptr;
    if (multicastIFOption) {
        ie = multicastIFOption;
        EV_DETAIL << "multicast packet routed by socket option via output interface " << ie->getInterfaceName() << "\n";
    }
    if (!ie) {
        Ipv4Route *route = rt->findBestMatchingRoute(ipv4Header->getDestAddress());
        if (route)
            ie = route->getInterface();
        if (ie)
            EV_DETAIL << "multicast packet routed by routing table via output interface " << ie->getInterfaceName() << "\n";
    }
    if (!ie) {
        ie = rt->getInterfaceByAddress(ipv4Header->getSrcAddress());
        if (ie)
            EV_DETAIL << "multicast packet routed by source address via output interface " << ie->getInterfaceName() << "\n";
    }
    if (!ie) {
        ie = ift->findFirstMulticastInterface();
        if (ie)
            EV_DETAIL << "multicast packet routed via the first multicast interface " << ie->getInterfaceName() << "\n";
    }
    return ie;
}

Referenced by datagramLocalOut().

dropQueuedDatagram()

void inet::Ipv4::dropQueuedDatagram ( const Packet *  datagram )

overridevirtual

drop a previously queued datagram

Implements inet::INetfilter.

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

encapsulate()

void inet::Ipv4::encapsulate ( Packet *  packet )

protectedvirtual

Encapsulate packet coming from higher layers into Ipv4Header, using the given control info.

Override if you subclassed controlInfo and/or want to add options etc to the datagram.

{
    const auto& ipv4Header = makeShared<Ipv4Header>();
 
    auto l3AddressReq = transportPacket->removeTag<L3AddressReq>();
    Ipv4Address src = l3AddressReq->getSrcAddress().toIpv4();
    bool nonLocalSrcAddress = l3AddressReq->getNonLocalSrcAddress();
    Ipv4Address dest = l3AddressReq->getDestAddress().toIpv4();
 
    ipv4Header->setProtocolId((IpProtocolId)ProtocolGroup::ipprotocol.getProtocolNumber(transportPacket->getTag<PacketProtocolTag>()->getProtocol()));
 
    auto hopLimitReq = transportPacket->removeTagIfPresent<HopLimitReq>();
    short ttl = (hopLimitReq != nullptr) ? hopLimitReq->getHopLimit() : -1;
    bool dontFragment = false;
    if (auto& dontFragmentReq = transportPacket->removeTagIfPresent<FragmentationReq>())
        dontFragment = dontFragmentReq->getDontFragment();
 
    // set source and destination address
    ipv4Header->setDestAddress(dest);
 
    // when source address was given, use it; otherwise it'll get the address
    // of the outgoing interface after routing
    if (!src.isUnspecified()) {
        if (!nonLocalSrcAddress && rt->getInterfaceByAddress(src) == nullptr)
            // if interface parameter does not match existing interface, do not send datagram
            throw cRuntimeError("Wrong source address %s in (%s)%s: no interface with such address",
                    src.str().c_str(), transportPacket->getClassName(), transportPacket->getFullName());
 
        ipv4Header->setSrcAddress(src);
    }
 
    // set other fields
    if (auto& tosReq = transportPacket->removeTagIfPresent<TosReq>()) {
        ipv4Header->setTypeOfService(tosReq->getTos());
        if (transportPacket->findTag<DscpReq>())
            throw cRuntimeError("TosReq and DscpReq found together");
        if (transportPacket->findTag<EcnReq>())
            throw cRuntimeError("TosReq and EcnReq found together");
        transportPacket->addTag<TosInd>()->setTos(ipv4Header->getTypeOfService());
    }
    if (auto& dscpReq = transportPacket->removeTagIfPresent<DscpReq>()) {
        ipv4Header->setDscp(dscpReq->getDifferentiatedServicesCodePoint());
        transportPacket->addTag<DscpInd>()->setDifferentiatedServicesCodePoint(ipv4Header->getDscp());
    }
    if (auto& ecnReq = transportPacket->removeTagIfPresent<EcnReq>()) {
        ipv4Header->setEcn(ecnReq->getExplicitCongestionNotification());
        transportPacket->addTag<EcnInd>()->setExplicitCongestionNotification(ipv4Header->getEcn());
    }
 
    ipv4Header->setIdentification(curFragmentId++);
    ipv4Header->setMoreFragments(false);
    ipv4Header->setDontFragment(dontFragment);
    ipv4Header->setFragmentOffset(0);
 
    if (ttl != -1) {
        ASSERT(ttl > 0);
    }
    else if (ipv4Header->getDestAddress().isLinkLocalMulticast())
        ttl = 1;
    else if (ipv4Header->getDestAddress().isMulticast())
        ttl = defaultMCTimeToLive;
    else
        ttl = defaultTimeToLive;
    ipv4Header->setTimeToLive(ttl);
 
    if (auto& optReq = transportPacket->removeTagIfPresent<Ipv4OptionsReq>()) {
        for (size_t i = 0; i < optReq->getOptionArraySize(); i++) {
            auto opt = optReq->removeOption(i);
            ipv4Header->addOption(opt);
            ipv4Header->addChunkLength(B(opt->getLength()));
        }
    }
 
    ASSERT(ipv4Header->getChunkLength() <= IPv4_MAX_HEADER_LENGTH);
    ipv4Header->setHeaderLength(ipv4Header->getChunkLength());
    ipv4Header->setTotalLengthField(ipv4Header->getChunkLength() + transportPacket->getDataLength());
    ipv4Header->setCrcMode(crcMode);
    ipv4Header->setCrc(0);
    switch (crcMode) {
        case CRC_DECLARED_CORRECT:
            // if the CRC mode is declared to be correct, then set the CRC to an easily recognizable value
            ipv4Header->setCrc(0xC00D);
            break;
        case CRC_DECLARED_INCORRECT:
            // if the CRC mode is declared to be incorrect, then set the CRC to an easily recognizable value
            ipv4Header->setCrc(0xBAAD);
            break;
        case CRC_COMPUTED: {
            ipv4Header->setCrc(0);
            // crc will be calculated in fragmentAndSend()
            break;
        }
        default:
            throw cRuntimeError("Unknown CRC mode");
    }
    insertNetworkProtocolHeader(transportPacket, Protocol::ipv4, ipv4Header);
    // setting Ipv4 options is currently not supported
}

Referenced by handlePacketFromHL().

flush()

void inet::Ipv4::flush ( )

protectedvirtual

{
    EV_DEBUG << "Ipv4::flush(): pending packets:\n";
    for (auto& elem : pendingPackets) {
        EV_DEBUG << "Ipv4::flush():    " << elem.first << ": " << elem.second.str() << endl;
        elem.second.clear();
    }
    pendingPackets.clear();
 
    EV_DEBUG << "Ipv4::flush(): packets in hooks: " << queuedDatagramsForHooks.size() << endl;
    for (auto& elem : queuedDatagramsForHooks) {
        delete elem.packet;
    }
    queuedDatagramsForHooks.clear();
 
    fragbuf.flush();
}

Referenced by stop(), and ~Ipv4().

forwardMulticastPacket()

void inet::Ipv4::forwardMulticastPacket ( Packet *  packet )

protectedvirtual

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

{
    const NetworkInterface *fromIE = ift->getInterfaceById(packet->getTag<InterfaceInd>()->getInterfaceId());
    const auto& ipv4Header = packet->peekAtFront<Ipv4Header>();
    const Ipv4Address& srcAddr = ipv4Header->getSrcAddress();
    const Ipv4Address& destAddr = ipv4Header->getDestAddress();
    ASSERT(destAddr.isMulticast());
    ASSERT(!destAddr.isLinkLocalMulticast());
 
    EV_INFO << "Forwarding multicast datagram `" << packet->getName() << "' with dest=" << destAddr << "\n";
 
    numMulticast++;
 
    const Ipv4MulticastRoute *route = rt->findBestMatchingMulticastRoute(srcAddr, destAddr);
    if (!route) {
        EV_WARN << "Multicast route does not exist, try to add.\n";
        // TODO no need to emit fromIE when tags will be used in place of control infos
        emit(ipv4NewMulticastSignal, ipv4Header.get(), const_cast<NetworkInterface *>(fromIE));
 
        // read new record
        route = rt->findBestMatchingMulticastRoute(srcAddr, destAddr);
 
        if (!route) {
            EV_ERROR << "No route, packet dropped.\n";
            numUnroutable++;
            PacketDropDetails details;
            details.setReason(NO_ROUTE_FOUND);
            emit(packetDroppedSignal, packet, &details);
            delete packet;
            return;
        }
    }
 
    if (route->getInInterface() && fromIE != route->getInInterface()->getInterface()) {
        EV_ERROR << "Did not arrive on input interface, packet dropped.\n";
        // TODO no need to emit fromIE when tags will be used in place of control infos
        emit(ipv4DataOnNonrpfSignal, ipv4Header.get(), const_cast<NetworkInterface *>(fromIE));
        numDropped++;
        PacketDropDetails details;
        emit(packetDroppedSignal, packet, &details);
        delete packet;
    }
    // backward compatible: no parent means shortest path interface to source (RPB routing)
    else if (!route->getInInterface() && fromIE != getShortestPathInterfaceToSource(ipv4Header)) {
        EV_ERROR << "Did not arrive on shortest path, packet dropped.\n";
        numDropped++;
        PacketDropDetails details;
        emit(packetDroppedSignal, packet, &details);
        delete packet;
    }
    else {
        // TODO no need to emit fromIE when tags will be used in place of control infos
        emit(ipv4DataOnRpfSignal, ipv4Header.get(), const_cast<NetworkInterface *>(fromIE)); // forwarding hook
 
        numForwarded++;
        // copy original datagram for multiple destinations
        for (unsigned int i = 0; i < route->getNumOutInterfaces(); i++) {
            Ipv4MulticastRoute::OutInterface *outInterface = route->getOutInterface(i);
            const NetworkInterface *destIE = outInterface->getInterface();
            if (destIE != fromIE && outInterface->isEnabled()) {
                int ttlThreshold = destIE->getProtocolData<Ipv4InterfaceData>()->getMulticastTtlThreshold();
                if (ipv4Header->getTimeToLive() <= ttlThreshold)
                    EV_WARN << "Not forwarding to " << destIE->getInterfaceName() << " (ttl threshold reached)\n";
                else if (outInterface->isLeaf() && !destIE->getProtocolData<Ipv4InterfaceData>()->hasMulticastListener(destAddr))
                    EV_WARN << "Not forwarding to " << destIE->getInterfaceName() << " (no listeners)\n";
                else {
                    EV_DETAIL << "Forwarding to " << destIE->getInterfaceName() << "\n";
                    auto packetCopy = packet->dup();
                    packetCopy->addTagIfAbsent<InterfaceReq>()->setInterfaceId(destIE->getInterfaceId());
                    packetCopy->addTagIfAbsent<NextHopAddressReq>()->setNextHopAddress(destAddr);
                    fragmentPostRouting(packetCopy);
                }
            }
        }
 
        // TODO no need to emit fromIE when tags will be use, d in place of control infos
        emit(ipv4MdataRegisterSignal, packet, const_cast<NetworkInterface *>(fromIE)); // postRouting hook
 
        // only copies sent, delete original packet
        delete packet;
    }
}

Referenced by preroutingFinish().

fragmentAndSend()

void inet::Ipv4::fragmentAndSend ( Packet *  packet )

protectedvirtual

Fragment packet if needed, then send it to the selected interface using sendDatagramToOutput().

{
    const NetworkInterface *destIE = ift->getInterfaceById(packet->getTag<InterfaceReq>()->getInterfaceId());
    Ipv4Address nextHopAddr = getNextHop(packet);
    if (nextHopAddr.isUnspecified()) {
        nextHopAddr = packet->peekAtFront<Ipv4Header>()->getDestAddress();
        packet->addTagIfAbsent<NextHopAddressReq>()->setNextHopAddress(nextHopAddr);
    }
 
    const auto& ipv4Header = packet->peekAtFront<Ipv4Header>();
 
    // hop counter check
    if (ipv4Header->getTimeToLive() <= 0) {
        // drop datagram, destruction responsibility in ICMP
        PacketDropDetails details;
        details.setReason(HOP_LIMIT_REACHED);
        emit(packetDroppedSignal, packet, &details);
        EV_WARN << "datagram TTL reached zero, sending ICMP_TIME_EXCEEDED\n";
        sendIcmpError(packet, -1 /*TODO*/, ICMP_TIME_EXCEEDED, 0);
        numDropped++;
        return;
    }
 
    int mtu = destIE->getMtu();
 
    // send datagram straight out if it doesn't require fragmentation (note: mtu==0 means infinite mtu)
    if (mtu == 0 || packet->getByteLength() <= mtu) {
        if (crcMode == CRC_COMPUTED) {
            auto ipv4Header = removeNetworkProtocolHeader<Ipv4Header>(packet);
            setComputedCrc(ipv4Header);
            insertNetworkProtocolHeader(packet, Protocol::ipv4, ipv4Header);
        }
        sendDatagramToOutput(packet);
        return;
    }
 
    // if "don't fragment" bit is set, throw datagram away and send ICMP error message
    if (ipv4Header->getDontFragment()) {
        PacketDropDetails details;
        emit(packetDroppedSignal, packet, &details);
        EV_WARN << "datagram larger than MTU and don't fragment bit set, sending ICMP_DESTINATION_UNREACHABLE\n";
        icmp->sendPtbMessage(packet, mtu);
        numDropped++;
        delete packet;
        return;
    }
 
    // FIXME some IP options should not be copied into each fragment, check their COPY bit
    int headerLength = B(ipv4Header->getHeaderLength()).get();
    int payloadLength = B(packet->getDataLength()).get() - headerLength;
    int fragmentLength = ((mtu - headerLength) / 8) * 8; // payload only (without header)
    int offsetBase = ipv4Header->getFragmentOffset();
    if (fragmentLength <= 0)
        throw cRuntimeError("Cannot fragment datagram: MTU=%d too small for header size (%d bytes)", mtu, headerLength); // exception and not ICMP because this is likely a simulation configuration error, not something one wants to simulate
 
    int noOfFragments = (payloadLength + fragmentLength - 1) / fragmentLength;
    EV_DETAIL << "Breaking datagram into " << noOfFragments << " fragments\n";
 
    // create and send fragments
    std::string fragMsgName = packet->getName();
    fragMsgName += "-frag-";
 
    int offset = 0;
    while (offset < payloadLength) {
        bool lastFragment = (offset + fragmentLength >= payloadLength);
        // length equal to fragmentLength, except for last fragment;
        int thisFragmentLength = lastFragment ? payloadLength - offset : fragmentLength;
 
        std::string curFragName = fragMsgName + std::to_string(offset);
        if (lastFragment)
            curFragName += "-last";
        Packet *fragment = new Packet(curFragName.c_str()); // TODO add offset or index to fragment name
 
        // copy Tags from packet to fragment
        fragment->copyTags(*packet);
 
        ASSERT(fragment->getByteLength() == 0);
        auto fraghdr = staticPtrCast<Ipv4Header>(ipv4Header->dupShared());
        const auto& fragData = packet->peekDataAt(B(headerLength + offset), B(thisFragmentLength));
        ASSERT(fragData->getChunkLength() == B(thisFragmentLength));
        fragment->insertAtBack(fragData);
 
        // "more fragments" bit is unchanged in the last fragment, otherwise true
        if (!lastFragment)
            fraghdr->setMoreFragments(true);
 
        fraghdr->setFragmentOffset(offsetBase + offset);
        fraghdr->setTotalLengthField(B(headerLength + thisFragmentLength));
        if (crcMode == CRC_COMPUTED)
            setComputedCrc(fraghdr);
 
        fragment->insertAtFront(fraghdr);
        ASSERT(fragment->getByteLength() == headerLength + thisFragmentLength);
        sendDatagramToOutput(fragment);
        offset += thisFragmentLength;
    }
 
    delete packet;
}

Referenced by fragmentPostRouting(), and reinjectQueuedDatagram().

fragmentPostRouting()

void inet::Ipv4::fragmentPostRouting ( Packet *  datagram )

protectedvirtual

Call PostRouting Hook and continue with fragmentAndSend() if accepted.

{
    const NetworkInterface *destIE = ift->getInterfaceById(packet->getTag<InterfaceReq>()->getInterfaceId());
    // fill in source address
    if (packet->peekAtFront<Ipv4Header>()->getSrcAddress().isUnspecified()) {
        auto ipv4Header = removeNetworkProtocolHeader<Ipv4Header>(packet);
        ipv4Header->setSrcAddress(destIE->getProtocolData<Ipv4InterfaceData>()->getIPAddress());
        insertNetworkProtocolHeader(packet, Protocol::ipv4, ipv4Header);
    }
    if (datagramPostRoutingHook(packet) == INetfilter::IHook::ACCEPT)
        fragmentAndSend(packet);
}

Referenced by datagramLocalOut(), forwardMulticastPacket(), preroutingFinish(), routeLocalBroadcastPacket(), and routeUnicastPacketFinish().

getDestInterface()

const NetworkInterface * inet::Ipv4::getDestInterface ( Packet *  packet )

protectedvirtual

{
    const auto& tag = packet->findTag<InterfaceReq>();
    return tag != nullptr ? ift->getInterfaceById(tag->getInterfaceId()) : nullptr;
}

Referenced by datagramLocalOut(), routeUnicastPacket(), and routeUnicastPacketFinish().

getNextHop()

Ipv4Address inet::Ipv4::getNextHop ( Packet *  packet )

protectedvirtual

{
    const auto& tag = packet->findTag<NextHopAddressReq>();
    return tag != nullptr ? tag->getNextHopAddress().toIpv4() : Ipv4Address::UNSPECIFIED_ADDRESS;
}

Referenced by datagramLocalOut(), fragmentAndSend(), preroutingFinish(), routeUnicastPacket(), and routeUnicastPacketFinish().

getShortestPathInterfaceToSource()

const NetworkInterface * inet::Ipv4::getShortestPathInterfaceToSource ( const Ptr< const Ipv4Header > &  ipv4Header ) const

protectedvirtual

{
    return rt->getInterfaceForDestAddr(ipv4Header->getSrcAddress());
}

Referenced by forwardMulticastPacket().

getSourceInterface()

const NetworkInterface * inet::Ipv4::getSourceInterface ( Packet *  packet )

protectedvirtual

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

Referenced by reassembleAndDeliverFinish(), and routeUnicastPacket().

handleCrashOperation()

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

overridevirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    stop();
}

handleIncomingDatagram()

void inet::Ipv4::handleIncomingDatagram ( Packet *  packet )

protectedvirtual

Handle Ipv4Header messages arriving from lower layer.

Decrements TTL, then invokes routePacket().

{
    ASSERT(packet);
    int interfaceId = packet->getTag<InterfaceInd>()->getInterfaceId();
    emit(packetReceivedFromLowerSignal, packet);
 
    //
    // "Prerouting"
    //
 
    const auto& ipv4Header = packet->peekAtFront<Ipv4Header>();
    packet->addTagIfAbsent<NetworkProtocolInd>()->setProtocol(&Protocol::ipv4);
    packet->addTagIfAbsent<NetworkProtocolInd>()->setNetworkProtocolHeader(ipv4Header);
 
    if (!verifyCrc(ipv4Header)) {
        EV_WARN << "CRC error found, drop packet\n";
        PacketDropDetails details;
        details.setReason(INCORRECTLY_RECEIVED);
        emit(packetDroppedSignal, packet, &details);
        delete packet;
        return;
    }
 
    if (ipv4Header->getTotalLengthField() > packet->getDataLength()) {
        EV_WARN << "length error found, sending ICMP_PARAMETER_PROBLEM\n";
        sendIcmpError(packet, interfaceId, ICMP_PARAMETER_PROBLEM, 0);
        return;
    }
 
    // remove lower layer paddings:
    if (ipv4Header->getTotalLengthField() < packet->getDataLength()) {
        packet->setBackOffset(packet->getFrontOffset() + ipv4Header->getTotalLengthField());
    }
 
    // check for header biterror
    if (packet->hasBitError()) {
        // probability of bit error in header = size of header / size of total message
        // (ignore bit error if in payload)
        double relativeHeaderLength = B(ipv4Header->getHeaderLength()).get() / (double)B(ipv4Header->getChunkLength()).get();
        if (dblrand() <= relativeHeaderLength) {
            EV_WARN << "bit error found, sending ICMP_PARAMETER_PROBLEM\n";
            sendIcmpError(packet, interfaceId, ICMP_PARAMETER_PROBLEM, 0);
            return;
        }
    }
 
    EV_DETAIL << "Received datagram `" << ipv4Header->getName() << "' with dest=" << ipv4Header->getDestAddress() << "\n";
 
    if (datagramPreRoutingHook(packet) == INetfilter::IHook::ACCEPT)
        preroutingFinish(packet);
}

Referenced by handleMessageWhenUp().

handleMessageWhenUp()

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

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

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

handlePacketFromHL()

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

protectedvirtual

Handle messages (typically packets to be send in Ipv4) from transport or ICMP.

Invokes encapsulate(), then routePacket().

{
    EV_INFO << "Received " << packet << " from upper layer.\n";
    emit(packetReceivedFromUpperSignal, packet);
 
    // if no interface exists, do not send datagram
    if (ift->getNumInterfaces() == 0) {
        EV_ERROR << "No interfaces exist, dropping packet\n";
        numDropped++;
        PacketDropDetails details;
        details.setReason(NO_INTERFACE_FOUND);
        emit(packetDroppedSignal, packet, &details);
        delete packet;
        return;
    }
 
    // encapsulate
    encapsulate(packet);
 
    // TODO
    L3Address nextHopAddr(Ipv4Address::UNSPECIFIED_ADDRESS);
    if (datagramLocalOutHook(packet) == INetfilter::IHook::ACCEPT)
        datagramLocalOut(packet);
}

Referenced by handleMessageWhenUp().

handleRegisterProtocol()

void inet::Ipv4::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::Ipv4::handleRegisterService ( const Protocol &  protocol, cGate *  gate, ServicePrimitive  servicePrimitive  )

overridevirtual

Reimplemented from inet::DefaultProtocolRegistrationListener.

{
    Enter_Method("handleRegisterService");
}

handleRequest()

void inet::Ipv4::handleRequest ( Request *  request )

protected

{
    auto ctrl = request->getControlInfo();
    if (ctrl == nullptr)
        throw cRuntimeError("Request '%s' arrived without controlinfo", request->getName());
    else if (Ipv4SocketBindCommand *command = dynamic_cast<Ipv4SocketBindCommand *>(ctrl)) {
        int socketId = request->getTag<SocketReq>()->getSocketId();
        SocketDescriptor *descriptor = new SocketDescriptor(socketId, command->getProtocol()->getId(), command->getLocalAddress());
        socketIdToSocketDescriptor[socketId] = descriptor;
        delete request;
    }
    else if (Ipv4SocketConnectCommand *command = dynamic_cast<Ipv4SocketConnectCommand *>(ctrl)) {
        int socketId = request->getTag<SocketReq>()->getSocketId();
        if (!containsKey(socketIdToSocketDescriptor, socketId))
            throw cRuntimeError("Ipv4Socket: should use bind() before connect()");
        socketIdToSocketDescriptor[socketId]->remoteAddress = command->getRemoteAddress();
        delete request;
    }
    else if (dynamic_cast<Ipv4SocketCloseCommand *>(ctrl) != 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", IPv4_I_SOCKET_CLOSED);
            auto ctrl = new Ipv4SocketClosedIndication();
            indication->setControlInfo(ctrl);
            indication->addTag<SocketInd>()->setSocketId(socketId);
            send(indication, "transportOut");
        }
        delete request;
    }
    else if (dynamic_cast<Ipv4SocketDestroyCommand *>(ctrl) != 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("Unknown command: '%s' with %s", request->getName(), ctrl->getClassName());
}

Referenced by handleMessageWhenUp().

handleStartOperation()

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

overridevirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    start();
}

handleStopOperation()

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

overridevirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    // TODO stop should send and wait pending packets
    stop();
}

initialize()

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

overrideprotectedvirtual

Reimplemented from inet::OperationalMixin< cSimpleModule >.

{
    OperationalBase::initialize(stage);
 
    if (stage == INITSTAGE_LOCAL) {
        ift.reference(this, "interfaceTableModule", true);
        rt.reference(this, "routingTableModule", true);
        arp.reference(this, "arpModule", true);
        icmp.reference(this, "icmpModule", true);
 
        transportInGateBaseId = gateBaseId("transportIn");
 
        const char *crcModeString = par("crcMode");
        crcMode = parseCrcMode(crcModeString, false);
 
        defaultTimeToLive = par("timeToLive");
        defaultMCTimeToLive = par("multicastTimeToLive");
        fragmentTimeoutTime = par("fragmentTimeout");
        limitedBroadcast = par("limitedBroadcast");
        directBroadcastInterfaces = par("directBroadcastInterfaces").stdstringValue();
 
        directBroadcastInterfaceMatcher.setPattern(directBroadcastInterfaces.c_str(), false, true, false);
 
        curFragmentId = 0;
        lastCheckTime = 0;
 
        numMulticast = numLocalDeliver = numDropped = numUnroutable = numForwarded = 0;
 
        // NetFilter:
        hooks.clear();
        queuedDatagramsForHooks.clear();
 
        pendingPackets.clear();
 
        WATCH(numMulticast);
        WATCH(numLocalDeliver);
        WATCH(numDropped);
        WATCH(numUnroutable);
        WATCH(numForwarded);
        WATCH_MAP(pendingPackets);
        WATCH_MAP(socketIdToSocketDescriptor);
    }
    else if (stage == INITSTAGE_NETWORK_LAYER) {
        cModule *arpModule = check_and_cast<cModule *>(arp.get());
        arpModule->subscribe(IArp::arpResolutionCompletedSignal, this);
        arpModule->subscribe(IArp::arpResolutionFailedSignal, this);
 
        registerService(Protocol::ipv4, gate("transportIn"), gate("transportOut"));
        registerProtocol(Protocol::ipv4, gate("queueOut"), gate("queueIn"));
    }
}

insertCrc()

void inet::Ipv4::insertCrc ( const Ptr< Ipv4Header > &  ipv4Header )

static

{
    CrcMode crcMode = ipv4Header->getCrcMode();
    switch (crcMode) {
        case CRC_DECLARED_CORRECT:
            // if the CRC mode is declared to be correct, then set the CRC to an easily recognizable value
            ipv4Header->setCrc(0xC00D);
            break;
        case CRC_DECLARED_INCORRECT:
            // if the CRC mode is declared to be incorrect, then set the CRC to an easily recognizable value
            ipv4Header->setCrc(0xBAAD);
            break;
        case CRC_COMPUTED: {
            // if the CRC mode is computed, then compute the CRC and set it
            // this computation is delayed after the routing decision, see INetfilter hook
            ipv4Header->setCrc(0x0000); // make sure that the CRC is 0 in the Udp header before computing the CRC
            MemoryOutputStream ipv4HeaderStream;
            Chunk::serialize(ipv4HeaderStream, ipv4Header);
            // compute the CRC
            uint16_t crc = TcpIpChecksum::checksum(ipv4HeaderStream.getData());
            ipv4Header->setCrc(crc);
            break;
        }
        default:
            throw cRuntimeError("Unknown CRC mode: %d", (int)crcMode);
    }
}

Referenced by inet::DscpMarker::markPacket(), inet::PimSm::sendPIMRegisterNull(), and inet::queueing::EcnMarker::setEcn().

isInitializeStage()

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

inlineoverridevirtual

ILifecycle methods.

Implements inet::OperationalMixin< cSimpleModule >.

{ return stage == INITSTAGE_NETWORK_LAYER; }

isModuleStartStage()

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

inlineoverridevirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ return stage == ModuleStartOperation::STAGE_NETWORK_LAYER; }

isModuleStopStage()

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

inlineoverridevirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ return stage == ModuleStopOperation::STAGE_NETWORK_LAYER; }

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

prepareForForwarding()

Packet * inet::Ipv4::prepareForForwarding ( Packet *  packet ) const

protectedvirtual

{
    const auto& ipv4Header = removeNetworkProtocolHeader<Ipv4Header>(packet);
    ipv4Header->setTimeToLive(ipv4Header->getTimeToLive() - 1);
    insertNetworkProtocolHeader(packet, Protocol::ipv4, ipv4Header);
    return packet;
}

Referenced by preroutingFinish().

preroutingFinish()

void inet::Ipv4::preroutingFinish ( Packet *  packet )

protectedvirtual

{
    const NetworkInterface *fromIE = ift->getInterfaceById(packet->getTag<InterfaceInd>()->getInterfaceId());
    Ipv4Address nextHopAddr = getNextHop(packet);
 
    const auto& ipv4Header = packet->peekAtFront<Ipv4Header>();
    ASSERT(ipv4Header);
    Ipv4Address destAddr = ipv4Header->getDestAddress();
 
    // route packet
 
    if (fromIE->isLoopback()) {
        reassembleAndDeliver(packet);
    }
    else if (destAddr.isMulticast()) {
        // check for local delivery
        // Note: multicast routers will receive IGMP datagrams even if their interface is not joined to the group
        if (fromIE->getProtocolData<Ipv4InterfaceData>()->isMemberOfMulticastGroup(destAddr) ||
            (rt->isMulticastForwardingEnabled() && ipv4Header->getProtocolId() == IP_PROT_IGMP))
            reassembleAndDeliver(packet->dup());
        else
            EV_WARN << "Skip local delivery of multicast datagram (input interface not in multicast group)\n";
 
        // don't forward if IP forwarding is off, or if dest address is link-scope
        if (!rt->isMulticastForwardingEnabled()) {
            EV_WARN << "Skip forwarding of multicast datagram (forwarding disabled)\n";
            delete packet;
        }
        else if (destAddr.isLinkLocalMulticast()) {
            EV_WARN << "Skip forwarding of multicast datagram (packet is link-local)\n";
            delete packet;
        }
        else if (ipv4Header->getTimeToLive() <= 1) { // TTL before decrement
            EV_WARN << "Skip forwarding of multicast datagram (TTL reached 0)\n";
            delete packet;
        }
        else
            forwardMulticastPacket(prepareForForwarding(packet));
    }
    else {
        const NetworkInterface *broadcastIE = nullptr;
 
        // check for local delivery; we must accept also packets coming from the interfaces that
        // do not yet have an IP address assigned. This happens during DHCP requests.
        if (rt->isLocalAddress(destAddr) || fromIE->getProtocolData<Ipv4InterfaceData>()->getIPAddress().isUnspecified()) {
            reassembleAndDeliver(packet);
        }
        else if (destAddr.isLimitedBroadcastAddress() || (broadcastIE = rt->findInterfaceByLocalBroadcastAddress(destAddr))) {
            // broadcast datagram on the target subnet if we are a router
            if (broadcastIE && fromIE != broadcastIE && rt->isForwardingEnabled()) {
                if (directBroadcastInterfaceMatcher.matches(broadcastIE->getInterfaceName()) ||
                    directBroadcastInterfaceMatcher.matches(broadcastIE->getInterfaceFullPath().c_str()))
                {
                    auto packetCopy = prepareForForwarding(packet->dup());
                    packetCopy->addTagIfAbsent<InterfaceReq>()->setInterfaceId(broadcastIE->getInterfaceId());
                    packetCopy->addTagIfAbsent<NextHopAddressReq>()->setNextHopAddress(Ipv4Address::ALLONES_ADDRESS);
                    fragmentPostRouting(packetCopy);
                }
                else
                    EV_INFO << "Forwarding of direct broadcast packets is disabled on interface " << broadcastIE->getInterfaceName() << std::endl;
            }
 
            EV_INFO << "Broadcast received\n";
            reassembleAndDeliver(packet);
        }
        else if (!rt->isForwardingEnabled()) {
            EV_WARN << "forwarding off, dropping packet\n";
            numDropped++;
            PacketDropDetails details;
            details.setReason(FORWARDING_DISABLED);
            emit(packetDroppedSignal, packet, &details);
            delete packet;
        }
        else {
            packet->addTagIfAbsent<NextHopAddressReq>()->setNextHopAddress(nextHopAddr);
            routeUnicastPacket(prepareForForwarding(packet));
        }
    }
}

Referenced by handleIncomingDatagram(), and reinjectQueuedDatagram().

reassembleAndDeliver()

void inet::Ipv4::reassembleAndDeliver ( Packet *  packet )

protectedvirtual

Perform reassembly of fragmented datagrams, then send them up to the higher layers using sendToHL().

{
    EV_INFO << "Delivering " << packet << " locally.\n";
 
    const auto& ipv4Header = packet->peekAtFront<Ipv4Header>();
    if (ipv4Header->getSrcAddress().isUnspecified())
        EV_WARN << "Received datagram '" << packet->getName() << "' without source address filled in\n";
 
    // reassemble the packet (if fragmented)
    if (ipv4Header->getFragmentOffset() != 0 || ipv4Header->getMoreFragments()) {
        EV_DETAIL << "Datagram fragment: offset=" << ipv4Header->getFragmentOffset()
                  << ", MORE=" << (ipv4Header->getMoreFragments() ? "true" : "false") << ".\n";
 
        // erase timed out fragments in fragmentation buffer; check every 10 seconds max
        if (simTime() >= lastCheckTime + 10) {
            lastCheckTime = simTime();
            fragbuf.purgeStaleFragments(icmp, simTime() - fragmentTimeoutTime);
        }
 
        packet = fragbuf.addFragment(packet, simTime());
        if (!packet) {
            EV_DETAIL << "No complete datagram yet.\n";
            return;
        }
        if (packet->peekAtFront<Ipv4Header>()->getCrcMode() == CRC_COMPUTED) {
            auto ipv4Header = removeNetworkProtocolHeader<Ipv4Header>(packet);
            setComputedCrc(ipv4Header);
            insertNetworkProtocolHeader(packet, Protocol::ipv4, ipv4Header);
        }
        EV_DETAIL << "This fragment completes the datagram.\n";
    }
 
    if (datagramLocalInHook(packet) == INetfilter::IHook::ACCEPT)
        reassembleAndDeliverFinish(packet);
}

Referenced by preroutingFinish().

reassembleAndDeliverFinish()

void inet::Ipv4::reassembleAndDeliverFinish ( Packet *  packet )

protectedvirtual

{
    auto ipv4HeaderPosition = packet->getFrontOffset();
    const auto& ipv4Header = packet->peekAtFront<Ipv4Header>();
    const Protocol *protocol = ipv4Header->getProtocol();
    auto remoteAddress(ipv4Header->getSrcAddress());
    auto localAddress(ipv4Header->getDestAddress());
    decapsulate(packet);
    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(IPv4_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) {
        delete packet;
    }
    else {
        EV_ERROR << "Transport protocol '" << protocol->getName() << "' not connected, discarding packet\n";
        packet->setFrontOffset(ipv4HeaderPosition);
        const NetworkInterface *fromIE = getSourceInterface(packet);
        sendIcmpError(packet, fromIE ? fromIE->getInterfaceId() : -1, ICMP_DESTINATION_UNREACHABLE, ICMP_DU_PROTOCOL_UNREACHABLE);
    }
}

Referenced by reassembleAndDeliver(), and reinjectQueuedDatagram().

receiveSignal()

void inet::Ipv4::receiveSignal ( cComponent *  source, simsignal_t  signalID, cObject *  obj, cObject *  details  )

overridevirtual

cListener method

{
    Enter_Method("%s", cComponent::getSignalName(signalID));
 
    if (signalID == IArp::arpResolutionCompletedSignal) {
        arpResolutionCompleted(check_and_cast<IArp::Notification *>(obj));
    }
    if (signalID == IArp::arpResolutionFailedSignal) {
        arpResolutionTimedOut(check_and_cast<IArp::Notification *>(obj));
    }
}

refreshDisplay()

void inet::Ipv4::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 (numMulticast > 0)
        sprintf(buf + strlen(buf), "mcast:%d ", numMulticast);
    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::Ipv4::registerHook ( int  priority, INetfilter::IHook *  hook  )

overridevirtual

registers a Hook to be executed during datagram processing

Reimplemented from inet::NetfilterBase.

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

reinjectQueuedDatagram()

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

overridevirtual

re-injects a previously queued datagram

Implements inet::INetfilter.

{
    Enter_Method("reinjectDatagram()");
    for (auto iter = queuedDatagramsForHooks.begin(); iter != queuedDatagramsForHooks.end(); iter++) {
        if (iter->packet == packet) {
            auto *qPacket = iter->packet;
            take(qPacket);
            switch (iter->hookType) {
                case INetfilter::IHook::LOCALOUT:
                    datagramLocalOut(qPacket);
                    break;
 
                case INetfilter::IHook::PREROUTING:
                    preroutingFinish(qPacket);
                    break;
 
                case INetfilter::IHook::POSTROUTING:
                    fragmentAndSend(qPacket);
                    break;
 
                case INetfilter::IHook::LOCALIN:
                    reassembleAndDeliverFinish(qPacket);
                    break;
 
                case INetfilter::IHook::FORWARD:
                    routeUnicastPacketFinish(qPacket);
                    break;
 
                default:
                    throw cRuntimeError("Unknown hook ID: %d", (int)(iter->hookType));
                    break;
            }
            queuedDatagramsForHooks.erase(iter);
            return;
        }
    }
}

resolveNextHopMacAddress()

MacAddress inet::Ipv4::resolveNextHopMacAddress ( cPacket *  packet, Ipv4Address  nextHopAddr, const NetworkInterface *  destIE  )

protectedvirtual

{
    if (nextHopAddr.isLimitedBroadcastAddress() || nextHopAddr == destIE->getProtocolData<Ipv4InterfaceData>()->getNetworkBroadcastAddress()) {
        EV_DETAIL << "destination address is broadcast, sending packet to broadcast MAC address\n";
        return MacAddress::BROADCAST_ADDRESS;
    }
 
    if (nextHopAddr.isMulticast()) {
        MacAddress macAddr = nextHopAddr.mapToMulticastMacAddress();
        EV_DETAIL << "destination address is multicast, sending packet to MAC address " << macAddr << "\n";
        return macAddr;
    }
 
    return arp->resolveL3Address(nextHopAddr, destIE);
}

Referenced by sendDatagramToOutput().

routeLocalBroadcastPacket()

void inet::Ipv4::routeLocalBroadcastPacket ( Packet *  packet )

protectedvirtual

Broadcasts the datagram on the specified interface.

When destIE is nullptr, the datagram is broadcasted on each interface.

{
    const auto& interfaceReq = packet->findTag<InterfaceReq>();
    const NetworkInterface *destIE = interfaceReq != nullptr ? ift->getInterfaceById(interfaceReq->getInterfaceId()) : nullptr;
    // The destination address is 255.255.255.255 or local subnet broadcast address.
    // We always use 255.255.255.255 as nextHopAddress, because it is recognized by ARP,
    // and mapped to the broadcast MAC address.
    if (destIE != nullptr) {
        packet->addTagIfAbsent<InterfaceReq>()->setInterfaceId(destIE->getInterfaceId()); // KLUDGE is it needed?
        packet->addTagIfAbsent<NextHopAddressReq>()->setNextHopAddress(Ipv4Address::ALLONES_ADDRESS);
        fragmentPostRouting(packet);
    }
    else if (limitedBroadcast) {
        auto destAddr = packet->peekAtFront<Ipv4Header>()->getDestAddress();
        // forward to each matching interfaces including loopback
        for (int i = 0; i < ift->getNumInterfaces(); i++) {
            const NetworkInterface *ie = ift->getInterface(i);
            if (!destAddr.isLimitedBroadcastAddress()) {
                Ipv4Address interfaceAddr = ie->getProtocolData<Ipv4InterfaceData>()->getIPAddress();
                Ipv4Address broadcastAddr = interfaceAddr.makeBroadcastAddress(ie->getProtocolData<Ipv4InterfaceData>()->getNetmask());
                if (destAddr != broadcastAddr)
                    continue;
            }
            auto packetCopy = packet->dup();
            packetCopy->addTagIfAbsent<InterfaceReq>()->setInterfaceId(ie->getInterfaceId());
            packetCopy->addTagIfAbsent<NextHopAddressReq>()->setNextHopAddress(Ipv4Address::ALLONES_ADDRESS);
            fragmentPostRouting(packetCopy);
        }
        delete packet;
    }
    else {
        numDropped++;
        PacketDropDetails details;
        details.setReason(NO_INTERFACE_FOUND);
        emit(packetDroppedSignal, packet, &details);
        delete packet;
    }
}

Referenced by datagramLocalOut().

routeUnicastPacket()

void inet::Ipv4::routeUnicastPacket ( Packet *  packet )

protectedvirtual

Performs unicast routing.

Based on the routing decision, it sends the datagram through the outgoing interface.

{
    const NetworkInterface *fromIE = getSourceInterface(packet);
    const NetworkInterface *destIE = getDestInterface(packet);
    Ipv4Address nextHopAddress = getNextHop(packet);
 
    const auto& ipv4Header = packet->peekAtFront<Ipv4Header>();
    Ipv4Address destAddr = ipv4Header->getDestAddress();
    EV_INFO << "Routing " << packet << " with destination = " << destAddr << ", ";
 
    // if output port was explicitly requested, use that, otherwise use Ipv4 routing
    if (destIE) {
        EV_DETAIL << "using manually specified output interface " << destIE->getInterfaceName() << "\n";
        // and nextHopAddr remains unspecified
        if (!nextHopAddress.isUnspecified()) {
            // do nothing, next hop address already specified
        }
        // special case ICMP reply
        else if (destIE->isBroadcast()) {
            // if the interface is broadcast we must search the next hop
            const Ipv4Route *re = rt->findBestMatchingRoute(destAddr);
            if (re && re->getInterface() == destIE) {
                packet->addTagIfAbsent<NextHopAddressReq>()->setNextHopAddress(re->getGateway());
            }
        }
    }
    else {
        // use Ipv4 routing (lookup in routing table)
        const Ipv4Route *re = rt->findBestMatchingRoute(destAddr);
        if (re) {
            destIE = re->getInterface();
            packet->addTagIfAbsent<InterfaceReq>()->setInterfaceId(destIE->getInterfaceId());
            packet->addTagIfAbsent<NextHopAddressReq>()->setNextHopAddress(re->getGateway());
        }
    }
 
    if (!destIE) { // no route found
        EV_WARN << "unroutable, sending ICMP_DESTINATION_UNREACHABLE, dropping packet\n";
        numUnroutable++;
        PacketDropDetails details;
        details.setReason(NO_ROUTE_FOUND);
        emit(packetDroppedSignal, packet, &details);
        sendIcmpError(packet, fromIE ? fromIE->getInterfaceId() : -1, ICMP_DESTINATION_UNREACHABLE, 0);
    }
    else { // fragment and send
        if (fromIE != nullptr) {
            if (datagramForwardHook(packet) != INetfilter::IHook::ACCEPT)
                return;
        }
 
        routeUnicastPacketFinish(packet);
    }
}

Referenced by datagramLocalOut(), and preroutingFinish().

routeUnicastPacketFinish()

void inet::Ipv4::routeUnicastPacketFinish ( Packet *  packet )

protected

{
    EV_INFO << "output interface = " << getDestInterface(packet)->getInterfaceName() << ", next hop address = " << getNextHop(packet) << "\n";
    numForwarded++;
    fragmentPostRouting(packet);
}

Referenced by reinjectQueuedDatagram(), and routeUnicastPacket().

sendDatagramToOutput()

void inet::Ipv4::sendDatagramToOutput ( Packet *  packet )

protectedvirtual

Send datagram on the given interface.

{
    const NetworkInterface *ie = ift->getInterfaceById(packet->getTag<InterfaceReq>()->getInterfaceId());
    auto nextHopAddressReq = packet->removeTag<NextHopAddressReq>();
    Ipv4Address nextHopAddr = nextHopAddressReq->getNextHopAddress().toIpv4();
    if (!ie->isBroadcast() || ie->getMacAddress().isUnspecified()) // we can't do ARP
        sendPacketToNIC(packet);
    else {
        MacAddress nextHopMacAddr = resolveNextHopMacAddress(packet, nextHopAddr, ie);
        if (nextHopMacAddr.isUnspecified()) {
            EV_INFO << "Pending " << packet << " to ARP resolution.\n";
            pendingPackets[nextHopAddr].insert(packet);
        }
        else {
            ASSERT2(!containsKey(pendingPackets, nextHopAddr), "Ipv4-ARP error: nextHopAddr found in ARP table, but Ipv4 queue for nextHopAddr not empty");
            packet->addTagIfAbsent<MacAddressReq>()->setDestAddress(nextHopMacAddr);
            sendPacketToNIC(packet);
        }
    }
}

Referenced by fragmentAndSend().

sendIcmpError()

void inet::Ipv4::sendIcmpError ( Packet *  packet, int  inputInterfaceId, IcmpType  type, IcmpCode  code  )

protectedvirtual

{
    icmp->sendErrorMessage(origPacket, inputInterfaceId, type, code);
    delete origPacket;
}

Referenced by fragmentAndSend(), handleIncomingDatagram(), reassembleAndDeliverFinish(), and routeUnicastPacket().

sendPacketToNIC()

void inet::Ipv4::sendPacketToNIC ( Packet *  packet )

protectedvirtual

{
    auto networkInterface = ift->getInterfaceById(packet->getTag<InterfaceReq>()->getInterfaceId());
    EV_INFO << "Sending " << packet << " to output interface = " << networkInterface->getInterfaceName() << ".\n";
    packet->addTagIfAbsent<PacketProtocolTag>()->setProtocol(&Protocol::ipv4);
    packet->addTagIfAbsent<DispatchProtocolInd>()->setProtocol(&Protocol::ipv4);
    auto networkInterfaceProtocol = networkInterface->getProtocol();
    auto dispatchProtocol = networkInterfaceProtocol;
    if (auto encapsulationProtocolReq = packet->findTagForUpdate<EncapsulationProtocolReq>()) {
        dispatchProtocol = encapsulationProtocolReq->getProtocol(0);
        encapsulationProtocolReq->eraseProtocol(0);
        encapsulationProtocolReq->insertProtocol(encapsulationProtocolReq->getProtocolArraySize(), networkInterfaceProtocol);
    }
    if (dispatchProtocol == nullptr)
        packet->removeTagIfPresent<DispatchProtocolReq>();
    else
        packet->addTagIfAbsent<DispatchProtocolReq>()->setProtocol(dispatchProtocol);
    ASSERT(packet->findTag<InterfaceReq>() != nullptr);
    send(packet, "queueOut");
}

Referenced by arpResolutionCompleted(), and sendDatagramToOutput().

setComputedCrc()

void inet::Ipv4::setComputedCrc ( Ptr< Ipv4Header > &  ipv4Header )

protected

{
    ASSERT(crcMode == CRC_COMPUTED);
    ipv4Header->setCrc(0);
    MemoryOutputStream ipv4HeaderStream;
    Chunk::serialize(ipv4HeaderStream, ipv4Header);
    // compute the CRC
    uint16_t crc = TcpIpChecksum::checksum(ipv4HeaderStream.getData());
    ipv4Header->setCrc(crc);
}

Referenced by fragmentAndSend(), and reassembleAndDeliver().

start()

void inet::Ipv4::start ( )

protectedvirtual

{
}

Referenced by handleStartOperation().

stop()

void inet::Ipv4::stop ( )

protectedvirtual

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

Referenced by handleCrashOperation(), and handleStopOperation().

unregisterHook()

void inet::Ipv4::unregisterHook ( INetfilter::IHook *  hook )

overridevirtual

unregisters a Hook to be executed during datagram processing

Reimplemented from inet::NetfilterBase.

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

verifyCrc()

bool inet::Ipv4::verifyCrc ( const Ptr< const Ipv4Header > &  ipv4Header )

protected

{
    switch (ipv4Header->getCrcMode()) {
        case CRC_DECLARED_CORRECT: {
            // if the CRC mode is declared to be correct, then the check passes if and only if the chunk is correct
            return ipv4Header->isCorrect();
        }
        case CRC_DECLARED_INCORRECT:
            // if the CRC mode is declared to be incorrect, then the check fails
            return false;
        case CRC_COMPUTED: {
            if (ipv4Header->isCorrect()) {
                // compute the CRC, the check passes if the result is 0xFFFF (includes the received CRC) and the chunks are correct
                MemoryOutputStream ipv4HeaderStream;
                Chunk::serialize(ipv4HeaderStream, ipv4Header);
                uint16_t computedCrc = TcpIpChecksum::checksum(ipv4HeaderStream.getData());
                return computedCrc == 0;
            }
            else {
                return false;
            }
        }
        default:
            throw cRuntimeError("Unknown CRC mode");
    }
}

Referenced by handleIncomingDatagram().

Member Data Documentation

arp

ModuleRefByPar<IArp> inet::Ipv4::arp

protected

Referenced by initialize(), and resolveNextHopMacAddress().

crcMode

CrcMode inet::Ipv4::crcMode = CRC_MODE_UNDEFINED

protected

Referenced by encapsulate(), fragmentAndSend(), initialize(), insertCrc(), and setComputedCrc().

curFragmentId

uint16_t inet::Ipv4::curFragmentId = -1

protected

Referenced by encapsulate(), and initialize().

defaultMCTimeToLive

int inet::Ipv4::defaultMCTimeToLive = -1

protected

Referenced by encapsulate(), and initialize().

defaultTimeToLive

int inet::Ipv4::defaultTimeToLive = -1

protected

Referenced by encapsulate(), and initialize().

directBroadcastInterfaceMatcher

cPatternMatcher inet::Ipv4::directBroadcastInterfaceMatcher

protected

Referenced by initialize(), and preroutingFinish().

directBroadcastInterfaces

std::string inet::Ipv4::directBroadcastInterfaces = ""

protected

Referenced by initialize().

fragbuf

Ipv4FragBuf inet::Ipv4::fragbuf

protected

Referenced by flush(), and reassembleAndDeliver().

fragmentTimeoutTime

simtime_t inet::Ipv4::fragmentTimeoutTime

protected

Referenced by initialize(), and reassembleAndDeliver().

icmp

ModuleRefByPar<Icmp> inet::Ipv4::icmp

protected

ift

ModuleRefByPar<IInterfaceTable> inet::Ipv4::ift

protected

Referenced by datagramLocalOut(), determineOutgoingInterfaceForMulticastDatagram(), forwardMulticastPacket(), fragmentAndSend(), fragmentPostRouting(), getDestInterface(), getSourceInterface(), handlePacketFromHL(), initialize(), preroutingFinish(), routeLocalBroadcastPacket(), sendDatagramToOutput(), and sendPacketToNIC().

lastCheckTime

simtime_t inet::Ipv4::lastCheckTime

protected

Referenced by initialize(), and reassembleAndDeliver().

limitedBroadcast

bool inet::Ipv4::limitedBroadcast = false

protected

Referenced by initialize(), and routeLocalBroadcastPacket().

numDropped

int inet::Ipv4::numDropped = 0

protected

Referenced by forwardMulticastPacket(), fragmentAndSend(), handlePacketFromHL(), initialize(), preroutingFinish(), refreshDisplay(), and routeLocalBroadcastPacket().

numForwarded

int inet::Ipv4::numForwarded = 0

protected

Referenced by forwardMulticastPacket(), initialize(), refreshDisplay(), and routeUnicastPacketFinish().

numLocalDeliver

int inet::Ipv4::numLocalDeliver = 0

protected

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

numMulticast

int inet::Ipv4::numMulticast = 0

protected

Referenced by datagramLocalOut(), forwardMulticastPacket(), initialize(), and refreshDisplay().

numUnroutable

int inet::Ipv4::numUnroutable = 0

protected

Referenced by datagramLocalOut(), forwardMulticastPacket(), initialize(), refreshDisplay(), and routeUnicastPacket().

pendingPackets

PendingPackets inet::Ipv4::pendingPackets

protected

Referenced by arpResolutionCompleted(), arpResolutionTimedOut(), flush(), initialize(), and sendDatagramToOutput().

queuedDatagramsForHooks

DatagramQueueForHooks inet::Ipv4::queuedDatagramsForHooks

protected

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

rt

ModuleRefByPar<IIpv4RoutingTable> inet::Ipv4::rt

protected

Referenced by datagramLocalOut(), determineOutgoingInterfaceForMulticastDatagram(), encapsulate(), forwardMulticastPacket(), getShortestPathInterfaceToSource(), initialize(), preroutingFinish(), and routeUnicastPacket().

socketIdToSocketDescriptor

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

protected

Referenced by handleRequest(), initialize(), reassembleAndDeliverFinish(), stop(), and ~Ipv4().

transportInGateBaseId

int inet::Ipv4::transportInGateBaseId = -1

protected

Referenced by initialize().

upperProtocols

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

protected

Referenced by handleRegisterProtocol(), and reassembleAndDeliverFinish().

---

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

• Ipv4.h
• Ipv4.cc