Attachment #2979 for bug #2312

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





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

 #. The Packet Data Network (PDN) type supported is both IPv4 and IPv6.
 #. The SGW and PGW functional entities are implemented within a single
    node, which is hence referred to as the SGW/PGW node.
 #. The scenarios with inter-SGW mobility are not of interests. Hence, a

IP networking. The first one is the end-to-end layer, which provides end-to-end 
connectivity to the users; this layers involves the UEs, the PGW and
the remote host (including eventual internet routers and hosts in
between), but does not involve the eNB. In this version of LTE, the EPC
supports both IPv4 and IPv6 type users. The 3GPP unique 64 bit IPv6 prefix
allocation process for each UE and PGW is followed here. Each EPC is assigned
an unique 16 bit IPv4 and a 48 bit IPv6 network address from the pool of
7.0.0.0/8 and 7777:f00d::/32 respectively. In the end-to-end IP connection
between UE and PGW, all addresses are configured using these prefixes.
These default values could also be changed from user script by setting
the attribute, defined in the helper classes. It increases the readability
of the user defined topology. As the first 16 bit (ipv4 type) or, 48 bit (ipv6
type) prefixes differs from one EPC to another, the routing path towards
different EPC network from internet also becomes unique and easy to set up.
The PGW's address is used by all UEs as the gateway to reach the internet. 

The second layer of IP networking is the EPC local area network. This
involves all eNB nodes and the SGW/PGW node. This network is


