Attachment #3022 for bug #2312

View | Details | Raw Unified | Return to bug 2312
Collapse All | Expand All

(-)a/AUTHORS (+1 lines)

Lines 155-160	Link Here

155

Michele Polese (michele.polese@gmail.com)

155

Michele Polese (michele.polese@gmail.com)

156

Ovidiu Poncea (ovidiu.poncea@cs.pub.ro)

156

Ovidiu Poncea (ovidiu.poncea@cs.pub.ro)

157

Vikas Pushkar (vikaskupushkar@gmail.com)

157

Vikas Pushkar (vikaskupushkar@gmail.com)

158

Manoj Kumar Rana (manoj24.rana@gmail.com)

158

Andrea Ranieri (andreran@uno.it)

159

Andrea Ranieri (andreran@uno.it)

159

Bruno Ranieri (Yrrsinn@googlemail.com)

160

Bruno Ranieri (Yrrsinn@googlemail.com)

160

Deepti Rajagopal (deeptir96@gmail.com)

161

Deepti Rajagopal (deeptir96@gmail.com)

(-)a/CHANGES.html (+1 lines)

Lines 56-61	Link Here

<ul>

<ul>

  <li> When deserializing Packet contents, <b>Header::Deserialize (Buffer::Iterator start)</b> and <b>Trailer::Deserialize (Buffer::Iterator start)</b> can not successfully deserialize variable-length headers and trailers.  New variants of these methods that also include an 'end' parameter are now provided.</li>

  <li> When deserializing Packet contents, <b>Header::Deserialize (Buffer::Iterator start)</b> and <b>Trailer::Deserialize (Buffer::Iterator start)</b> can not successfully deserialize variable-length headers and trailers.  New variants of these methods that also include an 'end' parameter are now provided.</li>

  <li> Ipv[4,6]AddressGenerator can now check if an address is allocated (<b>Ipv[4,6]AddressGenerator::IsAddressAllocated</b>) or a network has some allocated address (<b>Ipv[4,6]AddressGenerator::IsNetworkAllocated</b>).</li>

  <li> Ipv[4,6]AddressGenerator can now check if an address is allocated (<b>Ipv[4,6]AddressGenerator::IsAddressAllocated</b>) or a network has some allocated address (<b>Ipv[4,6]AddressGenerator::IsNetworkAllocated</b>).</li>

  <li> LTE UEs can now use IPv6 to send and receive traffic.

</ul>

</ul>

<h2>Changes to existing API:</h2>

<h2>Changes to existing API:</h2>

<ul>

<ul>

(-)a/RELEASE_NOTES (+2 lines)

Lines 28-36	Link Here

- (lr-wpan) Extended addressing mode is now supported.

- (lr-wpan) Extended addressing mode is now supported.

- (tcp) Implemented the core functionality of TCP Pacing.

- (tcp) Implemented the core functionality of TCP Pacing.

- (internet) Ipv[4,6]AddressGenerator can now check if an address or a network is allocated.

- (internet) Ipv[4,6]AddressGenerator can now check if an address or a network is allocated.

- (lte) UEs can now use IPv6 to send and receive traffic.

Bugs fixed

Bugs fixed

----------

----------

- Bug 2312 - IPv6 support for LTE

- Bug 2505 - network:  Avoid asserts in Header/Trailer deserialization

- Bug 2505 - network:  Avoid asserts in Header/Trailer deserialization

- Bug 2653 - tcp: Avoid saving smaller TS in case of packet reordering

- Bug 2653 - tcp: Avoid saving smaller TS in case of packet reordering

- Bug 2764 - wifi: WifiSpectrumModelId doesn't distinguish 11ax from legacy

- Bug 2764 - wifi: WifiSpectrumModelId doesn't distinguish 11ax from legacy

(-)a/src/lte/doc/source/lte-design.rst (-10 / +16 lines)

Lines 120-126	Link Here

120

121

The following design choices have been made for the EPC model:

121

The following design choices have been made for the EPC model:

122

123

 #. The only Packet Data Network (PDN) type supported is IPv4.

123

 #. The Packet Data Network (PDN) type supported is both IPv4 and IPv6.

124

 #. The SGW and PGW functional entities are implemented within a single

124

 #. The SGW and PGW functional entities are implemented within a single

125

    node, which is hence referred to as the SGW/PGW node.

125

    node, which is hence referred to as the SGW/PGW node.

126

 #. The scenarios with inter-SGW mobility are not of interests. Hence, a

126

 #. The scenarios with inter-SGW mobility are not of interests. Hence, a

Lines 3098-3106	Link Here

3098

IP networking. The first one is the end-to-end layer, which provides end-to-end

3098

IP networking. The first one is the end-to-end layer, which provides end-to-end

3099

connectivity to the users; this layers involves the UEs, the PGW and

3099

connectivity to the users; this layers involves the UEs, the PGW and

3100

the remote host (including eventual internet routers and hosts in

3100

the remote host (including eventual internet routers and hosts in

3101

between), but does not involve the eNB. By default, UEs are assigned a public IPv4 address in the 7.0.0.0/8

3101

between), but does not involve the eNB. In this version of LTE, the EPC

3102

network, and the PGW gets the address 7.0.0.1, which is used by all

3102

supports both IPv4 and IPv6 type users. The 3GPP unique 64 bit IPv6 prefix

3103

UEs as the gateway to reach the internet.

3103

allocation process for each UE and PGW is followed here. Each EPC is assigned

3104

an unique 16 bit IPv4 and a 48 bit IPv6 network address from the pool of

3105

7.0.0.0/8 and 7777:f00d::/32 respectively. In the end-to-end IP connection

3106

between UE and PGW, all addresses are configured using these prefixes.

3107

The PGW's address is used by all UEs as the gateway to reach the internet.

3104

3108

3105

The second layer of IP networking is the EPC local area network. This

3109

The second layer of IP networking is the EPC local area network. This

3106

involves all eNB nodes and the SGW/PGW node. This network is

3110

involves all eNB nodes and the SGW/PGW node. This network is

Lines 3126-3142	Link Here

3126

3130

3127

To begin with, we consider the case of the downlink, which is depicted

3131

To begin with, we consider the case of the downlink, which is depicted

3128

in Figure :ref:`fig-epc-data-flow-dl`.

3132

in Figure :ref:`fig-epc-data-flow-dl`.

3129

Downlink Ipv4 packets are generated from a generic remote host, and

3133

Downlink IPv4/IPv6 packets are generated from a generic remote host, and

3130

addressed to one of the UE device. Internet routing will take care of

3134

addressed to one of the UE device. Internet routing will take care of

3131

forwarding the packet to the generic NetDevice of the SGW/PGW node

3135

forwarding the packet to the generic NetDevice of the SGW/PGW node

3132

which is connected to the internet (this is the Gi interface according

3136

which is connected to the internet (this is the Gi interface according

3133

to 3GPP terminology). The SGW/PGW has a VirtualNetDevice which is

3137

to 3GPP terminology). The SGW/PGW has a VirtualNetDevice which is

3134

assigned the gateway IP address of the UE subnet; hence, static

3138

assigned the base IPv4 address of the EPC network; hence, static

3135

routing rules will cause the incoming packet from the internet to be

3139

routing rules will cause the incoming packet from the internet to be

3136

routed through this VirtualNetDevice. Such device starts the

3140

routed through this VirtualNetDevice. In case of IPv6 address as destination,

3137

GTP/UDP/IP tunneling procedure, by forwarding the packet to a

3141

a manual route towards the VirtualNetDevice is inserted in the routing table,

3138

dedicated application in the SGW/PGW  node which is called

3142

containg the 48 bit IPv6 prefix from which all the IPv6 addresses of the UEs

3139

EpcSgwPgwApplication. This application does the following operations:

3143

and PGW are configured. Such device starts the GTP/UDP/IP tunneling procedure,

3144

by forwarding the packet to a dedicated application in the SGW/PGW  node which

3145

is called EpcSgwPgwApplication. This application does the following operations:

3140

3146

3141

 #. it determines the eNB node to which the UE is attached, by looking

3147

 #. it determines the eNB node to which the UE is attached, by looking

3142

    at the IP destination address (which is the address of the UE);

3148

    at the IP destination address (which is the address of the UE);





We now explain how to write a simulation program that allows to
simulate the EPC in addition to the LTE radio access network. The use
of EPC allows to use IPv4 and IPv6 networking with LTE devices. In other words,
you will be able to use the regular ns-3 applications and sockets over
IPv4 and IPv6 over LTE, and also to connect an LTE network to any other IPv4 and IPv6
network you might have in your simulation.

First of all, in addition to ``LteHelper`` that we already introduced

create the PGW node and configure it so that it can properly handle
traffic from/to the LTE radio access network.  Still,
you need to add some explicit code to connect the PGW to other
IPv4/IPv6 networks (e.g., the internet, another EPC). Here is a very
simple example about how to connect a single remote host (IPv4 type)
to the PGW via a point-to-point link::

  Ptr<Node> pgw = epcHelper->GetPgwNode ();


  Ipv4InterfaceContainer internetIpIfaces = ipv4h.Assign (internetDevices);
  // interface 0 is localhost, 1 is the p2p device
  Ipv4Address remoteHostAddr = internetIpIfaces.GetAddress (1);


It's important to specify routes so that the remote host can reach LTE
UEs. One way of doing this is by exploiting the fact that the
``PointToPointEpcHelper`` will by default assign to LTE UEs an IP address in the
7.0.0.0 network. With this in mind, it suffices to do::

  Ipv4StaticRoutingHelper ipv4RoutingHelper;
  Ptr<Ipv4StaticRouting> remoteHostStaticRouting = ipv4RoutingHelper.GetStaticRouting (remoteHost->GetObject<Ipv4> ());
  remoteHostStaticRouting->AddNetworkRouteTo (epcHelper->GetEpcIpv4NetworkAddress (), Ipv4Mask ("255.255.0.0"), 1);

Now, you should go on and create LTE eNBs and UEs as explained in the
previous sections. You can of course configure other LTE aspects such


``LteHelper::InstallEnbDevice`` and ``LteHelper::InstallUeDevice`` functions
must have been called before attaching. In an EPC-enabled simulation, it is also
required to have IPv4/IPv6 properly pre-installed in the UE.

This method is very simple, but requires you to know exactly which UE belongs to
to which eNodeB before the simulation begins. This can be difficult when the UE




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2017 Jadavpur University, India
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Manoj Kumar Rana <manoj24.rana@gmail.com>
 */

#include "ns3/lte-helper.h"
#include "ns3/epc-helper.h"
#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/ipv4-global-routing-helper.h"
#include "ns3/ipv6-static-routing.h"
#include "ns3/internet-module.h"
#include "ns3/mobility-module.h"
#include "ns3/lte-module.h"
#include "ns3/applications-module.h"
#include "ns3/point-to-point-helper.h"
#include "ns3/config-store.h"

using namespace ns3;

/**
 * Sample simulation script for LTE+EPC. It instantiates several eNodeB,
 * attaches one UE per eNodeB starts a flow for each UE to  and from a remote host.
 * It configures IPv6 addresses for UEs by setting the 48 bit prefix attribute in epc helper
 */

NS_LOG_COMPONENT_DEFINE ("EpcFirstExampleForIpv6");

int
main (int argc, char *argv[])
{
  CommandLine cmd;
  cmd.Parse (argc, argv);

  //Set 32 bit prefix value
  Config::SetDefault ("ns3::PointToPointEpcHelper::BaseIpv6Prefix", Ipv6AddressValue (Ipv6Address ("8888:f00d:432a::")));

  Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();
  Ptr<PointToPointEpcHelper>  epcHelper = CreateObject<PointToPointEpcHelper> ();
  lteHelper->SetEpcHelper (epcHelper);

  Ptr<Node> pgw = epcHelper->GetPgwNode ();

  // Create a single RemoteHost
  NodeContainer remoteHostContainer;
  remoteHostContainer.Create (1);
  Ptr<Node> remoteHost = remoteHostContainer.Get (0);
  InternetStackHelper internet;
  internet.Install (remoteHostContainer);

  // Create the Internet
  PointToPointHelper p2ph;
  p2ph.SetDeviceAttribute ("DataRate", DataRateValue (DataRate ("100Gb/s")));
  p2ph.SetDeviceAttribute ("Mtu", UintegerValue (1500));
  p2ph.SetChannelAttribute ("Delay", TimeValue (Seconds (0.010)));
  NetDeviceContainer internetDevices = p2ph.Install (pgw, remoteHost);

  NodeContainer ueNodes;
  NodeContainer enbNodes;
  enbNodes.Create (2);
  ueNodes.Create (2);

  // Install Mobility Model
  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();
  for (uint16_t i = 0; i < 2; i++)
    {
      positionAlloc->Add (Vector (60.0 * i, 0, 0));
    }
  MobilityHelper mobility;
  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
  mobility.SetPositionAllocator (positionAlloc);
  mobility.Install (enbNodes);
  mobility.Install (ueNodes);

  // Install the IP stack on the UEs
  internet.Install (ueNodes);

  // Install LTE Devices to the nodes
  NetDeviceContainer enbLteDevs = lteHelper->InstallEnbDevice (enbNodes);
  NetDeviceContainer ueLteDevs1 = lteHelper->InstallUeDevice (NodeContainer (ueNodes.Get (0)));
  NetDeviceContainer ueLteDevs2 = lteHelper->InstallUeDevice (NodeContainer (ueNodes.Get (1)));

  Ipv6InterfaceContainer ueIpIface;

  for (NetDeviceContainer::Iterator it = ueLteDevs1.Begin (); it != ueLteDevs1.End (); ++it)
    {
      (*it)->SetAddress (Mac48Address::Allocate ());
    }

  for (NetDeviceContainer::Iterator it = ueLteDevs2.Begin (); it != ueLteDevs2.End (); ++it)
    {
      (*it)->SetAddress (Mac48Address::Allocate ());
    }


  Ipv6AddressHelper ipv6h;
  ipv6h.SetBase (Ipv6Address ("6001:db80::"), Ipv6Prefix (64));
  Ipv6InterfaceContainer internetIpIfaces = ipv6h.Assign (internetDevices);

  internetIpIfaces.SetForwarding (0, true);
  internetIpIfaces.SetDefaultRouteInAllNodes (0);


  // Assign IP address to the first UE
  ueIpIface = epcHelper->AssignUeIpv6Address (NetDeviceContainer (ueLteDevs1));


  Ipv6StaticRoutingHelper ipv6RoutingHelper;
  Ptr<Ipv6StaticRouting> remoteHostStaticRouting = ipv6RoutingHelper.GetStaticRouting (remoteHost->GetObject<Ipv6> ());
  remoteHostStaticRouting->AddNetworkRouteTo ("7777:f00d::", Ipv6Prefix (64), internetIpIfaces.GetAddress (0, 1), 1, 0);


  // Assign IP address to the second UE
  ueIpIface.Add (epcHelper->AssignUeIpv6Address (NetDeviceContainer (ueLteDevs2)));



  for (uint32_t u = 0; u < ueNodes.GetN (); ++u)
    {
      Ptr<Node> ueNode = ueNodes.Get (u);
      // Set the default gateway for the UEs
      Ptr<Ipv6StaticRouting> ueStaticRouting = ipv6RoutingHelper.GetStaticRouting (ueNode->GetObject<Ipv6> ());
      ueStaticRouting->SetDefaultRoute (epcHelper->GetUeDefaultGatewayAddress6 (), 1);
    }

  // Attach one UE per eNodeB
  lteHelper->Attach (ueLteDevs1.Get (0), enbLteDevs.Get (0));
  lteHelper->Attach (ueLteDevs2.Get (0), enbLteDevs.Get (1));


  // interface 0 is localhost, 1 is the p2p device
  Ipv6Address remoteHostAddr = internetIpIfaces.GetAddress (1, 1);


  // Install and start applications on UEs and remote host

  UdpEchoServerHelper echoServer (9);

  ApplicationContainer serverApps = echoServer.Install (remoteHost);

  serverApps.Start (Seconds (4.0));
  serverApps.Stop (Seconds (50.0));


  UdpEchoClientHelper echoClient1 (remoteHostAddr, 9);
  UdpEchoClientHelper echoClient2 (remoteHostAddr, 9);

  echoClient1.SetAttribute ("MaxPackets", UintegerValue (1000));
  echoClient1.SetAttribute ("Interval", TimeValue (Seconds (1.0)));
  echoClient1.SetAttribute ("PacketSize", UintegerValue (1024));

  echoClient2.SetAttribute ("MaxPackets", UintegerValue (1000));
  echoClient2.SetAttribute ("Interval", TimeValue (Seconds (1.0)));
  echoClient2.SetAttribute ("PacketSize", UintegerValue (1024));

  ApplicationContainer clientApps1 = echoClient1.Install (ueNodes.Get (0));
  ApplicationContainer clientApps2 = echoClient2.Install (ueNodes.Get (1));


  clientApps1.Start (Seconds (4.0));
  clientApps1.Stop (Seconds (50.0));

  clientApps2.Start (Seconds (4.5));
  clientApps2.Stop (Seconds (50.0));


  LogComponentEnable ("UdpEchoClientApplication", LOG_LEVEL_ALL);
  LogComponentEnable ("UdpEchoServerApplication", LOG_LEVEL_ALL);

  internet.EnablePcapIpv6 ("lena9", ueNodes.Get (0));
  internet.EnablePcapIpv6 ("lena10", ueNodes.Get (1));
  internet.EnablePcapIpv6 ("lena11", remoteHostContainer.Get (0));
  internet.EnablePcapIpv6 ("lena12", pgw);


  Simulator::Stop (Seconds (50));
  Simulator::Run ();

  Simulator::Destroy ();
  return 0;

}





