GtpTunnel.h Source File¶

Simu5G: GtpTunnel.h Source File
Simu5G
//
//                  Simu5G
//
// Copyright (C) 2026 Andras Varga (OpenSim Ltd)
//
// This file is part of a software released under the license included in file
// "license.pdf". Please read LICENSE and README files before using it.
// The above files and the present reference are part of the software itself,
// and cannot be removed from it.
//
 
#ifndef _GTP_TUNNEL_H_
#define _GTP_TUNNEL_H_
 
#include <map>
#include <ostream>
 
#include <inet/common/packet/Packet.h>
#include <inet/networklayer/common/L3Address.h>
 
#include "simu5g/common/LteTypes.h"
#include "simu5g/common/SessionTag_m.h"
#include "simu5g/corenetwork/gtp/GtpUserMsg_m.h"
 
namespace simu5g {
struct FTeid
{
    inet::L3Address address;
    Teid teid = TEID_NONE;
 
    bool isSet() const { return teid != TEID_NONE; }
};
 
inline std::ostream& operator<<(std::ostream& os, const FTeid& fteid)
{
    return os << fteid.address.str() << "/teid=" << fteid.teid;
}
struct SessionRef
{
    MacNodeId lteNodeId = NODEID_NONE;
    MacNodeId nrNodeId = NODEID_NONE;
    SessionId id = SessionId(0);
};
 
inline bool operator<(const SessionRef& a, const SessionRef& b)
{
    if (a.lteNodeId != b.lteNodeId)
        return a.lteNodeId < b.lteNodeId;
    if (a.nrNodeId != b.nrNodeId)
        return a.nrNodeId < b.nrNodeId;
    return a.id < b.id;
}
 
inline bool operator==(const SessionRef& a, const SessionRef& b)
{
    return a.lteNodeId == b.lteNodeId && a.nrNodeId == b.nrNodeId && a.id == b.id;
}
 
inline std::ostream& operator<<(std::ostream& os, const SessionRef& session)
{
    return os << "session " << session.id << " of UE " << session.lteNodeId << "/" << session.nrNodeId;
}
struct AddressPrefix
{
    inet::L3Address prefix;
    int length = 0;
 
    AddressPrefix() {}
    AddressPrefix(const inet::L3Address& prefix, int length) : prefix(prefix), length(length) {}
    bool matches(const inet::L3Address& address) const { return address.getType() == prefix.getType() && address.matches(prefix, length); }
};
 
inline std::ostream& operator<<(std::ostream& os, const AddressPrefix& p)
{
    return os << p.prefix.str() << "/" << p.length;
}
struct TunnelSession
{
    SessionRef ref;
    SessionType type = IP_V4;
};
inline void attachSessionTag(inet::Packet *datagram, const TunnelSession& session)
{
    auto tag = datagram->addTag<SessionTag>();
    tag->setSessionId(session.ref.id);
    tag->setLteNodeId(session.ref.lteNodeId);
    tag->setNrNodeId(session.ref.nrNodeId);
    tag->setSessionType(session.type);
}
struct N6Tunnel
{
    inet::L3Address sessionAddress;
    int localPort = -1;
    inet::L3Address serverAddress;
    int serverPort = -1;
};
 
inline std::ostream& operator<<(std::ostream& os, const N6Tunnel& tunnel)
{
    return os << "[" << tunnel.sessionAddress.str() << "]:" << tunnel.localPort << " <-> [" << tunnel.serverAddress.str() << "]:" << tunnel.serverPort;
}
struct UplinkTunnels
{
    FTeid anchor;
    std::map<inet::L3Address, Teid> mecHosts;
    bool toUpf = false;   // the anchor is a UPF (5GC): the G-PDUs carry a PDU Session Container
};
struct SessionResource
{
    SessionRef ref;
    SessionType type = IP_V4;
    UplinkTunnels uplink;
    FTeid dl;
};
inline inet::Ptr<GtpUserMsg> makeGtpUserHeader(Teid teid, Qfi qfi, PduSessionContainerType container, inet::B tpduLength)
{
    auto header = inet::makeShared<GtpUserMsg>();
    header->setTeid(teid);
    header->setQfi(qfi);
    header->setPduSessionContainer(container);
    inet::B headerLength = gtpUserHeaderLength(container);
    header->setChunkLength(headerLength);
    header->setLengthField((headerLength - inet::B(8) + tpduLength).get());
    return header;
}
 
} //namespace
 
#endif