To begin with, we consider the case of the downlink, which is depicted
in Figure :ref:`fig-epc-data-flow-dl`.   
Downlink Ipv4/Ipv6 packets are generated from a generic remote host, and
addressed to one of the UE device. Internet routing will take care of
forwarding the packet to the generic NetDevice of the SGW/PGW node
which is connected to the internet (this is the Gi interface according
to 3GPP terminology). The SGW/PGW has a VirtualNetDevice which is
assigned the base IPv4 address of the EPC network; hence, static
routing rules will cause the incoming packet from the internet to be
routed through this VirtualNetDevice. In case of IPv6 address as destination,
a manual route towards the VirtualNetDevice is inserted in the routing table,
containg the 48 bit IPv6 prefix from which all the IPv6 addresses of the UEs
and PGW are configured. Such device starts the GTP/UDP/IP tunneling procedure,
by forwarding the packet to a dedicated application in the SGW/PGW  node which
is called EpcSgwPgwApplication. This application does the following operations:

 #. it determines the eNB node to which the UE is attached, by looking
    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 (epcHelper->GetEpcIpv6NetworkAddress (), Ipv6Prefix (48), 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 (epcHelper->GetEpcIpv6NetworkAddress (), Ipv6Prefix (48), 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 (epcHelper->GetEpcIpv6NetworkAddress (), Ipv6Prefix (48), 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 (-20 / +137 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 91-124	Link Here

                   StringValue ("00:00:00:eb:00"),

                   StringValue ("00:00:00:eb:00"),

                   MakeStringAccessor (&EmuEpcHelper::m_enbMacAddressBase),

                   MakeStringAccessor (&EmuEpcHelper::m_enbMacAddressBase),

                   MakeStringChecker ())

                   MakeStringChecker ())

    .AddAttribute ("BaseIpv4Prefix",

100

                   "The 8 bit IPv4 prefix to be used for the assignment of IPv4 addresses to pgw and ue.",

101

                   Ipv4AddressValue (Ipv4Address ("7.0.0.0")),

102

                   MakeIpv4AddressAccessor (&EmuEpcHelper::m_uePgwbaseipv4prefix8),

103

                   MakeIpv4AddressChecker ())

104

    .AddAttribute ("BaseIpv6Prefix",

105

                   "The 48 bit IPv6 prefix to be used for the assignment of IPv6 addresses to pgw and ue.",

106

                   Ipv6AddressValue (Ipv6Address ("7777:f00d:cafe::")),

107

                   MakeIpv6AddressAccessor (&EmuEpcHelper::m_uePgwbaseipv6prefix32),

108

                   MakeIpv6AddressChecker ())

109

  return tid;

110

  return tid;

111

112

113

TypeId

114

EmuEpcHelper::GetInstanceTypeId () const

115

116

  return GetTypeId ();

117

118

void

119

void

EmuEpcHelper::DoInitialize ()

120

EmuEpcHelper::DoInitialize ()

100

121

101

  NS_LOG_LOGIC (this);

122

  NS_LOG_LOGIC (this);

102

123

124

  // we use a /16 bit IPv4 net for an EPC network

125

  m_uePgwbaseipv4prefix16 = m_uePgwbaseipv4prefix8.CombineMask (Ipv4Mask ("255.0.0.0")); //Initialize

126

  Ipv4AddressGenerator::Init (m_uePgwbaseipv4prefix16, Ipv4Mask ("255.255.0.0"));

103

127

104

  // we use a /8 net for all UEs

128

  Ipv4AddressGenerator::TestMode ();

105

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

129

  while (!(Ipv4AddressGenerator::AddAllocated (Ipv4AddressGenerator::GetNetwork (Ipv4Mask ("255.255.0.0")))))

130

    m_uePgwbaseipv4prefix16 = Ipv4AddressGenerator::NextNetwork (Ipv4Mask ("255.255.0.0"));

131

  m_uePgwAddressHelper.SetBase (m_uePgwbaseipv4prefix16, "255.255.0.0");  //The helper will assign IPv4 addresses using this 16 bit prefix

132

  //Now we get an unique 16 bit IPv4 prefix for this EPC, which not used by any other EPC

106

133

107

134

108

135

  // we use a /48 IPv6 net for an EPC network

136

  m_uePgwbaseipv6prefix48 = m_uePgwbaseipv6prefix32.CombinePrefix (Ipv6Prefix (32)); //Initialize

137

  Ipv6AddressGenerator::Init (m_uePgwbaseipv6prefix48, Ipv6Prefix (48));

138

  Ipv6AddressGenerator::TestMode ();

139

140

  while (!(Ipv6AddressGenerator::AddAllocated (Ipv6AddressGenerator::GetNetwork (Ipv6Prefix (48)))))

141

    m_uePgwbaseipv6prefix48 = Ipv6AddressGenerator::NextNetwork (Ipv6Prefix (48));

142

  //Now we get an unique 48 bit IPv6 prefix for this EPC, which not used by any other EPC

143

144

109

  // create SgwPgwNode

145

  // create SgwPgwNode

110

  m_sgwPgw = CreateObject<Node> ();

146

  m_sgwPgw = CreateObject<Node> ();

111

  InternetStackHelper internet;

147

  InternetStackHelper internet;

112

  internet.SetIpv4StackInstall (true);

113

  internet.Install (m_sgwPgw);

148

  internet.Install (m_sgwPgw);

149

150

  //The Tun device resides in different 64 bit subnet and so, 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

151

  Ipv6StaticRoutingHelper ipv6RoutingHelper;

152

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

153

  pgwStaticRouting->AddNetworkRouteTo (m_uePgwbaseipv6prefix48, Ipv6Prefix (48), Ipv6Address ("::"), 1, 0);

114

154

115

  // create S1-U socket

155

  // create S1-U socket

116

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

156

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

117

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

157

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

118

  NS_ASSERT (retval == 0);

158

  NS_ASSERT (retval == 0);

119

159

120

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

160

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

121

  m_tunDevice = CreateObject<VirtualNetDevice> ();

161

  m_tunDevice = CreateObject<VirtualNetDevice> ();

162

122

  // allow jumbo packets

163

  // allow jumbo packets

123

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

164

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

124

165

Lines 130-138	Link Here

130

  tunDeviceContainer.Add (m_tunDevice);

171

  tunDeviceContainer.Add (m_tunDevice);

131

172

132

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

173

  // 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

174

  // 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.

175

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

135

  Ipv4InterfaceContainer tunDeviceIpv4IfContainer = m_ueAddressHelper.Assign (tunDeviceContainer);

176

  Ipv4InterfaceContainer tunDeviceIpv4IfContainer = AssignUeIpv4Address (tunDeviceContainer);

177

178

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

179

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

180

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

181

  Ipv6InterfaceContainer tunDeviceIpv6IfContainer = AssignUeIpv6Address (tunDeviceContainer);

182

183

  //Set Forwarding

184

  tunDeviceIpv6IfContainer.SetForwarding (0,true);

185

  tunDeviceIpv6IfContainer.SetDefaultRouteInAllNodes (0);

186

136

187

137

  // create EpcSgwPgwApplication

188

  // create EpcSgwPgwApplication

138

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

189

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

Lines 141-146	Link Here

141

  // connect SgwPgwApplication and virtual net device for tunneling

192

  // connect SgwPgwApplication and virtual net device for tunneling

142

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

193

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

143

194

195

144

  // Create MME and connect with SGW via S11 interface

196

  // Create MME and connect with SGW via S11 interface

145

  m_mme = CreateObject<EpcMme> ();

197

  m_mme = CreateObject<EpcMme> ();

146

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

198

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

Lines 184-190	Link Here

184

236

185

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

237

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

186

238

187

  // add an IPv4 stack to the previously created eNB

239

  // add an Internet stack to the previously created eNB

188

  InternetStackHelper internet;

240

  InternetStackHelper internet;

189

  internet.Install (enb);

241

  internet.Install (enb);

190

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

242

  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);

283

  enbLteSocketConnectAddress.SetProtocol (Ipv4L3Protocol::PROT_NUMBER);

232

  retval = enbLteSocket->Connect (enbLteSocketConnectAddress);

284

  retval = enbLteSocket->Connect (enbLteSocketConnectAddress);

233

  NS_ASSERT (retval == 0);

285

  NS_ASSERT (retval == 0);

286

287

  // create LTE socket for the ENB

288

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

289

  PacketSocketAddress enbLteSocketBindAddress6;

290

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

291

  enbLteSocketBindAddress6.SetProtocol (Ipv6L3Protocol::PROT_NUMBER);

292

  retval = enbLteSocket6->Bind (enbLteSocketBindAddress6);

293

  NS_ASSERT (retval == 0);

294

  PacketSocketAddress enbLteSocketConnectAddress6;

295

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

296

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

297

  enbLteSocketConnectAddress6.SetProtocol (Ipv6L3Protocol::PROT_NUMBER);

298

  retval = enbLteSocket6->Connect (enbLteSocketConnectAddress6);

299

  NS_ASSERT (retval == 0);

234

300

235

236

  NS_LOG_INFO ("create EpcEnbApplication");

301

  NS_LOG_INFO ("create EpcEnbApplication");

237

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

302

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

303

  enbApp->SetLTESocket6(enbLteSocket6);

238

  enb->AddApplication (enbApp);

304

  enb->AddApplication (enbApp);

239

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

305

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

240

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

306

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

Lines 312-334	Link Here

312

378

313

379

314

380

381

315

uint8_t

382

uint8_t

316

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

383

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

317

384

318

  NS_LOG_FUNCTION (this << ueDevice << imsi);

385

  NS_LOG_FUNCTION (this << ueDevice << imsi);

319

386

320

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

387

  // 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

388

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

322

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

389

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

323

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

390

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

324

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

391

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

325

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

392

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

393

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

326

  int32_t interface =  ueIpv4->GetInterfaceForDevice (ueDevice);

394

  int32_t interface =  ueIpv4->GetInterfaceForDevice (ueDevice);

327

  NS_ASSERT (interface >= 0);

395

  int32_t interface6 =  ueIpv6->GetInterfaceForDevice (ueDevice);

328

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

396

  //NS_ASSERT (interface >= 0 || interface6 >= 0);

329

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

397

  //NS_ASSERT (ueIpv4->GetNAddresses (interface) == 1 || ueIpv6->GetNAddresses (interface6) == 1);

330

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

398

331

399

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

400

401

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

402

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

403

      m_sgwPgwApp->SetUeAddress (imsi, ueAddr);

404

405

  else

406

407

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

408

      NS_LOG_LOGIC (" UE IPv6 address: " << ueAddr6);  m_sgwPgwApp->SetUeAddress6 (imsi, ueAddr6);

409

332

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

410

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

333

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

411

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

334

  if (ueLteDevice)

412

  if (ueLteDevice)

Lines 349-358	Link Here

349

Ipv4InterfaceContainer

427

Ipv4InterfaceContainer

350

EmuEpcHelper::AssignUeIpv4Address (NetDeviceContainer ueDevices)

428

EmuEpcHelper::AssignUeIpv4Address (NetDeviceContainer ueDevices)

351

429

352

  return m_ueAddressHelper.Assign (ueDevices);

430

  return m_uePgwAddressHelper.Assign (ueDevices);

353

431

354

432

433

Ipv6InterfaceContainer

434

EmuEpcHelper::AssignUeIpv6Address (NetDeviceContainer ueDevices)

435

436

  Ipv6InterfaceContainer iifc;

437

  Ptr<NetDevice> device;

355

438

439

  // Assign unique 64 bit prefixes to each UE

440

441

  Ipv6AddressGenerator::Init (m_uePgwbaseipv6prefix48, Ipv6Prefix (64));

442

443

  for (uint32_t i = 0; i < ueDevices.GetN (); ++i)

444

445

       NetDeviceContainer dc;

446

       device = ueDevices.Get (i);

447

       dc.Add (device);

448

       while (!(Ipv6AddressGenerator::AddAllocated (Ipv6AddressGenerator::GetNetwork (Ipv6Prefix (64)))))

449

         Ipv6AddressGenerator::NextNetwork (Ipv6Prefix (64));

450

       iifc.Add (m_uePgwAddressHelper6.Assign (dc));

451

452

453

  return iifc;

454

356

455

357

Ipv4Address

456

Ipv4Address

358

EmuEpcHelper::GetUeDefaultGatewayAddress ()

457

EmuEpcHelper::GetUeDefaultGatewayAddress ()

Lines 361-365	Link Here

361

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

460

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

362

461

363

462

463

Ipv6Address

464

EmuEpcHelper::GetUeDefaultGatewayAddress6 ()

465

466

  // return the address of the tun device 6

467

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

468

469

470

Ipv4Address EmuEpcHelper::GetEpcIpv4NetworkAddress ()

471

472

  // return the network address of this EPC

473

  return m_uePgwbaseipv4prefix16;

474

475

476

Ipv6Address EmuEpcHelper::GetEpcIpv6NetworkAddress ()

477

478

  // return the network address of this EPC

479

  return m_uePgwbaseipv6prefix48;

480

364

481

365

} // namespace ns3