/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2017 Jadavpur University, India
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Manoj Kumar Rana <manoj24.rana@gmail.com>
 */

#include "ns3/lte-helper.h"
#include "ns3/epc-helper.h"
#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/ipv4-global-routing-helper.h"
#include "ns3/ipv6-static-routing.h"
#include "ns3/internet-module.h"
#include "ns3/mobility-module.h"
#include "ns3/lte-module.h"
#include "ns3/applications-module.h"
#include "ns3/point-to-point-helper.h"
#include "ns3/config-store.h"

using namespace ns3;

/**
 * Sample simulation script for LTE+EPC. It instantiates several eNodeB,
 * attaches one UE per eNodeB starts a flow for each UE to  and from a remote host.
 */

NS_LOG_COMPONENT_DEFINE ("EpcFirstExampleForIpv6");

int
main (int argc, char *argv[])
{
  CommandLine cmd;
  cmd.Parse (argc, argv);

  Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();
  Ptr<PointToPointEpcHelper>  epcHelper = CreateObject<PointToPointEpcHelper> ();
  lteHelper->SetEpcHelper (epcHelper);

  Ptr<Node> pgw = epcHelper->GetPgwNode ();

  // Create a single RemoteHost
  NodeContainer remoteHostContainer;
  remoteHostContainer.Create (1);
  Ptr<Node> remoteHost = remoteHostContainer.Get (0);
  InternetStackHelper internet;
  internet.Install (remoteHostContainer);

  // Create the Internet
  PointToPointHelper p2ph;
  p2ph.SetDeviceAttribute ("DataRate", DataRateValue (DataRate ("100Gb/s")));
  p2ph.SetDeviceAttribute ("Mtu", UintegerValue (1500));
  p2ph.SetChannelAttribute ("Delay", TimeValue (Seconds (0.010)));
  NetDeviceContainer internetDevices = p2ph.Install (pgw, remoteHost);

  NodeContainer ueNodes;
  NodeContainer enbNodes;
  enbNodes.Create (2);
  ueNodes.Create (2);

  // Install Mobility Model
  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();
  for (uint16_t i = 0; i < 2; i++)
    {
      positionAlloc->Add (Vector (60.0 * i, 0, 0));
    }
  MobilityHelper mobility;
  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
  mobility.SetPositionAllocator (positionAlloc);
  mobility.Install (enbNodes);
  mobility.Install (ueNodes);

  // Install the IP stack on the UEs
  internet.Install (ueNodes);

  // Install LTE Devices to the nodes
  NetDeviceContainer enbLteDevs = lteHelper->InstallEnbDevice (enbNodes);
  NetDeviceContainer ueLteDevs = lteHelper->InstallUeDevice (ueNodes);

  Ipv6InterfaceContainer ueIpIface;

  for (NetDeviceContainer::Iterator it = ueLteDevs.Begin (); it != ueLteDevs.End (); ++it)
    {
      (*it)->SetAddress (Mac48Address::Allocate ());
    }

  // Assign IP address to UEs
  ueIpIface = epcHelper->AssignUeIpv6Address (NetDeviceContainer (ueLteDevs));


  Ipv6StaticRoutingHelper ipv6RoutingHelper;

  for (uint32_t u = 0; u < ueNodes.GetN (); ++u)
    {
      Ptr<Node> ueNode = ueNodes.Get (u);
      // Set the default gateway for the UEs
      Ptr<Ipv6StaticRouting> ueStaticRouting = ipv6RoutingHelper.GetStaticRouting (ueNode->GetObject<Ipv6> ());
      ueStaticRouting->SetDefaultRoute (epcHelper->GetUeDefaultGatewayAddress6 (), 1);
    }


  // Attach one UE per eNodeB
  for (uint16_t i = 0; i < 2; i++)
    {
      lteHelper->Attach (ueLteDevs.Get (i), enbLteDevs.Get (i));
      // side effect: the default EPS bearer will be activated
    }

  Ipv6AddressHelper ipv6h;
  ipv6h.SetBase (Ipv6Address ("6001:db80::"), Ipv6Prefix (64));
  Ipv6InterfaceContainer internetIpIfaces = ipv6h.Assign (internetDevices);

  internetIpIfaces.SetForwarding (0, true);
  internetIpIfaces.SetDefaultRouteInAllNodes (0);

  Ptr<Ipv6StaticRouting> remoteHostStaticRouting = ipv6RoutingHelper.GetStaticRouting (remoteHost->GetObject<Ipv6> ());
  remoteHostStaticRouting->AddNetworkRouteTo ("7777:f00d::", Ipv6Prefix (64), internetIpIfaces.GetAddress (0, 1), 1, 0);


  // interface 0 is localhost, 1 is the p2p device
  Ipv6Address remoteHostAddr = internetIpIfaces.GetAddress (1, 1);


  // Start applications on UEs and remote host

  UdpEchoServerHelper echoServer (9);

  ApplicationContainer serverApps = echoServer.Install (remoteHost);


  serverApps.Start (Seconds (1.0));
  serverApps.Stop (Seconds (50.0));


  UdpEchoClientHelper echoClient1 (remoteHostAddr, 9);
  UdpEchoClientHelper echoClient2 (remoteHostAddr, 9);

  echoClient1.SetAttribute ("MaxPackets", UintegerValue (1000));
  echoClient1.SetAttribute ("Interval", TimeValue (Seconds (1.0)));
  echoClient1.SetAttribute ("PacketSize", UintegerValue (1024));

  echoClient2.SetAttribute ("MaxPackets", UintegerValue (1000));
  echoClient2.SetAttribute ("Interval", TimeValue (Seconds (1.0)));
  echoClient2.SetAttribute ("PacketSize", UintegerValue (1024));

  ApplicationContainer clientApps1 = echoClient1.Install (ueNodes.Get (0));
  ApplicationContainer clientApps2 = echoClient2.Install (ueNodes.Get (1));


  clientApps1.Start (Seconds (1.0));
  clientApps1.Stop (Seconds (50.0));

  clientApps2.Start (Seconds (1.5));
  clientApps2.Stop (Seconds (50.0));

  LogComponentEnable ("UdpEchoClientApplication", LOG_LEVEL_ALL);
  LogComponentEnable ("UdpEchoServerApplication", LOG_LEVEL_ALL);

  internet.EnablePcapIpv6 ("lena1", ueNodes.Get (0));
  internet.EnablePcapIpv6 ("lena2", ueNodes.Get (1));
  internet.EnablePcapIpv6 ("lena3", remoteHostContainer.Get (0));
  internet.EnablePcapIpv6 ("lena4", pgw);

  Simulator::Stop (Seconds (50));
  Simulator::Run ();

  Simulator::Destroy ();
  return 0;

}





/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2017 Jadavpur University, India
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Manoj Kumar Rana <manoj24.rana@gmail.com>
 */

#include "ns3/lte-helper.h"
#include "ns3/epc-helper.h"
#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/ipv4-global-routing-helper.h"
#include "ns3/ipv6-static-routing.h"
#include "ns3/internet-module.h"
#include "ns3/mobility-module.h"
#include "ns3/lte-module.h"
#include "ns3/applications-module.h"
#include "ns3/point-to-point-helper.h"
#include "ns3/config-store.h"

using namespace ns3;

/**
 * Sample simulation script for LTE+EPC. It instantiates several eNodeB,
 * attaches one UE per eNodeB starts a flow for remote host to  and from the first UE.
 * It also starts yet another flow between other UE pair.
 */

NS_LOG_COMPONENT_DEFINE ("EpcSecondExampleForIpv6");

int
main (int argc, char *argv[])
{
  CommandLine cmd;
  cmd.Parse (argc, argv);

  Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();
  Ptr<PointToPointEpcHelper>  epcHelper = CreateObject<PointToPointEpcHelper> ();
  lteHelper->SetEpcHelper (epcHelper);

  Ptr<Node> pgw = epcHelper->GetPgwNode ();

  // Create a single RemoteHost
  NodeContainer remoteHostContainer;
  remoteHostContainer.Create (1);
  Ptr<Node> remoteHost = remoteHostContainer.Get (0);
  InternetStackHelper internet;
  internet.Install (remoteHostContainer);

  // Create the Internet
  PointToPointHelper p2ph;
  p2ph.SetDeviceAttribute ("DataRate", DataRateValue (DataRate ("100Gb/s")));
  p2ph.SetDeviceAttribute ("Mtu", UintegerValue (1500));
  p2ph.SetChannelAttribute ("Delay", TimeValue (Seconds (0.010)));
  NetDeviceContainer internetDevices = p2ph.Install (pgw, remoteHost);

  NodeContainer ueNodes;
  NodeContainer enbNodes;
  enbNodes.Create (2);
  ueNodes.Create (2);

  // Install Mobility Model
  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();
  for (uint16_t i = 0; i < 2; i++)
    {
      positionAlloc->Add (Vector (60.0 * i, 0, 0));
    }
  MobilityHelper mobility;
  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
  mobility.SetPositionAllocator (positionAlloc);
  mobility.Install (enbNodes);
  mobility.Install (ueNodes);

  // Install the IP stack on the UEs
  internet.Install (ueNodes);

  // Install LTE Devices to the nodes
  NetDeviceContainer enbLteDevs = lteHelper->InstallEnbDevice (enbNodes);
  NetDeviceContainer ueLteDevs = lteHelper->InstallUeDevice (ueNodes);

  Ipv6InterfaceContainer ueIpIface;

  for (NetDeviceContainer::Iterator it = ueLteDevs.Begin (); it != ueLteDevs.End (); ++it)
    {
      (*it)->SetAddress (Mac48Address::Allocate ());
    }

  // Assign IP address to UEs
  ueIpIface = epcHelper->AssignUeIpv6Address (NetDeviceContainer (ueLteDevs));


  Ipv6StaticRoutingHelper ipv6RoutingHelper;

  for (uint32_t u = 0; u < ueNodes.GetN (); ++u)
    {
      Ptr<Node> ueNode = ueNodes.Get (u);
      // Set the default gateway for the UE
      Ptr<Ipv6StaticRouting> ueStaticRouting = ipv6RoutingHelper.GetStaticRouting (ueNode->GetObject<Ipv6> ());
      ueStaticRouting->SetDefaultRoute (epcHelper->GetUeDefaultGatewayAddress6 (), 1);
    }

  // Attach one UE per eNodeB
  for (uint16_t i = 0; i < 2; i++)
    {
      lteHelper->Attach (ueLteDevs.Get (i), enbLteDevs.Get (i));
      // side effect: the default EPS bearer will be activated
    }

  Ipv6AddressHelper ipv6h;
  ipv6h.SetBase (Ipv6Address ("6001:db80::"), Ipv6Prefix (64));
  Ipv6InterfaceContainer internetIpIfaces = ipv6h.Assign (internetDevices);

  internetIpIfaces.SetForwarding (0, true);
  internetIpIfaces.SetDefaultRouteInAllNodes (0);

  Ptr<Ipv6StaticRouting> remoteHostStaticRouting = ipv6RoutingHelper.GetStaticRouting (remoteHost->GetObject<Ipv6> ());
  remoteHostStaticRouting->AddNetworkRouteTo ("7777:f00d::", Ipv6Prefix (64), internetIpIfaces.GetAddress (0, 1), 1, 0);


  // Start applications on UEs and remote host

  UdpEchoServerHelper echoServer (9);

  ApplicationContainer serverApps = echoServer.Install (ueNodes.Get (0));


  serverApps.Start (Seconds (1.0));
  serverApps.Stop (Seconds (50.0));


  UdpEchoClientHelper echoClient1 (ueIpIface.GetAddress (0,1), 9);
  UdpEchoClientHelper echoClient2 (ueIpIface.GetAddress (0,1), 9);

  echoClient1.SetAttribute ("MaxPackets", UintegerValue (1000));
  echoClient1.SetAttribute ("Interval", TimeValue (Seconds (1.0)));
  echoClient1.SetAttribute ("PacketSize", UintegerValue (1024));

  echoClient2.SetAttribute ("MaxPackets", UintegerValue (1000));
  echoClient2.SetAttribute ("Interval", TimeValue (Seconds (1.0)));
  echoClient2.SetAttribute ("PacketSize", UintegerValue (1024));

  ApplicationContainer clientApps1 = echoClient1.Install (remoteHost);
  ApplicationContainer clientApps2 = echoClient2.Install (ueNodes.Get (1));


  clientApps1.Start (Seconds (1.0));
  clientApps1.Stop (Seconds (50.0));

  clientApps2.Start (Seconds (1.5));
  clientApps2.Stop (Seconds (50.0));

  LogComponentEnable ("UdpEchoClientApplication", LOG_LEVEL_ALL);
  LogComponentEnable ("UdpEchoServerApplication", LOG_LEVEL_ALL);

  internet.EnablePcapIpv6 ("lena5", ueNodes.Get (0));
  internet.EnablePcapIpv6 ("lena6", ueNodes.Get (1));
  internet.EnablePcapIpv6 ("lena7", remoteHostContainer.Get (0));
  internet.EnablePcapIpv6 ("lena8", pgw);

  Simulator::Stop (Seconds (50));
  Simulator::Run ();

  Simulator::Destroy ();
  return 0;

}


