GtpUser

simple module

This module implements a simplified version of the user plane of the GPRS Tunneling Protocol (GTP). On one hand, this module encapsulates incoming IP datagrams into GTP packets and sends them to the tunnel destination endpoint (GTP operates on top of UDP). The destination endpoint is identified by utilizing information from the TrafficFlowFilter module. On the other hand, when this module receives GTP packets from a tunnel source endpoint, it decapsulates the included IP datagram and sends it to the intended destination according to normal IP forwarding. This module is used by all entities that need to communicate within the cellular core network, such as eNodeB, gNodeB, PgwStandard, Upf, and MECHost modules.

Used in compound modules

Name	Type	Description
eNodeB	compound module	This module models an evolved Node B (eNB) of a 4G LTE network. It is a specialized device equipped with a Network Interface Card (NIC) that enables communication with the Ue devices connected to it. It serves as an access point that routes packets between the UEs and the 4G Core Network. Packets arriving from the UEs are tunneled to the appropriate next hop in the core network (e.g., the PDN Gateway, PGW) using the GPRS Tunneling Protocol (GTP). Conversely, packets received from the core network are detunneled and sent to the appropriate destination UE. In addition to the 4G NIC, this compound module includes a configurable number of wired interfaces to connect with routers of the core network or directly to the PgwStandard module, which serves as the IP module to perform forwarding, and the GtpUser module that handles GTP (de)tunneling. The latter utilizes the TrafficFlowFilter module to classify incoming packets and determine the next hop. Furthermore, it features a configurable number of LteX2App modules to facilitate peer-to-peer communications with other eNodeBs within the same LTE network.
PgwStandard	compound module	This module implements a simplified model of the EPC PDN Gateway (P-GW) of a 4G LTE network. It serves as the entry point to the core network of an LTE network, thus bridging it to the rest of the Internet. Packets arriving from the Internet are tunneled to the appropriate next hop in the core network (e.g., the eNodeB that will transmit the packet to the destination User Equipment through the radio access network) using the GPRS Tunneling Protocol (GTP). Conversely, packets received from the core network are detunneled and sent to the Internet (e.g., towards a remote server). To accomplish this, it utilizes a GtpUser module that handles GTP (de)tunneling, along with the TrafficFlowFilter module, which classifies incoming packets.
Upf	compound module	Implements a 5G Core User Plane Function (UPF) module.

Parameters

Name	Type	Default value	Description
binderModule	string	"binder"
interfaceTableModule	string		path to the InterfaceTable module
ipOutInterface	string	""	optional: manual specification of outgoing interface for received IP
localPort	int	31
tunnelPeerPort	int	31
gateway	string	""	optional

Properties

Name	Value	Description
display	i=block/tunnel

Gates

Name	Direction	Size	Description
socketOut	output
socketIn	input
trafficFlowFilterGate	input
pppGate	output

Source code

//
// This module implements a simplified version of the user plane of the GPRS Tunneling
// Protocol (GTP). On one hand, this module encapsulates incoming IP datagrams into GTP
// packets and sends them to the tunnel destination endpoint (GTP operates on top of
// UDP). The destination endpoint is identified by utilizing information from the
// ~TrafficFlowFilter module. On the other hand, when this module receives GTP packets
// from a tunnel source endpoint, it decapsulates the included IP datagram and sends it
// to the intended destination according to normal IP forwarding.
// This module is used by all entities that need to communicate within the cellular core
// network, such as ~eNodeB, ~gNodeB, ~PgwStandard, ~Upf, and ~MECHost modules.
//
simple GtpUser
{
    parameters:
        string binderModule = default("binder");
        string interfaceTableModule;            // path to the InterfaceTable module
        string ipOutInterface = default("");    // optional: manual specification of outgoing interface for received IP
        int localPort = default(31);
        int tunnelPeerPort = default(31);
        string gateway = default("");			// optional

        @display("i=block/tunnel");

    gates:
        output socketOut;
        input socketIn;

        input trafficFlowFilterGate;
        output pppGate;
}

File: src/corenetwork/gtp/GtpUser.ned