482

} // namespace ns3

(-)a/src/lte/helper/emu-epc-helper.h (-4 / +39 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 70-78	Link Here

   *  \return The object TypeId.

   *  \return The object TypeId.

*/

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  TypeId GetInstanceTypeId () const;

  virtual void DoInitialize ();

  virtual void DoInitialize ();

  virtual void DoDispose ();

  virtual void DoDispose ();

  Ipv4Address GetEpcIpv4NetworkAddress ();

  Ipv6Address GetEpcIpv6NetworkAddress ();

  // inherited from EpcHelper

  // inherited from EpcHelper

  virtual void AddEnb (Ptr<Node> enbNode, Ptr<NetDevice> lteEnbNetDevice, uint16_t cellId);

  virtual void AddEnb (Ptr<Node> enbNode, Ptr<NetDevice> lteEnbNetDevice, uint16_t cellId);

  virtual void AddUe (Ptr<NetDevice> ueLteDevice, uint64_t imsi);

  virtual void AddUe (Ptr<NetDevice> ueLteDevice, uint64_t imsi);

Lines 80-95	Link Here

  virtual uint8_t ActivateEpsBearer (Ptr<NetDevice> ueLteDevice, uint64_t imsi, Ptr<EpcTft> tft, EpsBearer bearer);

  virtual uint8_t ActivateEpsBearer (Ptr<NetDevice> ueLteDevice, uint64_t imsi, Ptr<EpcTft> tft, EpsBearer bearer);

  virtual Ptr<Node> GetPgwNode ();

  virtual Ptr<Node> GetPgwNode ();

  virtual Ipv4InterfaceContainer AssignUeIpv4Address (NetDeviceContainer ueDevices);

  virtual Ipv4InterfaceContainer AssignUeIpv4Address (NetDeviceContainer ueDevices);

  Ipv6InterfaceContainer AssignUeIpv6Address (NetDeviceContainer ueDevices);

  virtual Ipv4Address GetUeDefaultGatewayAddress ();

  virtual Ipv4Address GetUeDefaultGatewayAddress ();

  Ipv6Address GetUeDefaultGatewayAddress6 ();

private:

private:

/**

/**

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

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

*/

*/

  Ipv4AddressHelper m_ueAddressHelper;

  Ipv4AddressHelper m_uePgwAddressHelper;

100

/**

101

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

102

*/

103

  Ipv6AddressHelper m_uePgwAddressHelper6;

104

/**

105

/**

   * SGW-PGW network element

106

   * SGW-PGW network element

Lines 102-108	Link Here

102

  Ptr<EpcSgwPgwApplication> m_sgwPgwApp;

113

  Ptr<EpcSgwPgwApplication> m_sgwPgwApp;

103

114

104

/**

115

/**

105

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

116

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

106

*/

117

*/

107

  Ptr<VirtualNetDevice> m_tunDevice;

118

  Ptr<VirtualNetDevice> m_tunDevice;

108

119

Lines 151-156	Link Here

151

   * First 5 bytes of the Enb MAC address base

162

   * First 5 bytes of the Enb MAC address base

152

*/

163

*/

153

  std::string m_enbMacAddressBase;

164

  std::string m_enbMacAddressBase;

165

166

/**

167

   * The common 8 bit prefix used for the IPv4 address assignment of

168

   * the EPC network

169

*/

170

  Ipv4Address m_uePgwbaseipv4prefix8;

171

172

/**

173

   * The 16 bit prefix used for the IPv4 address assignment of

174

   * the UE and PGW

175

*/

176

  Ipv4Address m_uePgwbaseipv4prefix16;

177

178

/**

179

   * The common 32 bit prefix used for the IPv6 address assignment of

180

   * this EPC network

181

*/

182

  Ipv6Address m_uePgwbaseipv6prefix32;

183

184

/**

185

   * The common 48 bit prefix used for the IPv6 address assignment of

186

   * the UE and PGW

187

*/

188

  Ipv6Address m_uePgwbaseipv6prefix48;

154

};