(-)a/src/lte/examples/wscript (+9 lines)

Lines 13-18	Link Here

    obj = bld.create_ns3_program('lena-intercell-interference',

    obj = bld.create_ns3_program('lena-intercell-interference',

                                 ['lte'])

                                 ['lte'])

    obj.source = 'lena-intercell-interference.cc'

    obj.source = 'lena-intercell-interference.cc'

    obj = bld.create_ns3_program('lena-ipv6-addr-conf',

                                 ['lte'])

    obj.source = 'lena-ipv6-addr-conf.cc'

    obj = bld.create_ns3_program('lena-ipv6-ue-rh',

                                 ['lte'])

    obj.source = 'lena-ipv6-ue-rh.cc'

    obj = bld.create_ns3_program('lena-ipv6-ue-ue',

                                 ['lte'])

    obj.source = 'lena-ipv6-ue-ue.cc'

    obj = bld.create_ns3_program('lena-pathloss-traces',

    obj = bld.create_ns3_program('lena-pathloss-traces',

                                 ['lte'])

                                 ['lte'])

    obj.source = 'lena-pathloss-traces.cc'

    obj.source = 'lena-pathloss-traces.cc'

(-)a/src/lte/helper/emu-epc-helper.cc (-22 / +94 lines)

Lines 26-38	Link Here

#include <ns3/mac48-address.h>

#include <ns3/mac48-address.h>

#include <ns3/eps-bearer.h>

#include <ns3/eps-bearer.h>

#include <ns3/ipv4-address.h>

#include <ns3/ipv4-address.h>

#include <ns3/ipv6-address.h>

#include <ns3/internet-stack-helper.h>

#include <ns3/internet-stack-helper.h>

#include <ns3/packet-socket-helper.h>

#include <ns3/packet-socket-helper.h>

#include <ns3/packet-socket-address.h>

#include <ns3/packet-socket-address.h>

#include <ns3/epc-enb-application.h>

#include <ns3/epc-enb-application.h>

#include <ns3/epc-sgw-pgw-application.h>

#include <ns3/epc-sgw-pgw-application.h>

#include <ns3/emu-fd-net-device-helper.h>

#include <ns3/emu-fd-net-device-helper.h>

#include "ns3/ipv6-static-routing.h"

#include "ns3/ipv6-static-routing-helper.h"

#include <ns3/lte-enb-rrc.h>

#include <ns3/lte-enb-rrc.h>

#include <ns3/epc-x2.h>

#include <ns3/epc-x2.h>

#include <ns3/lte-enb-net-device.h>

#include <ns3/lte-enb-net-device.h>

Lines 41-46	Link Here

#include <ns3/epc-ue-nas.h>

#include <ns3/epc-ue-nas.h>

#include <ns3/string.h>

#include <ns3/string.h>

#include <ns3/abort.h>

#include <ns3/abort.h>

#include <ns3/ipv4-address-generator.h>

#include <ns3/ipv6-address-generator.h>

#include <iomanip>

#include <iomanip>

#include <iostream>

#include <iostream>

Lines 56-62	Link Here

  : m_gtpuUdpPort (2152)  // fixed by the standard

  : m_gtpuUdpPort (2152)  // fixed by the standard

  NS_LOG_FUNCTION (this);

  NS_LOG_FUNCTION (this);

  // To access the attribute value within the constructor

  ObjectBase::ConstructSelf (AttributeConstructionList ());

EmuEpcHelper::~EmuEpcHelper ()

EmuEpcHelper::~EmuEpcHelper ()

Lines 95-124	Link Here

  return tid;

100

  return tid;

101

102

103

TypeId

104

EmuEpcHelper::GetInstanceTypeId () const

105

106

  return GetTypeId ();

107

108

void

109

void

EmuEpcHelper::DoInitialize ()

110

EmuEpcHelper::DoInitialize ()

100

111

101

  NS_LOG_LOGIC (this);

112

  NS_LOG_LOGIC (this);

102

113

114

  // we use a /8 net for all UEs

115

  m_uePgwAddressHelper.SetBase ("7.0.0.0", "255.0.0.0");

103

116

104

  // we use a /8 net for all UEs

117

  // we use a /64 IPv6 net all UEs

105

  m_ueAddressHelper.SetBase ("7.0.0.0", "255.0.0.0");

118

  m_uePgwAddressHelper6.SetBase ("7777:f00d::", Ipv6Prefix (64));

106

119

107

120

108

109

  // create SgwPgwNode

121

  // create SgwPgwNode

110

  m_sgwPgw = CreateObject<Node> ();

122

  m_sgwPgw = CreateObject<Node> ();

111

  InternetStackHelper internet;

123

  InternetStackHelper internet;

112

  internet.SetIpv4StackInstall (true);

113

  internet.Install (m_sgwPgw);

124

  internet.Install (m_sgwPgw);

125

126

  // The Tun device resides in different 64 bit subnet.

127

  // We must create an unique route to tun device for all the packets destined

128

  // to all 64 bit IPv6 prefixes of UEs, based by the unique 48 bit network prefix of this EPC network

129

  Ipv6StaticRoutingHelper ipv6RoutingHelper;

130

  Ptr<Ipv6StaticRouting> pgwStaticRouting = ipv6RoutingHelper.GetStaticRouting (m_sgwPgw->GetObject<Ipv6> ());

131

  pgwStaticRouting->AddNetworkRouteTo ("7777:f00d::", Ipv6Prefix (64), Ipv6Address ("::"), 1, 0);

114

132

115

  // create S1-U socket

133

  // create S1-U socket

116

  Ptr<Socket> sgwPgwS1uSocket = Socket::CreateSocket (m_sgwPgw, TypeId::LookupByName ("ns3::UdpSocketFactory"));

134

  Ptr<Socket> sgwPgwS1uSocket = Socket::CreateSocket (m_sgwPgw, TypeId::LookupByName ("ns3::UdpSocketFactory"));

117

  int retval = sgwPgwS1uSocket->Bind (InetSocketAddress (Ipv4Address::GetAny (), m_gtpuUdpPort));

135

  int retval = sgwPgwS1uSocket->Bind (InetSocketAddress (Ipv4Address::GetAny (), m_gtpuUdpPort));

118

  NS_ASSERT (retval == 0);

136

  NS_ASSERT (retval == 0);

119

137

120

  // create TUN device implementing tunneling of user data over GTP-U/UDP/IP

138

  // create TUN device containg IPv4 address and implementing tunneling of user data over GTP-U/UDP/IP

121

  m_tunDevice = CreateObject<VirtualNetDevice> ();

139

  m_tunDevice = CreateObject<VirtualNetDevice> ();

140

122

  // allow jumbo packets

141

  // allow jumbo packets

123

  m_tunDevice->SetAttribute ("Mtu", UintegerValue (30000));

142

  m_tunDevice->SetAttribute ("Mtu", UintegerValue (30000));

124

143

Lines 130-138	Link Here

130

  tunDeviceContainer.Add (m_tunDevice);

149

  tunDeviceContainer.Add (m_tunDevice);

131

150

132

  // the TUN device is on the same subnet as the UEs, so when a packet

151

  // the TUN device is on the same subnet as the UEs, so when a packet

133

  // addressed to an UE arrives at the intenet to the WAN interface of

152

  // addressed to an UE IPv4 address arrives at the intenet to the WAN interface of

134

  // the PGW it will be forwarded to the TUN device.

153

  // the PGW it will be forwarded to the TUN device.

135

  Ipv4InterfaceContainer tunDeviceIpv4IfContainer = m_ueAddressHelper.Assign (tunDeviceContainer);

154

  Ipv4InterfaceContainer tunDeviceIpv4IfContainer = AssignUeIpv4Address (tunDeviceContainer);

155

156

  // the TUN device for IPv6 address is on the different subnet as the

157

  // UEs, it will forward the UE packets as we have inserted the route

158

  // for all UEs at the time of assigning UE addresses

159

  Ipv6InterfaceContainer tunDeviceIpv6IfContainer = AssignUeIpv6Address (tunDeviceContainer);

160

161

  //Set Forwarding

162

  tunDeviceIpv6IfContainer.SetForwarding (0,true);

163

  tunDeviceIpv6IfContainer.SetDefaultRouteInAllNodes (0);

164

136

165

137

  // create EpcSgwPgwApplication

166

  // create EpcSgwPgwApplication

138

  m_sgwPgwApp = CreateObject<EpcSgwPgwApplication> (m_tunDevice, sgwPgwS1uSocket);

167

  m_sgwPgwApp = CreateObject<EpcSgwPgwApplication> (m_tunDevice, sgwPgwS1uSocket);

Lines 141-146	Link Here

141

  // connect SgwPgwApplication and virtual net device for tunneling

170

  // connect SgwPgwApplication and virtual net device for tunneling

142

  m_tunDevice->SetSendCallback (MakeCallback (&EpcSgwPgwApplication::RecvFromTunDevice, m_sgwPgwApp));

171

  m_tunDevice->SetSendCallback (MakeCallback (&EpcSgwPgwApplication::RecvFromTunDevice, m_sgwPgwApp));

143

172

173

144

  // Create MME and connect with SGW via S11 interface

174

  // Create MME and connect with SGW via S11 interface

145

  m_mme = CreateObject<EpcMme> ();

175

  m_mme = CreateObject<EpcMme> ();

146

  m_mme->SetS11SapSgw (m_sgwPgwApp->GetS11SapSgw ());

176

  m_mme->SetS11SapSgw (m_sgwPgwApp->GetS11SapSgw ());

Lines 184-190	Link Here

184

214

185

  NS_ASSERT (enb == lteEnbNetDevice->GetNode ());

215

  NS_ASSERT (enb == lteEnbNetDevice->GetNode ());

186

216

187

  // add an IPv4 stack to the previously created eNB

217

  // add an Internet stack to the previously created eNB

188

  InternetStackHelper internet;

218

  InternetStackHelper internet;

189

  internet.Install (enb);

219

  internet.Install (enb);

190

  NS_LOG_LOGIC ("number of Ipv4 ifaces of the eNB after node creation: " << enb->GetObject<Ipv4> ()->GetNInterfaces ());

220

  NS_LOG_LOGIC ("number of Ipv4 ifaces of the eNB after node creation: " << enb->GetObject<Ipv4> ()->GetNInterfaces ());

Lines 231-240	Link Here

231

  enbLteSocketConnectAddress.SetProtocol (Ipv4L3Protocol::PROT_NUMBER);

261

  enbLteSocketConnectAddress.SetProtocol (Ipv4L3Protocol::PROT_NUMBER);

232

  retval = enbLteSocket->Connect (enbLteSocketConnectAddress);

262

  retval = enbLteSocket->Connect (enbLteSocketConnectAddress);

233

  NS_ASSERT (retval == 0);

263

  NS_ASSERT (retval == 0);

264

265

  // create LTE socket for the ENB

266

  Ptr<Socket> enbLteSocket6 = Socket::CreateSocket (enb, TypeId::LookupByName ("ns3::PacketSocketFactory"));

267

  PacketSocketAddress enbLteSocketBindAddress6;

268

  enbLteSocketBindAddress6.SetSingleDevice (lteEnbNetDevice->GetIfIndex ());

269

  enbLteSocketBindAddress6.SetProtocol (Ipv6L3Protocol::PROT_NUMBER);

270

  retval = enbLteSocket6->Bind (enbLteSocketBindAddress6);

271

  NS_ASSERT (retval == 0);

272

  PacketSocketAddress enbLteSocketConnectAddress6;

273

  enbLteSocketConnectAddress6.SetPhysicalAddress (Mac48Address::GetBroadcast ());

274

  enbLteSocketConnectAddress6.SetSingleDevice (lteEnbNetDevice->GetIfIndex ());

275

  enbLteSocketConnectAddress6.SetProtocol (Ipv6L3Protocol::PROT_NUMBER);

276

  retval = enbLteSocket6->Connect (enbLteSocketConnectAddress6);

277

  NS_ASSERT (retval == 0);

234

278

235

236

  NS_LOG_INFO ("create EpcEnbApplication");

279

  NS_LOG_INFO ("create EpcEnbApplication");

237

  Ptr<EpcEnbApplication> enbApp = CreateObject<EpcEnbApplication> (enbLteSocket, enbS1uSocket, enbAddress, sgwAddress, cellId);

280

  Ptr<EpcEnbApplication> enbApp = CreateObject<EpcEnbApplication> (enbLteSocket, enbS1uSocket, enbAddress, sgwAddress, cellId);

281

  enbApp->SetLTESocket6(enbLteSocket6);

238

  enb->AddApplication (enbApp);

282

  enb->AddApplication (enbApp);

239

  NS_ASSERT (enb->GetNApplications () == 1);

283

  NS_ASSERT (enb->GetNApplications () == 1);

240

  NS_ASSERT_MSG (enb->GetApplication (0)->GetObject<EpcEnbApplication> () != 0, "cannot retrieve EpcEnbApplication");

284

  NS_ASSERT_MSG (enb->GetApplication (0)->GetObject<EpcEnbApplication> () != 0, "cannot retrieve EpcEnbApplication");

Lines 312-334	Link Here

312

356

313

357

314

358

359

315

uint8_t

360

uint8_t

316

EmuEpcHelper::ActivateEpsBearer (Ptr<NetDevice> ueDevice, uint64_t imsi, Ptr<EpcTft> tft, EpsBearer bearer)

361

EmuEpcHelper::ActivateEpsBearer (Ptr<NetDevice> ueDevice, uint64_t imsi, Ptr<EpcTft> tft, EpsBearer bearer)

317

362

318

  NS_LOG_FUNCTION (this << ueDevice << imsi);

363

  NS_LOG_FUNCTION (this << ueDevice << imsi);

319

364

320

  // we now retrieve the IPv4 address of the UE and notify it to the SGW;

365

  // we now retrieve the IPv4/IPv6 address of the UE and notify it to the SGW;

321

  // we couldn't do it before since address assignment is triggered by

366

  // we couldn't do it before since address assignment is triggered by

322

  // the user simulation program, rather than done by the EPC

367

  // the user simulation program, rather than done by the EPC

323

  Ptr<Node> ueNode = ueDevice->GetNode ();

