inet::Ipv4Encap Class Reference

#include <Ipv4Encap.h>

Inheritance diagram for inet::Ipv4Encap:

Classes
struct	SocketDescriptor

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessage (cMessage *msg) override
virtual void	handleRequest (Request *request)
virtual void	encapsulate (Packet *packet)
virtual void	decapsulate (Packet *packet)

Protected Attributes
CrcMode	crcMode = CRC_MODE_UNDEFINED
int	defaultTimeToLive = -1
int	defaultMCTimeToLive = -1
std::set< const Protocol * >	upperProtocols
std::map< int, SocketDescriptor * >	socketIdToSocketDescriptor

Member Function Documentation

decapsulate()

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

protectedvirtual

{
    // 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 handleMessage().

encapsulate()

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

protectedvirtual

{
    const auto& ipv4Header = makeShared<Ipv4Header>();
 
    auto l3AddressReq = transportPacket->removeTag<L3AddressReq>();
    Ipv4Address src = l3AddressReq->getSrcAddress().toIpv4();
    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())
        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");
    }
    if (auto& dscpReq = transportPacket->removeTagIfPresent<DscpReq>())
        ipv4Header->setDscp(dscpReq->getDifferentiatedServicesCodePoint());
    if (auto& ecnReq = transportPacket->removeTagIfPresent<EcnReq>())
        ipv4Header->setEcn(ecnReq->getExplicitCongestionNotification());
 
    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);
    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: {
            MemoryOutputStream ipv4HeaderStream;
            Chunk::serialize(ipv4HeaderStream, ipv4Header);
            // compute the CRC
            uint16_t crc = TcpIpChecksum::checksum(ipv4HeaderStream.getData());
            ipv4Header->setCrc(crc);
            // 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 handleMessage().

handleMessage()

void inet::Ipv4Encap::handleMessage ( cMessage *  msg )

overrideprotectedvirtual

{
    if (auto request = dynamic_cast<Request *>(msg))
        handleRequest(request);
    else if (msg->getArrivalGate()->isName("upperLayerIn")) {
        auto packet = check_and_cast<Packet *>(msg);
        EV << "Encapsulating\n";
        encapsulate(packet);
        EV << "SEnding\n";
        send(packet, "lowerLayerOut");
    }
    else {
        auto packet = check_and_cast<Packet *>(msg);
        auto ipv4HeaderPosition = packet->getFrontOffset();
        const auto& ipv4Header = packet->peekAtFront<Ipv4Header>();
        const Protocol *protocol = ipv4Header->getProtocol();
        auto remoteAddress(ipv4Header->getSrcAddress());
        auto localAddress(ipv4Header->getDestAddress());
        EV << "Receiving\n";
        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->addTagIfAbsent<SocketInd>()->setSocketId(elem.second->socketId);
                EV_INFO << "Passing up to socket " << elem.second->socketId << "\n";
//                emit(packetSentToUpperSignal, packetCopy);
                send(packetCopy, "upperLayerOut");
                hasSocket = true;
            }
        }
        if (contains(upperProtocols, protocol)) {
            EV_INFO << "Passing up to protocol " << protocol << "\n";
//            emit(packetSentToUpperSignal, packet);
            send(packet, "upperLayerOut");
        }
        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);
        }
        send(packet, "upperLayerOut");
    }
}

handleRequest()

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

protectedvirtual

{
    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 = 0;
        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 handleMessage().

initialize()

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

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        defaultTimeToLive = 16; // par("timeToLive");
        defaultMCTimeToLive = 16; // par("multicastTimeToLive");
        crcMode = CRC_COMPUTED;
    }
    else if (stage == INITSTAGE_NETWORK_LAYER) {
        registerService(Protocol::ipv4, gate("upperLayerIn"), gate("upperLayerOut"));
    }
}

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

Member Data Documentation

crcMode

CrcMode inet::Ipv4Encap::crcMode = CRC_MODE_UNDEFINED

protected

Referenced by encapsulate(), and initialize().

defaultMCTimeToLive

int inet::Ipv4Encap::defaultMCTimeToLive = -1

protected

Referenced by encapsulate(), and initialize().

defaultTimeToLive

int inet::Ipv4Encap::defaultTimeToLive = -1

protected

Referenced by encapsulate(), and initialize().

socketIdToSocketDescriptor

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

protected

Referenced by handleMessage(), and handleRequest().

upperProtocols

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

protected

Referenced by handleMessage().

---

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

• Ipv4Encap.h
• Ipv4Encap.cc