189

};

155

190

156

191

(-)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 /16 bit IPv4 net for an EPC network
  m_uePgwbaseipv4prefix16 = m_uePgwbaseipv4prefix8.CombineMask (Ipv4Mask ("255.0.0.0"));  //Initialize
  Ipv4AddressGenerator::Init (m_uePgwbaseipv4prefix16, Ipv4Mask ("255.255.0.0"));

  Ipv4AddressGenerator::TestMode ();
  while (!(Ipv4AddressGenerator::AddAllocated (Ipv4AddressGenerator::GetNetwork (Ipv4Mask ("255.255.0.0")))))
    m_uePgwbaseipv4prefix16 = Ipv4AddressGenerator::NextNetwork (Ipv4Mask ("255.255.0.0"));
  m_uePgwAddressHelper.SetBase (m_uePgwbaseipv4prefix16, "255.255.0.0"); //The helper will assign IPv4 addresses using this 16 bit prefix
  //Now we get an unique 16 bit IPv4 prefix for this EPC, which not used by any other EPC


  // we use a /48 IPv6 net for an EPC network
  m_uePgwbaseipv6prefix48 = m_uePgwbaseipv6prefix32.CombinePrefix (Ipv6Prefix (32));//Initialize
  Ipv6AddressGenerator::Init (m_uePgwbaseipv6prefix48, Ipv6Prefix (48));

  Ipv6AddressGenerator::TestMode ();
  while (!(Ipv6AddressGenerator::AddAllocated (Ipv6AddressGenerator::GetNetwork (Ipv6Prefix (48)))))
    m_uePgwbaseipv6prefix48 = Ipv6AddressGenerator::NextNetwork (Ipv6Prefix (48));
  //Now we get an unique 48 bit IPv6 prefix for this EPC, which not used by any other EPC

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

  //The Tun device resides in different 64 bit subnet and so, 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 (m_uePgwbaseipv6prefix48, Ipv6Prefix (48), 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 ());

                   UintegerValue (3000),
                   MakeUintegerAccessor (&PointToPointEpcHelper::m_x2LinkMtu),
                   MakeUintegerChecker<uint16_t> ())
    .AddAttribute ("BaseIpv4Prefix",
                   "The 8 bit IPv4 prefix to be used for the assignment of IPv4 addresses to pgw and ue.",
                   Ipv4AddressValue (Ipv4Address ("7.0.0.0")),
                   MakeIpv4AddressAccessor (&PointToPointEpcHelper::m_uePgwbaseipv4prefix8),
                   MakeIpv4AddressChecker ())
    .AddAttribute ("BaseIpv6Prefix",
                   "The 32 bit IPv6 prefix to be used for the assignment of IPv6 addresses to pgw and ue.",
                   Ipv6AddressValue (Ipv6Address ("7777:f00d::")),
                   MakeIpv6AddressAccessor (&PointToPointEpcHelper::m_uePgwbaseipv6prefix32),
                   MakeIpv6AddressChecker ())
  ;
  return tid;
}

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