368

  Ptr<Node> ueNode = ueDevice->GetNode ();

324

  Ptr<Ipv4> ueIpv4 = ueNode->GetObject<Ipv4> ();

369

  Ptr<Ipv4> ueIpv4 = ueNode->GetObject<Ipv4> ();

325

  NS_ASSERT_MSG (ueIpv4 != 0, "UEs need to have IPv4 installed before EPS bearers can be activated");

370

  Ptr<Ipv6> ueIpv6 = ueNode->GetObject<Ipv6> ();

326

  int32_t interface =  ueIpv4->GetInterfaceForDevice (ueDevice);

371

  NS_ASSERT_MSG (ueIpv4 != 0 || ueIpv6 != 0, "UEs need to have IPv4/IPv6 installed before EPS bearers can be activated");

327

  NS_ASSERT (interface >= 0);

372

328

  NS_ASSERT (ueIpv4->GetNAddresses (interface) == 1);

373

  if (ueIpv4)

329

  Ipv4Address ueAddr = ueIpv4->GetAddress (interface, 0).GetLocal ();

374

330

  NS_LOG_LOGIC (" UE IP address: " << ueAddr);  m_sgwPgwApp->SetUeAddress (imsi, ueAddr);

375

      int32_t interface =  ueIpv4->GetInterfaceForDevice (ueDevice);

331

376

      if (interface >= 0 && ueIpv4->GetNAddresses (interface) == 1)

377

378

          Ipv4Address ueAddr = ueIpv4->GetAddress (interface, 0).GetLocal ();

379

          NS_LOG_LOGIC (" UE IPv4 address: " << ueAddr);

380

          m_sgwPgwApp->SetUeAddress (imsi, ueAddr);

381

382

383

  if (ueIpv6)

384

385

      int32_t interface6 =  ueIpv6->GetInterfaceForDevice (ueDevice);

386

      if (interface6 >= 0 && ueIpv6->GetNAddresses (interface6) == 2)

387

388

          Ipv6Address ueAddr6 = ueIpv6->GetAddress (interface6, 1).GetAddress ();

389

          NS_LOG_LOGIC (" UE IPv6 address: " << ueAddr6);

390

          m_sgwPgwApp->SetUeAddress6 (imsi, ueAddr6);

391

392

393

332

  uint8_t bearerId = m_mme->AddBearer (imsi, tft, bearer);

394

  uint8_t bearerId = m_mme->AddBearer (imsi, tft, bearer);

333

  Ptr<LteUeNetDevice> ueLteDevice = ueDevice->GetObject<LteUeNetDevice> ();

395

  Ptr<LteUeNetDevice> ueLteDevice = ueDevice->GetObject<LteUeNetDevice> ();

334

  if (ueLteDevice)

396

  if (ueLteDevice)

Lines 349-358	Link Here

349

Ipv4InterfaceContainer

411

Ipv4InterfaceContainer

350

EmuEpcHelper::AssignUeIpv4Address (NetDeviceContainer ueDevices)

412

EmuEpcHelper::AssignUeIpv4Address (NetDeviceContainer ueDevices)

351

413

352

  return m_ueAddressHelper.Assign (ueDevices);

414

  return m_uePgwAddressHelper.Assign (ueDevices);

353

415

354

416

355

417

Ipv6InterfaceContainer

418

EmuEpcHelper::AssignUeIpv6Address (NetDeviceContainer ueDevices)

419

420

  return m_uePgwAddressHelper6.Assign (ueDevices);

421

356

422

357

Ipv4Address

423

Ipv4Address

358

EmuEpcHelper::GetUeDefaultGatewayAddress ()

424

EmuEpcHelper::GetUeDefaultGatewayAddress ()

Lines 361-365	Link Here

361

  return m_sgwPgw->GetObject<Ipv4> ()->GetAddress (1, 0).GetLocal ();

427

  return m_sgwPgw->GetObject<Ipv4> ()->GetAddress (1, 0).GetLocal ();

362

428

363

429

430

Ipv6Address

431

EmuEpcHelper::GetUeDefaultGatewayAddress6 ()

432

433

  // return the address of the tun device 6

434

  return m_sgwPgw->GetObject<Ipv6> ()->GetAddress (1, 1).GetAddress ();

435

364

436

365

} // namespace ns3

437

} // namespace ns3





#include <ns3/object.h>
#include <ns3/ipv4-address-helper.h>
#include <ns3/ipv6-address-helper.h>
#include <ns3/data-rate.h>
#include <ns3/epc-tft.h>
#include <ns3/eps-bearer.h>

   *  \return The object TypeId.
   */
  static TypeId GetTypeId (void);
  TypeId GetInstanceTypeId () const;
  virtual void DoInitialize ();
  virtual void DoDispose ();


  virtual uint8_t ActivateEpsBearer (Ptr<NetDevice> ueLteDevice, uint64_t imsi, Ptr<EpcTft> tft, EpsBearer bearer);
  virtual Ptr<Node> GetPgwNode ();
  virtual Ipv4InterfaceContainer AssignUeIpv4Address (NetDeviceContainer ueDevices);
  Ipv6InterfaceContainer AssignUeIpv6Address (NetDeviceContainer ueDevices);
  virtual Ipv4Address GetUeDefaultGatewayAddress ();
  Ipv6Address GetUeDefaultGatewayAddress6 ();


private:

  /** 
   * helper to assign IPv4 addresses to UE devices as well as to the TUN device of the SGW/PGW
   */
  Ipv4AddressHelper m_uePgwAddressHelper; 

  /** 
   * helper to assign IPv6 addresses to UE devices as well as to the TUN device of the SGW/PGW
   */
  Ipv6AddressHelper m_uePgwAddressHelper6; 

  /**
   * SGW-PGW network element

  Ptr<EpcSgwPgwApplication> m_sgwPgwApp;

  /**
   * TUN device containing IPv4 address and implementing tunneling of user data over GTP-U/UDP/IP
   */
  Ptr<VirtualNetDevice> m_tunDevice;


   * First 5 bytes of the Enb MAC address base
   */
  std::string m_enbMacAddressBase;
  
};



(-)a/src/lte/helper/epc-helper.cc (+1 lines)

Lines 24-29	Link Here

#include <ns3/log.h>

#include <ns3/log.h>

#include <ns3/node.h>

#include <ns3/node.h>

#include <ns3/ipv4-address.h>

#include <ns3/ipv4-address.h>

#include <ns3/ipv6-address.h>

namespace ns3 {

namespace ns3 {

(-)a/src/lte/helper/epc-helper.h (-1 / +2 lines)

Lines 25-30	Link Here

#include <ns3/object.h>

#include <ns3/object.h>

#include <ns3/ipv4-address-helper.h>

#include <ns3/ipv4-address-helper.h>

#include <ns3/ipv6-address-helper.h>

#include <ns3/data-rate.h>

#include <ns3/data-rate.h>

#include <ns3/epc-tft.h>

#include <ns3/epc-tft.h>

#include <ns3/eps-bearer.h>

#include <ns3/eps-bearer.h>

Lines 133-139	Link Here

133

134

/**

135

/**

135

136

   * \return the address of the Default Gateway to be used by UEs to reach the internet

137

   * \return the IPv4 address of the Default Gateway to be used by UEs to reach the internet

137

*/

138

*/

138

  virtual Ipv4Address GetUeDefaultGatewayAddress () = 0;

139

  virtual Ipv4Address GetUeDefaultGatewayAddress () = 0;

139

140




#include <ns3/mac48-address.h>
#include <ns3/eps-bearer.h>
#include <ns3/ipv4-address.h>
#include <ns3/ipv4-address.h>
#include <ns3/internet-stack-helper.h>
#include <ns3/point-to-point-helper.h>
#include <ns3/packet-socket-helper.h>
#include <ns3/packet-socket-address.h>
#include <ns3/epc-enb-application.h>
#include <ns3/epc-sgw-pgw-application.h>
#include "ns3/ipv6-static-routing.h"
#include "ns3/ipv6-static-routing-helper.h"
#include <ns3/lte-enb-rrc.h>
#include <ns3/epc-x2.h>
#include <ns3/lte-enb-net-device.h>
#include <ns3/lte-ue-net-device.h>
#include <ns3/epc-mme.h>
#include <ns3/epc-ue-nas.h>
#include <ns3/ipv4-address-generator.h>
#include <ns3/ipv6-address-generator.h>

namespace ns3 {


  : m_gtpuUdpPort (2152)  // fixed by the standard
{
  NS_LOG_FUNCTION (this);
  // To access the attribute value within the constructor
  ObjectBase::ConstructSelf (AttributeConstructionList ());

  // since we use point-to-point links for all S1-U links, 
  // we use a /30 subnet which can hold exactly two addresses 

  m_x2Ipv4AddressHelper.SetBase ("12.0.0.0", "255.255.255.252");

  // we use a /8 net for all UEs
  m_uePgwAddressHelper.SetBase ("7.0.0.0", "255.0.0.0");

  // we use a /64 IPv6 net all UEs
  m_uePgwAddressHelper6.SetBase ("7777:f00d::", Ipv6Prefix (64));

  // create SgwPgwNode
  m_sgwPgw = CreateObject<Node> ();
  InternetStackHelper internet;
  internet.Install (m_sgwPgw);

  // The Tun device resides in different 64 bit subnet.
  // We must create an unique route to tun device for all the packets destined
  // to all 64 bit IPv6 prefixes of UEs, based by the unique 48 bit network prefix of this EPC network
  Ipv6StaticRoutingHelper ipv6RoutingHelper;
  Ptr<Ipv6StaticRouting> pgwStaticRouting = ipv6RoutingHelper.GetStaticRouting (m_sgwPgw->GetObject<Ipv6> ());
  pgwStaticRouting->AddNetworkRouteTo ("7777:f00d::", Ipv6Prefix (64), Ipv6Address ("::"), 1, 0);
  
  // create S1-U socket
  Ptr<Socket> sgwPgwS1uSocket = Socket::CreateSocket (m_sgwPgw, TypeId::LookupByName ("ns3::UdpSocketFactory"));


  // create TUN device implementing tunneling of user data over GTP-U/UDP/IP 
  m_tunDevice = CreateObject<VirtualNetDevice> ();

  // allow jumbo packets
  m_tunDevice->SetAttribute ("Mtu", UintegerValue (30000));

  // yes we need this
  m_tunDevice->SetAddress (Mac48Address::Allocate ());



  m_sgwPgw->AddDevice (m_tunDevice);
  NetDeviceContainer tunDeviceContainer;

  // the TUN device is on the same subnet as the UEs, so when a packet
  // addressed to an UE arrives at the intenet to the WAN interface of
  // the PGW it will be forwarded to the TUN device. 
  Ipv4InterfaceContainer tunDeviceIpv4IfContainer = AssignUeIpv4Address (tunDeviceContainer);  


  // the TUN device for IPv6 address is on the different subnet as the
  // UEs, it will forward the UE packets as we have inserted the route
  // for all UEs at the time of assigning UE addresses
  Ipv6InterfaceContainer tunDeviceIpv6IfContainer = AssignUeIpv6Address (tunDeviceContainer);


  //Set Forwarding of the IPv6 interface
  tunDeviceIpv6IfContainer.SetForwarding (0,true);
  tunDeviceIpv6IfContainer.SetDefaultRouteInAllNodes (0);

  // create EpcSgwPgwApplication
  m_sgwPgwApp = CreateObject<EpcSgwPgwApplication> (m_tunDevice, sgwPgwS1uSocket);

  // connect SgwPgwApplication and virtual net device for tunneling
  m_tunDevice->SetSendCallback (MakeCallback (&EpcSgwPgwApplication::RecvFromTunDevice, m_sgwPgwApp));


  // Create MME and connect with SGW via S11 interface
  m_mme = CreateObject<EpcMme> ();
  m_mme->SetS11SapSgw (m_sgwPgwApp->GetS11SapSgw ());

  return tid;
}

TypeId
PointToPointEpcHelper::GetInstanceTypeId () const
{
  return GetTypeId ();
}

void
PointToPointEpcHelper::DoDispose ()
{

  Ptr<Socket> enbS1uSocket = Socket::CreateSocket (enb, TypeId::LookupByName ("ns3::UdpSocketFactory"));
  int retval = enbS1uSocket->Bind (InetSocketAddress (enbAddress, m_gtpuUdpPort));
  NS_ASSERT (retval == 0);
  

  // give PacketSocket powers to the eNB
  //PacketSocketHelper packetSocket;
  //packetSocket.Install (enb); 
  
  // create LTE socket for the ENB 
  Ptr<Socket> enbLteSocket = Socket::CreateSocket (enb, TypeId::LookupByName ("ns3::PacketSocketFactory"));
  PacketSocketAddress enbLteSocketBindAddress;

  enbLteSocketConnectAddress.SetProtocol (Ipv4L3Protocol::PROT_NUMBER);
  retval = enbLteSocket->Connect (enbLteSocketConnectAddress);
  NS_ASSERT (retval == 0);  

  // create LTE socket for the ENB 
  Ptr<Socket> enbLteSocket6 = Socket::CreateSocket (enb, TypeId::LookupByName ("ns3::PacketSocketFactory"));
  PacketSocketAddress enbLteSocketBindAddress6;
  enbLteSocketBindAddress6.SetSingleDevice (lteEnbNetDevice->GetIfIndex ());
  enbLteSocketBindAddress6.SetProtocol (Ipv6L3Protocol::PROT_NUMBER);
  retval = enbLteSocket6->Bind (enbLteSocketBindAddress6);
  NS_ASSERT (retval == 0);  
  PacketSocketAddress enbLteSocketConnectAddress6;
  enbLteSocketConnectAddress6.SetPhysicalAddress (Mac48Address::GetBroadcast ());
  enbLteSocketConnectAddress6.SetSingleDevice (lteEnbNetDevice->GetIfIndex ());
  enbLteSocketConnectAddress6.SetProtocol (Ipv6L3Protocol::PROT_NUMBER);
  retval = enbLteSocket6->Connect (enbLteSocketConnectAddress6);
  NS_ASSERT (retval == 0);  

  NS_LOG_INFO ("create EpcEnbApplication");
  Ptr<EpcEnbApplication> enbApp = CreateObject<EpcEnbApplication> (enbLteSocket, enbS1uSocket, enbAddress, sgwAddress, cellId);
  enbApp->SetLTESocket6(enbLteSocket6);
  enb->AddApplication (enbApp);
  NS_ASSERT (enb->GetNApplications () == 1);
  NS_ASSERT_MSG (enb->GetApplication (0)->GetObject<EpcEnbApplication> () != 0, "cannot retrieve EpcEnbApplication");

{
  NS_LOG_FUNCTION (this << ueDevice << imsi);

  // we now retrieve the IPv4/IPv6 address of the UE and notify it to the SGW;
  // we couldn't do it before since address assignment is triggered by
  // the user simulation program, rather than done by the EPC   
  Ptr<Node> ueNode = ueDevice->GetNode (); 
  Ptr<Ipv4> ueIpv4 = ueNode->GetObject<Ipv4> ();
  Ptr<Ipv6> ueIpv6 = ueNode->GetObject<Ipv6> ();
  NS_ASSERT_MSG (ueIpv4 != 0 || ueIpv6 != 0, "UEs need to have IPv4/IPv6 installed before EPS bearers can be activated");

  if (ueIpv4)
    {
      int32_t interface =  ueIpv4->GetInterfaceForDevice (ueDevice);
      if (interface >= 0 && ueIpv4->GetNAddresses (interface) == 1)
        {
          Ipv4Address ueAddr = ueIpv4->GetAddress (interface, 0).GetLocal ();
          NS_LOG_LOGIC (" UE IPv4 address: " << ueAddr);
          m_sgwPgwApp->SetUeAddress (imsi, ueAddr);
        }
    }
  if (ueIpv6)
    {
      int32_t interface6 =  ueIpv6->GetInterfaceForDevice (ueDevice);
      if (interface6 >= 0 && ueIpv6->GetNAddresses (interface6) == 2)
        {
          Ipv6Address ueAddr6 = ueIpv6->GetAddress (interface6, 1).GetAddress ();
          NS_LOG_LOGIC (" UE IPv6 address: " << ueAddr6);
          m_sgwPgwApp->SetUeAddress6 (imsi, ueAddr6);
        }
    }
  uint8_t bearerId = m_mme->AddBearer (imsi, tft, bearer);
  Ptr<LteUeNetDevice> ueLteDevice = ueDevice->GetObject<LteUeNetDevice> ();
  if (ueLteDevice)
    {
      Simulator::ScheduleNow (&EpcUeNas::ActivateEpsBearer, ueLteDevice->GetNas (), bearer, tft);
    }
  return bearerId;
}


Ptr<Node>
PointToPointEpcHelper::GetPgwNode ()
{
  return m_sgwPgw;
}


Ipv4InterfaceContainer 
PointToPointEpcHelper::AssignUeIpv4Address (NetDeviceContainer ueDevices)
{
  return m_uePgwAddressHelper.Assign (ueDevices);
}

Ipv6InterfaceContainer 
PointToPointEpcHelper::AssignUeIpv6Address (NetDeviceContainer ueDevices)
{
  return m_uePgwAddressHelper6.Assign (ueDevices);
}

Ipv4Address
PointToPointEpcHelper::GetUeDefaultGatewayAddress ()

  return m_sgwPgw->GetObject<Ipv4> ()->GetAddress (1, 0).GetLocal ();
}

Ipv6Address
PointToPointEpcHelper::GetUeDefaultGatewayAddress6 ()
{
  // return the address of the tun device
  return m_sgwPgw->GetObject<Ipv6> ()->GetAddress (1, 1).GetAddress ();
}

} // namespace ns3





#include <ns3/object.h>
#include <ns3/ipv4-address-helper.h>
#include <ns3/ipv6-address-helper.h>
#include <ns3/data-rate.h>
#include <ns3/epc-tft.h>
#include <ns3/eps-bearer.h>