void
PointToPointEpcHelper::DoDispose ()
{

  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");
  int32_t interface =  ueIpv4->GetInterfaceForDevice (ueDevice);
  int32_t interface6 =  ueIpv6->GetInterfaceForDevice (ueDevice);
  //NS_ASSERT (interface >= 0 || interface6 >= 0);
  //NS_ASSERT (ueIpv4->GetNAddresses (interface) == 1 || ueIpv6->GetNAddresses (interface6) == 1);
  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);
   }
  else
   {
    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)
{
  Ipv6InterfaceContainer iifc;
  Ptr<NetDevice> device;

  // Assign unique 64 bit prefixes to each UE

  Ipv6AddressGenerator::Init (m_uePgwbaseipv6prefix48, Ipv6Prefix (64));

  for (uint32_t i = 0; i < ueDevices.GetN (); ++i) 
    {
       NetDeviceContainer dc;
       device = ueDevices.Get (i);
       dc.Add (device);
       while (!(Ipv6AddressGenerator::AddAllocated (Ipv6AddressGenerator::GetNetwork (Ipv6Prefix (64)))))
         Ipv6AddressGenerator::NextNetwork (Ipv6Prefix (64));
       iifc.Add (m_uePgwAddressHelper6.Assign (dc));
    }

  return iifc;
}

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 ();
}

Ipv4Address PointToPointEpcHelper::GetEpcIpv4NetworkAddress ()
{
  // return thr network address of this epc
  return m_uePgwbaseipv4prefix16;
}

Ipv6Address PointToPointEpcHelper::GetEpcIpv6NetworkAddress ()
{
  //return the network address of this epc
  return m_uePgwbaseipv6prefix48;
}
} // namespace ns3

(-)a/src/lte/helper/point-to-point-epc-helper.h (-3 / +36 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 68-75	Link Here

   *  \return The object TypeId.

   *  \return The object TypeId.

*/

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  TypeId GetInstanceTypeId () const;

  virtual void DoDispose ();

  virtual void DoDispose ();

  Ipv4Address GetEpcIpv4NetworkAddress ();

  Ipv6Address GetEpcIpv6NetworkAddress ();

  // inherited from EpcHelper

  // inherited from EpcHelper

  virtual void AddEnb (Ptr<Node> enbNode, Ptr<NetDevice> lteEnbNetDevice, uint16_t cellId);

  virtual void AddEnb (Ptr<Node> enbNode, Ptr<NetDevice> lteEnbNetDevice, uint16_t cellId);

  virtual void AddUe (Ptr<NetDevice> ueLteDevice, uint64_t imsi);

  virtual void AddUe (Ptr<NetDevice> ueLteDevice, uint64_t imsi);

Lines 77-92	Link Here

  virtual uint8_t ActivateEpsBearer (Ptr<NetDevice> ueLteDevice, uint64_t imsi, Ptr<EpcTft> tft, EpsBearer bearer);

  virtual uint8_t ActivateEpsBearer (Ptr<NetDevice> ueLteDevice, uint64_t imsi, Ptr<EpcTft> tft, EpsBearer bearer);

  virtual Ptr<Node> GetPgwNode ();

  virtual Ptr<Node> GetPgwNode ();

  virtual Ipv4InterfaceContainer AssignUeIpv4Address (NetDeviceContainer ueDevices);

  virtual Ipv4InterfaceContainer AssignUeIpv4Address (NetDeviceContainer ueDevices);

  Ipv6InterfaceContainer AssignUeIpv6Address (NetDeviceContainer ueDevices);

  virtual Ipv4Address GetUeDefaultGatewayAddress ();

  virtual Ipv4Address GetUeDefaultGatewayAddress ();

  Ipv6Address GetUeDefaultGatewayAddress6 ();

private:

private:

/**

/**

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

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

*/

*/

  Ipv4AddressHelper m_ueAddressHelper;

  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;

100

/**

101

/**

   * SGW-PGW network element

102

   * SGW-PGW network element

Lines 166-171	Link Here

166

*/

176

*/

167

  uint16_t m_x2LinkMtu;

177

  uint16_t m_x2LinkMtu;

168

178

179

/**

180

   * The common 8 bit prefix used for the IPv4 address assignment of

181

   * the EPC network

182

*/

183

  Ipv4Address m_uePgwbaseipv4prefix8;

184

185

/**

186

   * The 16 bit prefix used for the IPv4 address assignment of

187

   * the UE and PGW

188

*/

189

  Ipv4Address m_uePgwbaseipv4prefix16;

190

191

/**

192

   * The common 32 bit prefix used for the IPv6 address assignment of

193

   * this EPC network

194

*/

195

  Ipv6Address m_uePgwbaseipv6prefix32;

196

197

/**

198

   * The common 48 bit prefix used for the IPv6 address assignment of

199

   * the UE and PGW

200

*/

201

  Ipv6Address m_uePgwbaseipv6prefix48;

169

};