   *  \return The object TypeId.
   */
  static TypeId GetTypeId (void);
  TypeId GetInstanceTypeId () const;
  virtual void DoDispose ();

  // inherited from EpcHelper

  virtual uint8_t ActivateEpsBearer (Ptr<NetDevice> ueLteDevice, uint64_t imsi, Ptr<EpcTft> tft, EpsBearer bearer);
  virtual Ptr<Node> GetPgwNode ();
  virtual Ipv4InterfaceContainer AssignUeIpv4Address (NetDeviceContainer ueDevices);
  Ipv6InterfaceContainer AssignUeIpv6Address (NetDeviceContainer ueDevices);
  virtual Ipv4Address GetUeDefaultGatewayAddress ();
  Ipv6Address GetUeDefaultGatewayAddress6 ();


private:

  /** 
   * helper to assign IPv4 addresses to UE devices as well as to the TUN device of the SGW/PGW
   */
  Ipv4AddressHelper m_uePgwAddressHelper;
  /** 
   * helper to assign IPv6 addresses to UE devices as well as to the TUN device of the SGW/PGW
   */
  Ipv6AddressHelper m_uePgwAddressHelper6;
  
  /**
   * SGW-PGW network element

   * because of some big X2 messages, you need a big MTU.
   */
  uint16_t m_x2LinkMtu;

};






{
  static TypeId tid = TypeId ("ns3::EpcEnbApplication")
    .SetParent<Object> ()
    .SetGroupName("Lte")
    .AddTraceSource ("RxFromEnb",
                     "Receive data packets from LTE Enb Net Device",
                     MakeTraceSourceAccessor (&EpcEnbApplication::m_rxLteSocketPktTrace),
                     "ns3::EpcEnbApplication::RxTracedCallback")
    .AddTraceSource ("RxFromS1u",
                     "Receive data packets from S1-U Net Device",
                     MakeTraceSourceAccessor (&EpcEnbApplication::m_rxS1uSocketPktTrace),
                     "ns3::EpcEnbApplication::RxTracedCallback")
    ;
  return tid;
}


{
  NS_LOG_FUNCTION (this);
  m_lteSocket = 0;
  m_lteSocket6 = 0;
  m_s1uSocket = 0;
  delete m_s1SapProvider;
  delete m_s1apSapEnb;
}


EpcEnbApplication::EpcEnbApplication (Ptr<Socket> lteSocket, Ptr<Socket> s1uSocket, Ipv4Address enbS1uAddress, Ipv4Address sgwS1uAddress, uint16_t cellId)
  : m_lteSocket (lteSocket),
    m_lteSocket6 (0),
    m_s1uSocket (s1uSocket),    
    m_enbS1uAddress (enbS1uAddress),
    m_sgwS1uAddress (sgwS1uAddress),

EpcEnbApplication::RecvFromLteSocket (Ptr<Socket> socket)
{
  NS_LOG_FUNCTION (this);  
  if(m_lteSocket6)
    {
      NS_ASSERT (socket == m_lteSocket || socket == m_lteSocket6);
    }
  else
    {
      NS_ASSERT (socket == m_lteSocket);
    }
  Ptr<Packet> packet = socket->Recv ();

  EpsBearerTag tag;

      std::map<uint8_t, uint32_t>::iterator bidIt = rntiIt->second.find (bid);
      NS_ASSERT (bidIt != rntiIt->second.end ());
      uint32_t teid = bidIt->second;
      m_rxLteSocketPktTrace (packet->Copy ());
      SendToS1uSocket (packet, teid);
    }
}

  std::map<uint32_t, EpsFlowId_t>::iterator it = m_teidRbidMap.find (teid);
  NS_ASSERT (it != m_teidRbidMap.end ());

  m_rxS1uSocketPktTrace (packet->Copy ());
  SendToLteSocket (packet, it->second.m_rnti, it->second.m_bid);
}


  NS_LOG_FUNCTION (this << packet << rnti << (uint16_t) bid << packet->GetSize ());  
  EpsBearerTag tag (rnti, bid);
  packet->AddPacketTag (tag);
  uint8_t ipType;

  packet->CopyData (&ipType, 1);
  ipType = (ipType>>4) & 0x0f;

  int sentBytes;
  if (ipType == 0x04)
    {
      sentBytes = m_lteSocket->Send (packet);
    }
  else if (ipType == 0x06)
    {
      sentBytes = m_lteSocket6->Send (packet);
    }
  else
    {
      NS_ABORT_MSG ("EpcEnbApplication::SendToLteSocket - Unknown IP type...");
    }

  NS_ASSERT (sentBytes > 0);
}


  //From 3GPP TS 23401-950 Section 5.4.4.2, enB sends EPS bearer Identity in Bearer Release Indication message to MME
  m_s1apSapMme->ErabReleaseIndication (imsi, rnti, erabToBeReleaseIndication);
}

void EpcEnbApplication::SetLTESocket6(Ptr<Socket> lteSocket6)
{
  m_lteSocket6 = lteSocket6;
  m_lteSocket6->SetRecvCallback (MakeCallback (&EpcEnbApplication::RecvFromLteSocket, this));
}

Ptr<Socket> EpcEnbApplication::GetLTESocket6()
{
  return m_lteSocket6;
}

}  // namespace ns3

(-)a/src/lte/model/epc-enb-application.h (+24 lines)

Lines 80-85	Link Here

*/

*/

  EpcEnbApplication (Ptr<Socket> lteSocket, Ptr<Socket> s1uSocket, Ipv4Address enbS1uAddress, Ipv4Address sgwS1uAddress, uint16_t cellId);

  EpcEnbApplication (Ptr<Socket> lteSocket, Ptr<Socket> s1uSocket, Ipv4Address enbS1uAddress, Ipv4Address sgwS1uAddress, uint16_t cellId);

  void SetLTESocket6(Ptr<Socket> lteSocket6);

  Ptr<Socket> GetLTESocket6();

/**

/**

   * Destructor

   * Destructor

Lines 128-133	Link Here

128

*/

130

*/

129

  void RecvFromS1uSocket (Ptr<Socket> socket);

131

  void RecvFromS1uSocket (Ptr<Socket> socket);

130

132

133

/**

134

   * TracedCallback signature for data Packet reception event.

135

136

   * \param [in] packet The data packet sent from the internet.

137

*/

138

  typedef void (* RxTracedCallback)

139

    (Ptr<Packet> packet);

140

131

141

132

/**

142

/**

133

   * EPS flow ID structure

143

   * EPS flow ID structure

Lines 246-251	Link Here

246

  Ptr<Socket> m_lteSocket;

256

  Ptr<Socket> m_lteSocket;

247

257

248

/**

258

/**

259

   * raw packet socket to send and receive the packets to and from the LTE radio interface

260

*/

261

  Ptr<Socket> m_lteSocket6;

262

263

/**

249

   * UDP socket to send and receive GTP-U the packets to and from the S1-U interface

264

   * UDP socket to send and receive GTP-U the packets to and from the S1-U interface

250

*/

265

*/

251

  Ptr<Socket> m_s1uSocket;

266

  Ptr<Socket> m_s1uSocket;

Lines 307-312	Link Here

307

322

308

  uint16_t m_cellId; ///< cell ID

323

  uint16_t m_cellId; ///< cell ID

309

324

325

/**

326

   * \brief Callback to trace RX (reception) data packets from LTE Socket.

327

*/

328

  TracedCallback<Ptr<Packet> > m_rxLteSocketPktTrace;

329

330

/**

331

   * \brief Callback to trace RX (reception) data packets from S1-U Socket.

332

*/

333

  TracedCallback<Ptr<Packet> > m_rxS1uSocketPktTrace;

310

};

334

};

311

335

312

} //namespace ns3

336

} //namespace ns3

(-)a/src/lte/model/epc-sgw-pgw-application.cc (-24 / +112 lines)

Lines 24-29	Link Here

#include "ns3/log.h"

#include "ns3/log.h"

#include "ns3/mac48-address.h"

#include "ns3/mac48-address.h"

#include "ns3/ipv4.h"

#include "ns3/ipv4.h"

#include "ns3/ipv6.h"

#include "ns3/ipv6-header.h"

#include "ns3/inet-socket-address.h"

#include "ns3/inet-socket-address.h"

#include "ns3/epc-gtpu-header.h"

#include "ns3/epc-gtpu-header.h"

#include "ns3/abort.h"

#include "ns3/abort.h"

Lines 91-96	Link Here

  m_ueAddr = ueAddr;

  m_ueAddr = ueAddr;

Ipv6Address

EpcSgwPgwApplication::UeInfo::GetUeAddr6 ()

  return m_ueAddr6;

100

101

102

void

103

EpcSgwPgwApplication::UeInfo::SetUeAddr6 (Ipv6Address ueAddr)

104

105

  m_ueAddr6 = ueAddr;

106

107

/////////////////////////

108

/////////////////////////

// EpcSgwPgwApplication

109

// EpcSgwPgwApplication

/////////////////////////

110

/////////////////////////

Lines 101-107	Link Here

101

115

102

  static TypeId tid = TypeId ("ns3::EpcSgwPgwApplication")

116

  static TypeId tid = TypeId ("ns3::EpcSgwPgwApplication")

103

    .SetParent<Object> ()

117

    .SetParent<Object> ()

104

    .SetGroupName("Lte");

118

    .SetGroupName("Lte")

119

    .AddTraceSource ("RxfromTun",

120

                     "Receive data packets from internet in Tunnel net device",

121

                     MakeTraceSourceAccessor (&EpcSgwPgwApplication::m_rxTunPktTrace),

122

                     "ns3::EpcSgwPgwApplication::RxTracedCallback")

123

    .AddTraceSource ("RxfromS1u",

124

                     "Receive data packets from S1 U Socket",

125

                     MakeTraceSourceAccessor (&EpcSgwPgwApplication::m_rxS1uPktTrace),

126

                     "ns3::EpcSgwPgwApplication::RxTracedCallback")

127

105

  return tid;

128

  return tid;

106

129

107

130

Lines 115-121	Link Here

115

138

116

139

117

140

118

119

EpcSgwPgwApplication::EpcSgwPgwApplication (const Ptr<VirtualNetDevice> tunDevice, const Ptr<Socket> s1uSocket)

141

EpcSgwPgwApplication::EpcSgwPgwApplication (const Ptr<VirtualNetDevice> tunDevice, const Ptr<Socket> s1uSocket)

120

  : m_s1uSocket (s1uSocket),

142

  : m_s1uSocket (s1uSocket),

121

    m_tunDevice (tunDevice),

143

    m_tunDevice (tunDevice),

Lines 139-171	Link Here

139

EpcSgwPgwApplication::RecvFromTunDevice (Ptr<Packet> packet, const Address& source, const Address& dest, uint16_t protocolNumber)

161

EpcSgwPgwApplication::RecvFromTunDevice (Ptr<Packet> packet, const Address& source, const Address& dest, uint16_t protocolNumber)

140

162

141

  NS_LOG_FUNCTION (this << source << dest << packet << packet->GetSize ());

163

  NS_LOG_FUNCTION (this << source << dest << packet << packet->GetSize ());

164

  m_rxTunPktTrace (packet->Copy ());

165

  Ptr<Packet> pCopy = packet->Copy ();

166

167

  uint8_t ipType;

168

  pCopy->CopyData (&ipType, 1);

169

  ipType = (ipType>>4) & 0x0f;

142

170

143

  // get IP address of UE

171

  // get IP address of UE

144

  Ptr<Packet> pCopy = packet->Copy ();

172

  if (ipType == 0x04)

145

  Ipv4Header ipv4Header;

173

146

  pCopy->RemoveHeader (ipv4Header);

174

      Ipv4Header ipv4Header;

147

  Ipv4Address ueAddr =  ipv4Header.GetDestination ();

175

      pCopy->RemoveHeader (ipv4Header);

148

  NS_LOG_LOGIC ("packet addressed to UE " << ueAddr);

176

      Ipv4Address ueAddr =  ipv4Header.GetDestination ();

149

177

      NS_LOG_LOGIC ("packet addressed to UE " << ueAddr);

150

  // find corresponding UeInfo address

178

      // find corresponding UeInfo address

151

  std::map<Ipv4Address, Ptr<UeInfo> >::iterator it = m_ueInfoByAddrMap.find (ueAddr);

179

      std::map<Ipv4Address, Ptr<UeInfo> >::iterator it = m_ueInfoByAddrMap.find (ueAddr);

152

  if (it == m_ueInfoByAddrMap.end ())

180

      if (it == m_ueInfoByAddrMap.end ())

153

181

154

      NS_LOG_WARN ("unknown UE address " << ueAddr);

182

          NS_LOG_WARN ("unknown UE address " << ueAddr);

183

184

      else

185

186

          Ipv4Address enbAddr = it->second->GetEnbAddr ();

187

          uint32_t teid = it->second->Classify (packet);

188

          if (teid == 0)

189

190

              NS_LOG_WARN ("no matching bearer for this packet");

191

192

          else

193

194

              SendToS1uSocket (packet, enbAddr, teid);

195

196

197

198

  else if (ipType == 0x06)

199

200

      Ipv6Header ipv6Header;

201

      pCopy->RemoveHeader (ipv6Header);

202

      Ipv6Address ueAddr =  ipv6Header.GetDestinationAddress ();

203

      NS_LOG_LOGIC ("packet addressed to UE " << ueAddr);

204

      // find corresponding UeInfo address

205

      std::map<Ipv6Address, Ptr<UeInfo> >::iterator it = m_ueInfoByAddrMap6.find (ueAddr);

206

      if (it == m_ueInfoByAddrMap6.end ())

207

208

          NS_LOG_WARN ("unknown UE address " << ueAddr);

209

210

      else

211

212

          Ipv4Address enbAddr = it->second->GetEnbAddr ();

213

          uint32_t teid = it->second->Classify (packet);

214

          if (teid == 0)

215

216

              NS_LOG_WARN ("no matching bearer for this packet");

217

218

          else

219

220

              SendToS1uSocket (packet, enbAddr, teid);

221

222

155

223

156

  else

224

  else

157

225

158

      Ipv4Address enbAddr = it->second->GetEnbAddr ();

226

      NS_ABORT_MSG ("EpcSgwPgwApplication::RecvFromTunDevice - Unknown IP type...");

159

      uint32_t teid = it->second->Classify (packet);

160

      if (teid == 0)

161

162

          NS_LOG_WARN ("no matching bearer for this packet");

163

164

      else

165

166

          SendToS1uSocket (packet, enbAddr, teid);

167

168

227

228

169

  // there is no reason why we should notify the TUN

229

  // there is no reason why we should notify the TUN

170

  // VirtualNetDevice that he failed to send the packet: if we receive

230

  // VirtualNetDevice that he failed to send the packet: if we receive

171

  // any bogus packet, it will just be silently discarded.

231

  // any bogus packet, it will just be silently discarded.

Lines 184-189	Link Here

184

  uint32_t teid = gtpu.GetTeid ();

244

  uint32_t teid = gtpu.GetTeid ();

185

245

186

  SendToTunDevice (packet, teid);

246

  SendToTunDevice (packet, teid);

247

248

  m_rxS1uPktTrace (packet->Copy ());

187

249

188

250

189

void

251

void

Lines 191-197	Link Here

191

253

192

  NS_LOG_FUNCTION (this << packet << teid);

254

  NS_LOG_FUNCTION (this << packet << teid);

193

  NS_LOG_LOGIC (" packet size: " << packet->GetSize () << " bytes");

255

  NS_LOG_LOGIC (" packet size: " << packet->GetSize () << " bytes");

194

  m_tunDevice->Receive (packet, 0x0800, m_tunDevice->GetAddress (), m_tunDevice->GetAddress (), NetDevice::PACKET_HOST);

256

257

  uint8_t ipType;

258

  packet->CopyData (&ipType, 1);

259

  ipType = (ipType>>4) & 0x0f;

260

261

  if (ipType == 0x04)

262

263

      m_tunDevice->Receive (packet, 0x0800, m_tunDevice->GetAddress (), m_tunDevice->GetAddress (), NetDevice::PACKET_HOST);

264

265

  else if (ipType == 0x06)

266

267

      m_tunDevice->Receive (packet, 0x86DD, m_tunDevice->GetAddress (), m_tunDevice->GetAddress (), NetDevice::PACKET_HOST);

268

269

  else

270

271

      NS_ABORT_MSG ("EpcSgwPgwApplication::SendToTunDevice - Unknown IP type...");

272

195

273

196

274

197

void

275

void

Lines 251-256	Link Here

251

329

252

330

253

void

331

void

332

EpcSgwPgwApplication::SetUeAddress6 (uint64_t imsi, Ipv6Address ueAddr)

333

334

  NS_LOG_FUNCTION (this << imsi << ueAddr);

335

  std::map<uint64_t, Ptr<UeInfo> >::iterator ueit = m_ueInfoByImsiMap.find (imsi);

336

  NS_ASSERT_MSG (ueit != m_ueInfoByImsiMap.end (), "unknown IMSI " << imsi);

337

  m_ueInfoByAddrMap6[ueAddr] = ueit->second;

338

  ueit->second->SetUeAddr6 (ueAddr);

339

340

341

void

254

EpcSgwPgwApplication::DoCreateSessionRequest (EpcS11SapSgw::CreateSessionRequestMessage req)

342

EpcSgwPgwApplication::DoCreateSessionRequest (EpcS11SapSgw::CreateSessionRequestMessage req)

255

343

256

  NS_LOG_FUNCTION (this << req.imsi);

344

  NS_LOG_FUNCTION (this << req.imsi);




   * internet over GTP-U/UDP/IP on the S1-U interface
   * \param s1uSocket socket used to send GTP-U packets to the eNBs
   */

  EpcSgwPgwApplication (const Ptr<VirtualNetDevice> tunDevice, const Ptr<Socket> s1uSocket);

  /** 

   */
  void SetUeAddress (uint64_t imsi, Ipv4Address ueAddr);

  /** 
   * set the address of a previously added UE
   * 
   * \param imsi the unique identifier of the UE
   * \param ueAddr the IPv6 address of the UE
   */
  void SetUeAddress6 (uint64_t imsi, Ipv6Address ueAddr);

  /**
   * TracedCallback signature for data Packet reception event.
   *
   * \param [in] packet The data packet sent from the internet.
   */
  typedef void (* RxTracedCallback)
    (Ptr<Packet> packet);

private:

  // S11 SAP SGW methods

    void SetEnbAddr (Ipv4Address addr);

    /** 
     * \return the IPv4 address of the UE
     */
    Ipv4Address GetUeAddr ();

    /** 
     * set the IPv4 address of the UE
     * 
     * \param addr the IPv4 address of the UE
     */
    void SetUeAddr (Ipv4Address addr);

    /**
     * \return the IPv6 address of the UE
     */
    Ipv6Address GetUeAddr6 ();

    /**
     * set the IPv6 address of the UE
     *
     * \param addr the IPv6 address of the UE
     */
    void SetUeAddr6 (Ipv6Address addr);

  private:
    EpcTftClassifier m_tftClassifier; ///< TFT classifier
    Ipv4Address m_enbAddr; ///< ENB IPv4 address
    Ipv4Address m_ueAddr; ///< UE IPv4 address
    Ipv6Address m_ueAddr6; ///< UE IPv6 address
    std::map<uint8_t, uint32_t> m_teidByBearerIdMap; ///< TEID By bearer ID Map
  };


  Ptr<VirtualNetDevice> m_tunDevice;

  /**
   * Map telling for each UE IPv4 address the corresponding UE info 
   */
  std::map<Ipv4Address, Ptr<UeInfo> > m_ueInfoByAddrMap;

  /**
   * Map telling for each UE IPv6 address the corresponding UE info 
   */
  std::map<Ipv6Address, Ptr<UeInfo> > m_ueInfoByAddrMap6;

  /**
   * Map telling for each IMSI the corresponding UE info 
   */
  std::map<uint64_t, Ptr<UeInfo> > m_ueInfoByImsiMap;

  /// EnbInfo structure
  struct EnbInfo
  {
    Ipv4Address enbAddr; ///< eNB IPv4 address
    Ipv4Address sgwAddr; ///< SGW IPV4 address
  };

  std::map<uint16_t, EnbInfo> m_enbInfoByCellId; ///< eNB info by cell ID

  /**
   * \brief Callback to trace RX (reception) data packets at Tun Net Device from internet.
   */
  TracedCallback<Ptr<Packet> > m_rxTunPktTrace;

  /**
   * \brief Callback to trace RX (reception) data packets from S1-U socket.
   */
  TracedCallback<Ptr<Packet> > m_rxS1uPktTrace;
};

} //namespace ns3




 *
 */




#include "epc-tft-classifier.h"
#include "epc-tft.h"
#include "ns3/log.h"
#include "ns3/packet.h"
#include "ns3/ipv4-header.h"
#include "ns3/ipv6-header.h"
#include "ns3/udp-header.h"
#include "ns3/tcp-header.h"
#include "ns3/udp-l4-protocol.h"
#include "ns3/tcp-l4-protocol.h"
#include "ns3/icmpv6-l4-protocol.h"
#include "ns3/icmpv4-l4-protocol.h"

namespace ns3 {



  Ptr<Packet> pCopy = p->Copy ();

  uint8_t ipType;
  pCopy->CopyData (&ipType, 1);
  ipType = (ipType>>4) & 0x0f;
  Ipv4Address localAddress;
  Ipv4Address remoteAddress;

  Ipv4Address localAddressIpv4;
  Ipv4Address remoteAddressIpv4;
    {
      localAddress = ipv4Header.GetSource ();
      remoteAddress = ipv4Header.GetDestination ();
    }
  else
    { 
      NS_ASSERT (direction ==  EpcTft::DOWNLINK);
      remoteAddress = ipv4Header.GetSource ();
      localAddress = ipv4Header.GetDestination ();      
    }
  
  uint8_t protocol = ipv4Header.GetProtocol ();

  Ipv6Address localAddressIpv6;
  Ipv6Address remoteAddressIpv6;

  uint8_t protocol;
  uint8_t tos;

  uint16_t localPort = 0;
  uint16_t remotePort = 0;

  if (ipType == 0x04)
    {
      Ipv4Header ipv4Header;
      pCopy->RemoveHeader (ipv4Header);

      if (direction ==  EpcTft::UPLINK)
        {
          localAddressIpv4 = ipv4Header.GetSource ();
          remoteAddressIpv4 = ipv4Header.GetDestination ();
        }
      else
        {
          NS_ASSERT (direction ==  EpcTft::DOWNLINK);
          remoteAddressIpv4 = ipv4Header.GetSource ();
          localAddressIpv4 = ipv4Header.GetDestination ();
        }
      NS_LOG_INFO ("local address: " << localAddressIpv4 << " remote address: " << remoteAddressIpv4);

      protocol = ipv4Header.GetProtocol ();
      tos = ipv4Header.GetTos ();
    }
  else if (ipType == 0x06)
    {
      Ipv6Header ipv6Header;
      pCopy->RemoveHeader (ipv6Header);

      if (direction ==  EpcTft::UPLINK)
        {
          localAddressIpv6 = ipv6Header.GetSourceAddress ();
          remoteAddressIpv6 = ipv6Header.GetDestinationAddress ();
        }
      else
        {
          NS_ASSERT (direction ==  EpcTft::DOWNLINK);
          remoteAddressIpv6 = ipv6Header.GetSourceAddress ();
          localAddressIpv6 = ipv6Header.GetDestinationAddress ();
        }
      NS_LOG_INFO ("local address: " << localAddressIpv6 << " remote address: " << remoteAddressIpv6);

      protocol = ipv6Header.GetNextHeader ();
      tos = ipv6Header.GetTrafficClass ();
    }
  else
    {
      NS_ABORT_MSG ("EpcTftClassifier::Classify - Unknown IP type...");
    }

  if (protocol == UdpL4Protocol::PROT_NUMBER)
    {
      UdpHeader udpHeader;
      pCopy->RemoveHeader (udpHeader);

      if (direction ==  EpcTft::UPLINK)
        {
          localPort = udpHeader.GetSourcePort ();
          remotePort = udpHeader.GetDestinationPort ();
        }
      else
        {
          remotePort = udpHeader.GetSourcePort ();
          localPort = udpHeader.GetDestinationPort ();
        }
    }
  else if (protocol == TcpL4Protocol::PROT_NUMBER)
    {
      TcpHeader tcpHeader;
      pCopy->RemoveHeader (tcpHeader);
      if (direction ==  EpcTft::UPLINK)
        {
          localPort = tcpHeader.GetSourcePort ();
          remotePort = tcpHeader.GetDestinationPort ();
        }
      else
        {
          remotePort = tcpHeader.GetSourcePort ();
          localPort = tcpHeader.GetDestinationPort ();
        }
    }
  else if (protocol == Icmpv6L4Protocol::PROT_NUMBER || protocol == Icmpv4L4Protocol::PROT_NUMBER)
    {
      remotePort = 0;
      localPort = 0;
    }
  else
    {

      return 0;  // no match
    }

  if (ipType == 0x04)
    {
      NS_LOG_INFO ("Classifying packet:"
          << " localAddr="  << localAddressIpv4
          << " remoteAddr=" << remoteAddressIpv4
          << " localPort="  << localPort
          << " remotePort=" << remotePort
          << " tos=0x" << (uint16_t) tos );

      // now it is possible to classify the packet!
      // we use a reverse iterator since filter priority is not implemented properly.
      // This way, since the default bearer is expected to be added first, it will be evaluated last.
      std::map <uint32_t, Ptr<EpcTft> >::const_reverse_iterator it;
      NS_LOG_LOGIC ("TFT MAP size: " << m_tftMap.size ());

      for (it = m_tftMap.rbegin (); it != m_tftMap.rend (); ++it)
        {
          NS_LOG_LOGIC ("TFT id: " << it->first );
          NS_LOG_LOGIC (" Ptr<EpcTft>: " << it->second);
          Ptr<EpcTft> tft = it->second;
          if (tft->Matches (direction, remoteAddressIpv4, localAddressIpv4, remotePort, localPort, tos))
            {
              NS_LOG_LOGIC ("matches with TFT ID = " << it->first);
              return it->first; // the id of the matching TFT
            }
        }
    }
  else if (ipType == 0x06)
    {
      NS_LOG_INFO ("Classifying packet:"
          << " localAddr="  << localAddressIpv6
          << " remoteAddr=" << remoteAddressIpv6
          << " localPort="  << localPort
          << " remotePort=" << remotePort
          << " tos=0x" << (uint16_t) tos );

      // now it is possible to classify the packet!
      // we use a reverse iterator since filter priority is not implemented properly.
      // This way, since the default bearer is expected to be added first, it will be evaluated last.
      std::map <uint32_t, Ptr<EpcTft> >::const_reverse_iterator it;
      NS_LOG_LOGIC ("TFT MAP size: " << m_tftMap.size ());

      for (it = m_tftMap.rbegin (); it != m_tftMap.rend (); ++it)
        {
          NS_LOG_LOGIC ("TFT id: " << it->first );
          NS_LOG_LOGIC (" Ptr<EpcTft>: " << it->second);
          Ptr<EpcTft> tft = it->second;
          if (tft->Matches (direction, remoteAddressIpv6, localAddressIpv6, remotePort, localPort, tos))
            {
              NS_LOG_LOGIC ("matches with TFT ID = " << it->first);
              return it->first; // the id of the matching TFT
            }
        }
    }
  NS_LOG_LOGIC ("no match");