202

};

170

203

171

204




{
  static TypeId tid = TypeId ("ns3::EpcEnbApplication")
    .SetParent<Object> ()
    .SetGroupName("Lte")
    .AddTraceSource ("RxfromEnb",
                     "Receive data packets from LTE Enb Net Device",
                     MakeTraceSourceAccessor (&EpcEnbApplication::m_rxLteenbPktTrace),
                     "ns3::EpcEnbApplication::RxTracedCallback")
    .AddTraceSource ("RxfromS1u",
                     "Receive data packets from S1-U Net Device",
                     MakeTraceSourceAccessor (&EpcEnbApplication::m_rxS1uPktTrace),
                     "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_rxLteenbPktTrace (packet->Copy ());
      SendToS1uSocket (packet, teid);
    }
}

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

  m_rxS1uPktTrace (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;
  Ptr<Packet> pCopy = packet->Copy ();
  pCopy->CopyData (&ipType, 1);
  ipType=(ipType>>4) & 0x0f;
  int sentBytes;
  if (ipType == 0x04)
    {
      sentBytes = m_lteSocket->Send (packet);
    }
  else
    {
      sentBytes = m_lteSocket6->Send (packet);
    }

  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 Enb Net Device.

327

*/

328

  TracedCallback<Ptr<Packet> > m_rxLteenbPktTrace;

329

330

/**

331

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

332

*/

333

  TracedCallback<Ptr<Packet> > m_rxS1uPktTrace;

310

};

334

};

311

335

312

} //namespace ns3

336

} //namespace ns3

(-)a/src/lte/model/epc-sgw-pgw-application.cc (-20 / +98 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 ());

142

164

  m_rxTunPktTrace (packet->Copy ());

165

  uint8_t ipType;

143

  // get IP address of UE

166

  // get IP address of UE

144

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

167

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

145

  Ipv4Header ipv4Header;

168

  pCopy->CopyData (&ipType, 1);

146

  pCopy->RemoveHeader (ipv4Header);

169

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

147

  Ipv4Address ueAddr =  ipv4Header.GetDestination ();

170

  if (ipType == 0x04)

148

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

171

149

172

      Ipv4Header ipv4Header;

150

  // find corresponding UeInfo address

173

      pCopy->RemoveHeader (ipv4Header);

151

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

174

      Ipv4Address ueAddr =  ipv4Header.GetDestination ();

152

  if (it == m_ueInfoByAddrMap.end ())

175

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

153

176

      // find corresponding UeInfo address

154

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

177

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

178

      if (it == m_ueInfoByAddrMap.end ())

179

180

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

181

182

      else

183

184

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

185

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

186

          if (teid == 0)

187

188

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

189

190

          else

191

192

              SendToS1uSocket (packet, enbAddr, teid);

193

194

155

195

156

  else

196

  else

157

197

158

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

198

      Ipv6Header ipv6Header;

159

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

199

      pCopy->RemoveHeader (ipv6Header);

160

      if (teid == 0)

200

      Ipv6Address ueAddr =  ipv6Header.GetDestinationAddress ();

161

201

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

162

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

202

      // find corresponding UeInfo address

203

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

204

      if (it == m_ueInfoByAddrMap6.end ())

205

206

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

163

207

164

      else

208

      else

165

209

166

          SendToS1uSocket (packet, enbAddr, teid);

210

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

211

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

212

          if (teid == 0)

213

214

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

215

216

          else

217

218

              SendToS1uSocket (packet, enbAddr, teid);

219

167

220

168

221

222

169

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

223

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

170

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

224

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

171

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

225

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

Lines 184-189	Link Here

184

  uint32_t teid = gtpu.GetTeid ();

238

  uint32_t teid = gtpu.GetTeid ();

185

239

186

  SendToTunDevice (packet, teid);

240

  SendToTunDevice (packet, teid);

241

242

  m_rxS1uPktTrace (packet->Copy ());

187

243

188

244

189

void

245

void

Lines 191-197	Link Here

191

247

192

  NS_LOG_FUNCTION (this << packet << teid);

248

  NS_LOG_FUNCTION (this << packet << teid);

193

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

249

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

194

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

250

  uint8_t ipType;

251

  // get IP address of UE

252

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

253

  pCopy->CopyData (&ipType, 1);

254

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

255

  if (ipType == 0x04)

256

257

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

258

259

  else

260

261

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

262

195

263

196

264

197

void

265

void

Lines 251-256	Link Here

251

319

252

320

253

void

321

void

322

EpcSgwPgwApplication::SetUeAddress6 (uint64_t imsi, Ipv6Address ueAddr)

323

324

  NS_LOG_FUNCTION (this << imsi << ueAddr);

325

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

326

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

327

  m_ueInfoByAddrMap6[ueAddr] = ueit->second;

328

  ueit->second->SetUeAddr6 (ueAddr);

329

330

331

void

254

EpcSgwPgwApplication::DoCreateSessionRequest (EpcS11SapSgw::CreateSessionRequestMessage req)

332

EpcSgwPgwApplication::DoCreateSessionRequest (EpcS11SapSgw::CreateSessionRequestMessage req)

255

333

256

  NS_LOG_FUNCTION (this << req.imsi);

334

  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 SetUeAddr (Ipv4Address addr);

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

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

  private:
    EpcTftClassifier m_tftClassifier; ///< TFT classifier
    Ipv4Address m_enbAddr; ///< ENB address
    Ipv4Address m_ueAddr; ///< UE address
    Ipv6Address m_ueAddr6; ///< UE 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;

  };

  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 localAddressIpv4;
  Ipv4Address remoteAddressIpv4;

  Ipv6Address localAddressIpv6;
  Ipv6Address remoteAddressIpv6;
    {
      localAddress = ipv4Header.GetSource ();
      remoteAddress = ipv4Header.GetDestination ();
    }
  else
    { 
      NS_ASSERT (direction ==  EpcTft::DOWNLINK);
      remoteAddress = ipv4Header.GetSource ();
      localAddress = ipv4Header.GetDestination ();      
    }
  
  uint8_t protocol = ipv4Header.GetProtocol ();

  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
    {
      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 ();
    }

  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
            }
        }
      NS_LOG_LOGIC ("no match");
      return 0;  // no match
    }
  else
    {
      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");
      return 0;  // no match
    }
  NS_LOG_LOGIC ("no match");
  return 0;  // no match
}






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 

  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
    {
      NS_LOG_LOGIC ("d doesn't match: d=0x" << std::hex << d << " f.d=0x" << std::hex << direction << std::dec);
    }
  return false;      
}


Ptr<EpcTft> 
EpcTft::Default ()

  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;
}


} // namespace ns3





#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;
  Ptr<Packet> pCopy = p->Copy ();
  pCopy->CopyData (&ipType, 1);
  ipType=(ipType>>4) & 0x0f;
  if (ipType == 0x04)
    m_rxCallback (this, p, Ipv4L3Protocol::PROT_NUMBER, Address ());
  else
    m_rxCallback (this, p, Ipv6L3Protocol::PROT_NUMBER, Address ());
}






#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 (Mac48Address::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 (epcHelper->GetEpcIpv6NetworkAddress (), Ipv6Prefix (48), 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