 */
std::ostream& operator<< (std::ostream& os, EpcTft::Direction& d)
{
  switch (d)
  {
    case EpcTft::DOWNLINK:
      os << "DOWNLINK";
      break;

    default:
      os << "BIDIRECTIONAL";
      break;
  }
  return os;
}


std::ostream& operator<< (std::ostream& os, EpcTft::PacketFilter& f)
{
  os << " direction: " << f.direction
      << " remoteAddress: "  << f.remoteAddress
      << " remoteAddress6: "  << f.remoteAddress6
      << " remoteMask: "  << f.remoteMask
      << " localAddress: "  << f.localAddress
      << " localAddress6: "  << f.localAddress6
      << " localMask: "  << f.localMask
      << " remotePortStart: "   << f.remotePortStart
      << " remotePortEnd: "   << f.remotePortEnd
      << " localPortStart: "   << f.localPortStart
      << " localPortEnd: "   << f.localPortEnd
      << " typeOfService: 0x" << std::hex << (uint16_t) f.typeOfService << std::dec
      << " typeOfServiceMask: 0x" << std::hex << (uint16_t) f.typeOfServiceMask << std::dec;
  return os;
}

EpcTft::PacketFilter::PacketFilter ()
: precedence (255),
  direction (BIDIRECTIONAL),
  remoteMask ("0.0.0.0"),
  localMask ("0.0.0.0"),
  remotePortStart (0),
  remotePortEnd (65535),
  localPortStart (0),
  localPortEnd (65535),
  typeOfService (0),
  typeOfServiceMask (0)
{
  NS_LOG_FUNCTION (this);
}

bool 
EpcTft::PacketFilter::Matches (Direction d,
                               Ipv4Address ra,
                               Ipv4Address la,
                               uint16_t rp,
                               uint16_t lp,
                               uint8_t tos)
{
  NS_LOG_FUNCTION (this << d << ra << la << rp << lp << (uint16_t) tos);
  if (d & direction)
    {
      NS_LOG_LOGIC ("d matches");
      if (remoteMask.IsMatch (remoteAddress, ra))
        {
          NS_LOG_LOGIC ("ra matches");
          if (localMask.IsMatch (localAddress, la))
            {
              NS_LOG_LOGIC ("ls matches");
              if (rp >= remotePortStart)
                {
                  NS_LOG_LOGIC ("rps matches");
                  if (rp <= remotePortEnd)
                    {
                      NS_LOG_LOGIC ("rpe matches");
                      if (lp >= localPortStart)
                        {
                          NS_LOG_LOGIC ("lps matches");
                          if (lp <= localPortEnd)
                            {
                              NS_LOG_LOGIC ("lpe matches");
                              if ((tos & typeOfServiceMask) == (typeOfService & typeOfServiceMask))
                                {
                                  NS_LOG_LOGIC ("tos matches --> have match!");
                                  return true;
                                }
                            }
                        }
                    }
                }
            }
          else
            {
              NS_LOG_LOGIC ("la doesn't match: la=" << la << " f.la=" << localAddress << " f.lmask=" << localMask);
            }
        }
      else
        {
          NS_LOG_LOGIC ("ra doesn't match: ra=" << ra << " f.ra=" << remoteAddress << " f.rmask=" << remoteMask);
        }
    }
  else
    {
      NS_LOG_LOGIC ("d doesn't match: d=0x" << std::hex << d << " f.d=0x" << std::hex << direction << std::dec);
    }
  return false;      
}

bool 
EpcTft::PacketFilter::Matches (Direction d,
                               Ipv6Address ra,
                               Ipv6Address la,
                               uint16_t rp,
                               uint16_t lp,
                               uint8_t tos)
{
  NS_LOG_FUNCTION (this << d << ra << la << rp << lp << (uint16_t) tos);
  if (d & direction)
    {
      NS_LOG_LOGIC ("d matches");
      if (rp >= remotePortStart)
        {
          NS_LOG_LOGIC ("rps matches");
          if (rp <= remotePortEnd)
            {
              NS_LOG_LOGIC ("rpe matches");
              if (lp >= localPortStart)
                {
                  NS_LOG_LOGIC ("lps matches");
                  if (lp <= localPortEnd)
                    {
                      NS_LOG_LOGIC ("lpe matches");
                      if ((tos & typeOfServiceMask) == (typeOfService & typeOfServiceMask))
                        {
                          NS_LOG_LOGIC ("tos matches --> have match!");
                          return true;
                        }
                    }
                }
            }


          else
            {
              NS_LOG_LOGIC ("la doesn't match: la=" << la << " f.la=" << localAddress << " f.lmask=" << localMask);
            }
        }
      else
        {
          NS_LOG_LOGIC ("ra doesn't match: ra=" << ra << " f.ra=" << remoteAddress << " f.rmask=" << remoteMask);
        }
    }
  else
    {



EpcTft::EpcTft ()
: m_numFilters (0)
{
  NS_LOG_FUNCTION (this);
}

{
  NS_LOG_FUNCTION (this << f);
  NS_ABORT_IF (m_numFilters >= 16);

  std::list<PacketFilter>::iterator it;
  for (it = m_filters.begin ();
      (it != m_filters.end ()) && (it->precedence <= f.precedence);
      ++it)
    {
    }  
  m_filters.insert (it, f);  
  ++m_numFilters;
  return (m_numFilters - 1);
}

bool 
EpcTft::Matches (Direction direction,
                 Ipv4Address remoteAddress,
                 Ipv4Address localAddress,
                 uint16_t remotePort,
                 uint16_t localPort,
                 uint8_t typeOfService)
{
  NS_LOG_FUNCTION (this << direction << remoteAddress << localAddress << std::dec << remotePort << localPort << (uint16_t) typeOfService);
  for (std::list<PacketFilter>::iterator it = m_filters.begin ();
      it != m_filters.end ();
      ++it)
    {
      if (it->Matches (direction, remoteAddress, localAddress, remotePort, localPort, typeOfService))
        {
          return true;
        }
    }  
  return false;
}

bool 
EpcTft::Matches (Direction direction,
                 Ipv6Address remoteAddress,
                 Ipv6Address localAddress,
                 uint16_t remotePort,
                 uint16_t localPort,
                 uint8_t typeOfService)
{
  NS_LOG_FUNCTION (this << direction << remoteAddress << localAddress << std::dec << remotePort << localPort << (uint16_t) typeOfService);
  for (std::list<PacketFilter>::iterator it = m_filters.begin ();
      it != m_filters.end ();
      ++it)
    {
      if (it->Matches (direction, remoteAddress, localAddress, remotePort, localPort, typeOfService))
        {
          return true;
        }
    }  
  return false;
}





#include <ns3/simple-ref-count.h>
#include <ns3/ipv4-address.h>
#include <ns3/ipv6-address.h>

#include <list>


     */
    bool Matches (Direction d,
		  Ipv4Address ra, 
		  Ipv4Address la,
		  uint16_t rp,
		  uint16_t lp,
		  uint8_t tos);

    /** 
     * 
     * \param d the direction 
     * \param ra the remote address 
     * \param la the local address 
     * \param rp the remote port 
     * \param lp the local port 
     * \param tos the type of service 
     * 
     * \return true if the parameters match with the PacketFilter,
     * false otherwise.
     */
    bool Matches (Direction d,
		  Ipv6Address ra, 
		  Ipv6Address la,
		  uint16_t rp,
		  uint16_t lp,
		  uint8_t tos);

			    to uplink / downlink only, or in both cases*/

    Ipv4Address remoteAddress;     /**< IPv4 address of the remote host  */
    Ipv6Address remoteAddress6;     /**< IPv6 address of the remote host  */
    Ipv4Mask remoteMask;            /**< IPv4 address mask of the remote host */
    Ipv4Address localAddress;       /**< IPv4 address of the UE */
    Ipv6Address localAddress6;      /**< IPv6 address of the UE */
    Ipv4Mask localMask;  /**< IPv4 address mask of the UE */
  
    uint16_t remotePortStart;  /**< start of the port number range of the remote host */

     * parameters, false otherwise.
     */
    bool Matches (Direction direction,
		  Ipv4Address remoteAddress,
		  Ipv4Address localAddress,
		  uint16_t remotePort,
		  uint16_t localPort,
		  uint8_t typeOfService);

    /** 
     * 
     * \param direction 
     * \param remoteAddress 
     * \param localAddress 
     * \param remotePort 
     * \param localPort 
     * \param typeOfService 
     * 
     * \return true if any PacketFilter in the TFT matches with the
     * parameters, false otherwise.
     */
    bool Matches (Direction direction,
		  Ipv6Address remoteAddress,
		  Ipv6Address localAddress,
		  uint16_t remotePort,
		  uint16_t localPort,
		  uint8_t typeOfService);

(-)a/src/lte/model/lte-enb-net-device.cc (-1 / +2 lines)

Lines 43-48	Link Here

#include <ns3/lte-anr.h>

#include <ns3/lte-anr.h>

#include <ns3/lte-ffr-algorithm.h>

#include <ns3/lte-ffr-algorithm.h>

#include <ns3/ipv4-l3-protocol.h>

#include <ns3/ipv4-l3-protocol.h>

#include <ns3/ipv6-l3-protocol.h>

#include <ns3/abort.h>

#include <ns3/abort.h>

#include <ns3/log.h>

#include <ns3/log.h>

#include <ns3/lte-enb-component-carrier-manager.h>

#include <ns3/lte-enb-component-carrier-manager.h>

Lines 387-393	Link Here

387

LteEnbNetDevice::Send (Ptr<Packet> packet, const Address& dest, uint16_t protocolNumber)

388

LteEnbNetDevice::Send (Ptr<Packet> packet, const Address& dest, uint16_t protocolNumber)

388

389

  NS_LOG_FUNCTION (this << packet   << dest << protocolNumber);

390

  NS_LOG_FUNCTION (this << packet   << dest << protocolNumber);

390

  NS_ASSERT_MSG (protocolNumber == Ipv4L3Protocol::PROT_NUMBER, "unsupported protocol " << protocolNumber << ", only IPv4 is supported");

391

  NS_ASSERT_MSG (protocolNumber == Ipv4L3Protocol::PROT_NUMBER || protocolNumber == Ipv6L3Protocol::PROT_NUMBER, "unsupported protocol " << protocolNumber << ", only IPv4/IPv6 is supported");

391

  return m_rrc->SendData (packet);

392

  return m_rrc->SendData (packet);

392

393

394




#include "ns3/enum.h"
#include "lte-amc.h"
#include "ns3/ipv4-header.h"
#include "ns3/ipv6-header.h"
#include <ns3/lte-radio-bearer-tag.h>
#include <ns3/ipv4-l3-protocol.h>
#include <ns3/ipv6-l3-protocol.h>
#include <ns3/log.h>

namespace ns3 {

LteNetDevice::Receive (Ptr<Packet> p)
{
  NS_LOG_FUNCTION (this << p);
  uint8_t ipType;

  p->CopyData (&ipType, 1);
  ipType = (ipType>>4) & 0x0f;

  if (ipType == 0x04)
    m_rxCallback (this, p, Ipv4L3Protocol::PROT_NUMBER, Address ());
  else if (ipType == 0x06)
    m_rxCallback (this, p, Ipv6L3Protocol::PROT_NUMBER, Address ());
  else
    NS_ABORT_MSG ("LteNetDevice::Receive - Unknown IP type...");
}






#include "lte-ue-mac.h"
#include "lte-ue-rrc.h"
#include "ns3/ipv4-header.h"
#include "ns3/ipv6-header.h"
#include "ns3/ipv4.h"
#include "ns3/ipv6.h"
#include "lte-amc.h"
#include "lte-ue-phy.h"
#include "epc-ue-nas.h"
#include <ns3/ipv4-l3-protocol.h>
#include <ns3/ipv6-l3-protocol.h>
#include <ns3/log.h>
#include "epc-tft.h"
#include <ns3/lte-ue-component-carrier-manager.h>

LteUeNetDevice::Send (Ptr<Packet> packet, const Address& dest, uint16_t protocolNumber)
{
  NS_LOG_FUNCTION (this << dest << protocolNumber);
  if (protocolNumber != Ipv4L3Protocol::PROT_NUMBER && protocolNumber != Ipv6L3Protocol::PROT_NUMBER)
    {
      NS_LOG_INFO ("unsupported protocol " << protocolNumber << ", only IPv4 and IPv6 are supported");
      return true;
    }  
  return m_nas->Send (packet);




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2017 Jadavpur University, India
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Manoj Kumar Rana <manoj24.rana@gmail.com>
 */

#include "ns3/lte-helper.h"
#include "ns3/epc-helper.h"
#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/ipv4-global-routing-helper.h"
#include "ns3/ipv6-static-routing.h"
#include "ns3/internet-module.h"
#include "ns3/mobility-module.h"
#include "ns3/lte-module.h"
#include "ns3/applications-module.h"
#include "ns3/point-to-point-helper.h"
#include "ns3/config-store.h"
#include <algorithm>


/* *
   * Scenario:  3 UEs, 2 ENBs, 1 Remote Host, UE0<-->ENB0, UE1<-->ENB0, UE2<-->ENB1
                Servers: UE1, UE2, Remote Host
                Client: UE0 (3 clients)
                UDP Echo Packets transmitted between client and server

   * Pass criteria: 1) Every UDP Echo Request and Reply messages sent and received respectively
                       at UE0 must be matched by their UID, source address, destination address,
                       source port and destination port
                    2) Every request reply must follow proper route (e.g. In case of UE0->UE1,
                       packet must travel this route: UE0->ENB0->PGW->ENB1->UE1->ENB1->PGW->ENB0->UE0)
                    3) The above check also ensures no redundancy of the followed route for a packet
* */



using namespace ns3;

class LteIpv6RoutingTestCase : public TestCase
{
public:
  LteIpv6RoutingTestCase ();
  virtual ~LteIpv6RoutingTestCase ();

  /**
   * \brief Initialize testing parameters.
   */
  void Checker ();

  /**
   * \brief sent Packets from client's IPv6 interface.
   * \param: p packet
   * \param: ipv6 Ipv6 object
   * \param: interface Ipv6interface from which the packet is transmitted
   */
  void SentAtClient (Ptr<const Packet> p, Ptr<Ipv6> ipv6, uint32_t interface);

  /**
   * \brief Received Packets at client's IPv6 interface.
   * \param: p packet
   * \param: ipv6 Ipv6 object
   * \param: interface Ipv6interface at which the packet is received
   */
  void ReceivedAtClient (Ptr<const Packet> p, Ptr<Ipv6> ipv6, uint32_t interface);

  /**
   * \brief Received Packet at pgw from enb.
   * \param: p packet
   */
  void EnbToPgw (Ptr<Packet> p);

  /**
   * \brief Received Packet at pgw from enb.
   * \param: p packet
   */
  void TunToPgw (Ptr<Packet> p);

  /**
   * \brief search uid in a list and delete if found.
   * \param: l list
   * \param: item a uid
   */
  bool SearchAndDelete (std::list<uint64_t> *l, uint64_t item);


private:
  virtual void DoRun (void);
  Ipv6InterfaceContainer ueIpIface; //IPv6 interface container for ue
  Ipv6Address remoteHostAddr; //remote host address
  std::list<uint64_t> * EnbPgw; //list of uids of packets received at pgw from enb
  std::list<uint64_t> * TunPgw; //list of uids of packets received at pgw from tunnel net device

  std::list<Ptr<Packet> > ClientSent; //list of sent packets from client
  std::list<Ptr<Packet> > ClientReceived; //list of received packets at client
};


LteIpv6RoutingTestCase::LteIpv6RoutingTestCase ()
  : TestCase ("Test IPv6 Routing at LTE")
{
  EnbPgw = new std::list<uint64_t>;
  TunPgw = new std::list<uint64_t>;
}

LteIpv6RoutingTestCase::~LteIpv6RoutingTestCase ()
{
}

void LteIpv6RoutingTestCase::SentAtClient (Ptr<const Packet> p, Ptr<Ipv6> ipv6, uint32_t interface)
{
  Ipv6Header ipv6Header;
  p->PeekHeader (ipv6Header);
  if (ipv6Header.GetNextHeader () == UdpL4Protocol::PROT_NUMBER)
    {
      ClientSent.push_back (p->Copy ());
    }
}

void LteIpv6RoutingTestCase::ReceivedAtClient (Ptr<const Packet> p, Ptr<Ipv6> ipv6, uint32_t interface)
{
  Ipv6Header ipv6Header;
  p->PeekHeader (ipv6Header);
  if (ipv6Header.GetNextHeader () == UdpL4Protocol::PROT_NUMBER)
    {
      ClientReceived.push_back (p->Copy ());
    }
}

void LteIpv6RoutingTestCase::EnbToPgw (Ptr<Packet> p)
{
  Ipv6Header ipv6Header;
  p->PeekHeader (ipv6Header);
  if (ipv6Header.GetNextHeader () == UdpL4Protocol::PROT_NUMBER)
    {
      EnbPgw->push_back (p->GetUid ());
    }
}

void LteIpv6RoutingTestCase::TunToPgw (Ptr<Packet> p)
{
  Ipv6Header ipv6Header;
  p->PeekHeader (ipv6Header);
  if (ipv6Header.GetNextHeader () == UdpL4Protocol::PROT_NUMBER)
    {
      TunPgw->push_back (p->GetUid ());
    }
}

bool LteIpv6RoutingTestCase::SearchAndDelete (std::list<uint64_t> *l, uint64_t item)
{
  bool b = false;
  std::list<uint64_t>::iterator it;
  it = std::find (l->begin (), l->end (), item);
  if (it != l->end ())
    {
      b = true;
      l->erase (it);
    }
  return b;
}

void LteIpv6RoutingTestCase::Checker ()
{
  bool b = false;
  bool check = true;
  //Extract each received reply packet of the client
  for (std::list<Ptr<Packet> >::iterator it1 = ClientReceived.begin (); it1 != ClientReceived.end (); it1++)
    {
      Ipv6Header ipv6header1;
      UdpHeader udpHeader1;
      Ptr<Packet> p1 = (*it1)->Copy ();
      p1->RemoveHeader (ipv6header1);
      uint64_t uid = p1->GetUid ();
      p1->RemoveHeader (udpHeader1);
      //Search each packet in list of sent request packet of the client
      for (std::list<Ptr<Packet> >::iterator it2 = ClientSent.begin (); it2 != ClientSent.end (); it2++)
        {
          Ptr<Packet> p2 = (*it2)->Copy ();
          Ipv6Header ipv6header2;
          p2->RemoveHeader (ipv6header2);
          Ipv6Address sorceAddress = ipv6header2.GetSourceAddress ();
          Ipv6Address destinationAddress = ipv6header2.GetDestinationAddress ();
          UdpHeader udpHeader2;
          p2->RemoveHeader (udpHeader2);
          uint16_t sourcePort;
          uint16_t destinationPort;
          sourcePort = udpHeader2.GetSourcePort ();
          destinationPort = udpHeader2.GetDestinationPort ();
          //Check whether the uids, addresses and ports match
          if ((p2->GetUid () == p1->GetUid ()) && sorceAddress.IsEqual (ipv6header1.GetDestinationAddress ()) && destinationAddress.IsEqual (ipv6header1.GetSourceAddress ()) && sourcePort == udpHeader1.GetDestinationPort () && destinationPort == udpHeader1.GetSourcePort ())
            {
              b = true;
              break;
            }
        }
      check &= b;
      if (ipv6header1.GetSourceAddress ().IsEqual (remoteHostAddr))
        {
          check &= (SearchAndDelete (EnbPgw, uid) && SearchAndDelete (TunPgw, uid));
        }
      else
        {
          check &= (SearchAndDelete (EnbPgw, uid) && SearchAndDelete (TunPgw, uid) && SearchAndDelete (EnbPgw, uid) && SearchAndDelete (TunPgw, uid));
        }

      b = false;
    }

  NS_TEST_ASSERT_MSG_EQ (check, true, "Failure Happens IPv6 routing of LENA");
  NS_TEST_ASSERT_MSG_EQ (ClientSent.size (), ClientReceived.size (), "No. of Request and Reply messages mismatch");
  NS_TEST_ASSERT_MSG_EQ (EnbPgw->size (), 0, "Route is not Redundant in Lte IPv6 test");
  NS_TEST_ASSERT_MSG_EQ (TunPgw->size (), 0, "Route is not Redundant in Lte IPv6 test");

}

void
LteIpv6RoutingTestCase::DoRun (void)
{
  double distance = 60.0;

  Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();
  Ptr<PointToPointEpcHelper>  epcHelper = CreateObject<PointToPointEpcHelper> ();
  lteHelper->SetEpcHelper (epcHelper);

  ConfigStore inputConfig;
  inputConfig.ConfigureDefaults ();

  Ptr<Node> pgw = epcHelper->GetPgwNode ();

  // Create a single RemoteHost
  NodeContainer remoteHostContainer;
  remoteHostContainer.Create (1);
  Ptr<Node> remoteHost = remoteHostContainer.Get (0);
  InternetStackHelper internet;
  internet.Install (remoteHostContainer);

  // Create the Internet
  PointToPointHelper p2ph;
  p2ph.SetDeviceAttribute ("DataRate", DataRateValue (DataRate ("100Gb/s")));
  p2ph.SetDeviceAttribute ("Mtu", UintegerValue (1500));
  p2ph.SetChannelAttribute ("Delay", TimeValue (Seconds (0.010)));
  NetDeviceContainer internetDevices = p2ph.Install (pgw, remoteHost);

  NodeContainer ueNodes;
  NodeContainer enbNodes;
  enbNodes.Create (2);
  ueNodes.Create (3);

  // Install Mobility Model
  Ptr<ListPositionAllocator> positionAlloc1 = CreateObject<ListPositionAllocator> ();
  Ptr<ListPositionAllocator> positionAlloc2 = CreateObject<ListPositionAllocator> ();

  positionAlloc1->Add (Vector (distance * 0, 0, 0));
  positionAlloc1->Add (Vector (distance * 0 + 5, 0, 0));
  positionAlloc1->Add (Vector (distance * 1, 0, 0));

  positionAlloc2->Add (Vector (distance * 0, 0, 0));
  positionAlloc2->Add (Vector (distance * 1, 0, 0));

  MobilityHelper mobility;
  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
  mobility.SetPositionAllocator (positionAlloc1);
  mobility.Install (ueNodes);

  mobility.SetPositionAllocator (positionAlloc2);
  mobility.Install (enbNodes);

  // Install the IP stack on the UEs
  internet.Install (ueNodes);

  // Install LTE Devices to the nodes
  NetDeviceContainer enbLteDevs = lteHelper->InstallEnbDevice (enbNodes);
  NetDeviceContainer ueLteDevs = lteHelper->InstallUeDevice (ueNodes);



  for (NetDeviceContainer::Iterator it = ueLteDevs.Begin (); it != ueLteDevs.End (); ++it)
    {
      (*it)->SetAddress (Mac64Address::Allocate ());
    }

  // Assign IP address to UEs, and install applications
  ueIpIface = epcHelper->AssignUeIpv6Address (NetDeviceContainer (ueLteDevs));


  Ipv6StaticRoutingHelper ipv6RoutingHelper;

  for (uint32_t u = 0; u < ueNodes.GetN (); ++u)
    {
      Ptr<Node> ueNode = ueNodes.Get (u);
      // Set the default gateway for the UE
      Ptr<Ipv6StaticRouting> ueStaticRouting = ipv6RoutingHelper.GetStaticRouting (ueNode->GetObject<Ipv6> ());
      ueStaticRouting->SetDefaultRoute (epcHelper->GetUeDefaultGatewayAddress6 (), 1);
    }


  // Attach two UEs at first eNodeB and one UE at second eNodeB
  lteHelper->Attach (ueLteDevs.Get (0), enbLteDevs.Get (0));
  lteHelper->Attach (ueLteDevs.Get (1), enbLteDevs.Get (0));
  lteHelper->Attach (ueLteDevs.Get (2), enbLteDevs.Get (1));


  Ipv6AddressHelper ipv6h;
  ipv6h.SetBase (Ipv6Address ("6001:db80::"), Ipv6Prefix (64));
  Ipv6InterfaceContainer internetIpIfaces = ipv6h.Assign (internetDevices);

  internetIpIfaces.SetForwarding (0, true);
  internetIpIfaces.SetDefaultRouteInAllNodes (0);


  Ptr<Ipv6StaticRouting> remoteHostStaticRouting = ipv6RoutingHelper.GetStaticRouting (remoteHost->GetObject<Ipv6> ());
  remoteHostStaticRouting->AddNetworkRouteTo ("7777:f00d::", Ipv6Prefix (64), internetIpIfaces.GetAddress (0, 1), 1, 0);


  // interface 0 is localhost, 1 is the p2p device
  remoteHostAddr = internetIpIfaces.GetAddress (1, 1);


  // Install and start applications on UEs and remote host
  UdpEchoServerHelper echoServer1 (10);
  UdpEchoServerHelper echoServer2 (11);
  UdpEchoServerHelper echoServer3 (12);

  ApplicationContainer serverApps = echoServer1.Install (remoteHost);
  serverApps.Add (echoServer2.Install (ueNodes.Get (1)));
  serverApps.Add (echoServer3.Install (ueNodes.Get (2)));


  serverApps.Start (Seconds (4.0));
  serverApps.Stop (Seconds (12.0));


  UdpEchoClientHelper echoClient1 (remoteHostAddr, 10);
  UdpEchoClientHelper echoClient2 (ueIpIface.GetAddress (1,1), 11);
  UdpEchoClientHelper echoClient3 (ueIpIface.GetAddress (2,1), 12);

  echoClient1.SetAttribute ("MaxPackets", UintegerValue (1000));
  echoClient1.SetAttribute ("Interval", TimeValue (Seconds (0.2)));
  echoClient1.SetAttribute ("PacketSize", UintegerValue (1024));

  echoClient2.SetAttribute ("MaxPackets", UintegerValue (1000));
  echoClient2.SetAttribute ("Interval", TimeValue (Seconds (0.2)));
  echoClient2.SetAttribute ("PacketSize", UintegerValue (1024));

  echoClient3.SetAttribute ("MaxPackets", UintegerValue (1000));
  echoClient3.SetAttribute ("Interval", TimeValue (Seconds (0.2)));
  echoClient3.SetAttribute ("PacketSize", UintegerValue (1024));

  ApplicationContainer clientApps1 = echoClient1.Install (ueNodes.Get (0));
  ApplicationContainer clientApps2 = echoClient2.Install (ueNodes.Get (0));
  ApplicationContainer clientApps3 = echoClient3.Install (ueNodes.Get (0));

  clientApps1.Start (Seconds (4.0));
  clientApps1.Stop (Seconds (6.0));

  clientApps2.Start (Seconds (6.1));
  clientApps2.Stop (Seconds (8.0));

  clientApps3.Start (Seconds (8.1));
  clientApps3.Stop (Seconds (10.0));

  EnbPgw = new std::list<uint64_t>;
  TunPgw = new std::list<uint64_t>;

  //Set Cllback for Client Sent and Received packets
  Ptr<Ipv6L3Protocol> ipl3 = (ueNodes.Get (0))->GetObject<Ipv6L3Protocol> ();
  ipl3->TraceConnectWithoutContext ("Tx", MakeCallback (&LteIpv6RoutingTestCase::SentAtClient, this));
  ipl3->TraceConnectWithoutContext ("Rx", MakeCallback (&LteIpv6RoutingTestCase::ReceivedAtClient, this));

  //Set Callback at SgwPgWApplication of epc to get the packets from enb and from tunnel net device
  Ptr<Application> apppgw = pgw->GetApplication (0);
  apppgw->TraceConnectWithoutContext ("RxfromS1u", MakeCallback (&LteIpv6RoutingTestCase::EnbToPgw, this));
  apppgw->TraceConnectWithoutContext ("RxfromTun", MakeCallback (&LteIpv6RoutingTestCase::TunToPgw, this));

  Simulator::Schedule (Time (Seconds (12.0)), &LteIpv6RoutingTestCase::Checker, this);

  Simulator::Stop (Seconds (14));
  Simulator::Run ();

  Simulator::Destroy ();
}


/**
 * \brief test suite 1
 */
class LteIpv6RoutingTestSuite : public TestSuite
{
public:
  LteIpv6RoutingTestSuite ();
};

LteIpv6RoutingTestSuite::LteIpv6RoutingTestSuite ()
  : TestSuite ("lte-ipv6-routing-test", UNIT)
{
  AddTestCase (new LteIpv6RoutingTestCase, TestCase::QUICK);
}

static LteIpv6RoutingTestSuite lteipv6testsuite;

(-)a/src/lte/wscript (+1 lines)

Lines 191-196	Link Here

191

        'test/lte-simple-spectrum-phy.cc',

191

        'test/lte-simple-spectrum-phy.cc',

192

        'test/lte-test-carrier-aggregation.cc',

192

        'test/lte-test-carrier-aggregation.cc',

193

        'test/lte-test-aggregation-throughput-scale.cc',

193

        'test/lte-test-aggregation-throughput-scale.cc',

194

        'test/lte-test-ipv6-routing.cc'

194

195

196

    headers = bld(features='ns3header')

197

    headers = bld(features='ns3header')

Return to bug 2312