A Discrete-Event Network Simulator
API
emu-epc-helper.cc
Go to the documentation of this file.
1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2011-2013 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation;
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Author: Jaume Nin <jnin@cttc.es>
19  * Nicola Baldo <nbaldo@cttc.es>
20  * Manuel Requena <manuel.requena@cttc.es>
21  */
22 
23 #include <ns3/emu-epc-helper.h>
24 #include <ns3/log.h>
25 #include <ns3/inet-socket-address.h>
26 #include <ns3/mac48-address.h>
27 #include <ns3/eps-bearer.h>
28 #include <ns3/ipv4-address.h>
29 #include <ns3/ipv6-address.h>
30 #include <ns3/internet-stack-helper.h>
31 #include <ns3/packet-socket-helper.h>
32 #include <ns3/packet-socket-address.h>
33 #include <ns3/epc-enb-application.h>
34 #include <ns3/epc-sgw-pgw-application.h>
35 #include <ns3/emu-fd-net-device-helper.h>
36 #include "ns3/ipv6-static-routing.h"
37 #include "ns3/ipv6-static-routing-helper.h"
38 #include <ns3/lte-enb-rrc.h>
39 #include <ns3/epc-x2.h>
40 #include <ns3/lte-enb-net-device.h>
41 #include <ns3/lte-ue-net-device.h>
42 #include <ns3/epc-mme.h>
43 #include <ns3/epc-ue-nas.h>
44 #include <ns3/string.h>
45 #include <ns3/abort.h>
46 #include <ns3/ipv4-address-generator.h>
47 #include <ns3/ipv6-address-generator.h>
48 #include <ns3/icmpv6-l4-protocol.h>
49 
50 #include <iomanip>
51 #include <iostream>
52 
53 namespace ns3 {
54 
55 NS_LOG_COMPONENT_DEFINE ("EmuEpcHelper");
56 
57 NS_OBJECT_ENSURE_REGISTERED (EmuEpcHelper);
58 
59 
61  : m_gtpuUdpPort (2152) // fixed by the standard
62 {
63  NS_LOG_FUNCTION (this);
64  // To access the attribute value within the constructor
66 }
67 
69 {
70  NS_LOG_FUNCTION (this);
71 }
72 
73 TypeId
75 {
76  static TypeId tid = TypeId ("ns3::EmuEpcHelper")
77  .SetParent<EpcHelper> ()
78  .SetGroupName("Lte")
79  .AddConstructor<EmuEpcHelper> ()
80  .AddAttribute ("sgwDeviceName",
81  "The name of the device used for the S1-U interface of the SGW",
82  StringValue ("veth0"),
85  .AddAttribute ("enbDeviceName",
86  "The name of the device used for the S1-U interface of the eNB",
87  StringValue ("veth1"),
90  .AddAttribute ("SgwMacAddress",
91  "MAC address used for the SGW ",
92  StringValue ("00:00:00:59:00:aa"),
95  .AddAttribute ("EnbMacAddressBase",
96  "First 5 bytes of the Enb MAC address base",
97  StringValue ("00:00:00:eb:00"),
100  ;
101  return tid;
102 }
103 
104 TypeId
106 {
107  return GetTypeId ();
108 }
109 
110 void
112 {
113  NS_LOG_LOGIC (this);
114 
115  // we use a /8 net for all UEs
116  m_uePgwAddressHelper.SetBase ("7.0.0.0", "255.0.0.0");
117 
118  // we use a /64 IPv6 net all UEs
119  m_uePgwAddressHelper6.SetBase ("7777:f00d::", Ipv6Prefix (64));
120 
121 
122  // create SgwPgwNode
123  m_sgwPgw = CreateObject<Node> ();
124  InternetStackHelper internet;
125  internet.Install (m_sgwPgw);
126 
127  // The Tun device resides in different 64 bit subnet.
128  // We must create an unique route to tun device for all the packets destined
129  // to all 64 bit IPv6 prefixes of UEs, based by the unique 48 bit network prefix of this EPC network
130  Ipv6StaticRoutingHelper ipv6RoutingHelper;
131  Ptr<Ipv6StaticRouting> pgwStaticRouting = ipv6RoutingHelper.GetStaticRouting (m_sgwPgw->GetObject<Ipv6> ());
132  pgwStaticRouting->AddNetworkRouteTo ("7777:f00d::", Ipv6Prefix (64), Ipv6Address ("::"), 1, 0);
133 
134  // create S1-U socket
135  Ptr<Socket> sgwPgwS1uSocket = Socket::CreateSocket (m_sgwPgw, TypeId::LookupByName ("ns3::UdpSocketFactory"));
136  int retval = sgwPgwS1uSocket->Bind (InetSocketAddress (Ipv4Address::GetAny (), m_gtpuUdpPort));
137  NS_ASSERT (retval == 0);
138 
139  // create TUN device containing IPv4 address and implementing tunneling of user data over GTP-U/UDP/IP
140  m_tunDevice = CreateObject<VirtualNetDevice> ();
141 
142  // allow jumbo packets
143  m_tunDevice->SetAttribute ("Mtu", UintegerValue (30000));
144 
145  // yes we need this
147 
149  NetDeviceContainer tunDeviceContainer;
150  tunDeviceContainer.Add (m_tunDevice);
151 
152  // the TUN device is on the same subnet as the UEs, so when a packet
153  // addressed to an UE IPv4 address arrives at the intenet to the WAN interface of
154  // the PGW it will be forwarded to the TUN device.
155  Ipv4InterfaceContainer tunDeviceIpv4IfContainer = AssignUeIpv4Address (tunDeviceContainer);
156 
157  // the TUN device for IPv6 address is on the different subnet as the
158  // UEs, it will forward the UE packets as we have inserted the route
159  // for all UEs at the time of assigning UE addresses
160  Ipv6InterfaceContainer tunDeviceIpv6IfContainer = AssignUeIpv6Address (tunDeviceContainer);
161 
162  //Set Forwarding
163  tunDeviceIpv6IfContainer.SetForwarding (0,true);
164  tunDeviceIpv6IfContainer.SetDefaultRouteInAllNodes (0);
165 
166 
167  // create EpcSgwPgwApplication
168  m_sgwPgwApp = CreateObject<EpcSgwPgwApplication> (m_tunDevice, sgwPgwS1uSocket);
170 
171  // connect SgwPgwApplication and virtual net device for tunneling
172  m_tunDevice->SetSendCallback (MakeCallback (&EpcSgwPgwApplication::RecvFromTunDevice, m_sgwPgwApp));
173 
174 
175  // Create MME and connect with SGW via S11 interface
176  m_mme = CreateObject<EpcMme> ();
177  m_mme->SetS11SapSgw (m_sgwPgwApp->GetS11SapSgw ());
178  m_sgwPgwApp->SetS11SapMme (m_mme->GetS11SapMme ());
179 
180  // Create EmuFdNetDevice for SGW
182  NS_LOG_LOGIC ("SGW device: " << m_sgwDeviceName);
184  NetDeviceContainer sgwDevices = emu.Install (m_sgwPgw);
185  Ptr<NetDevice> sgwDevice = sgwDevices.Get (0);
186  NS_LOG_LOGIC ("MAC address of SGW: " << m_sgwMacAddress);
187  sgwDevice->SetAttribute ("Address", Mac48AddressValue (m_sgwMacAddress.c_str ()));
188 
189  // we use a /8 subnet so the SGW and the eNBs can talk directly to each other
190  m_epcIpv4AddressHelper.SetBase ("10.0.0.0", "255.255.255.0", "0.0.0.1");
192  m_epcIpv4AddressHelper.SetBase ("10.0.0.0", "255.0.0.0", "0.0.0.101");
193 
194 
196 }
197 
198 void
200 {
201  NS_LOG_FUNCTION (this);
202  m_tunDevice->SetSendCallback (MakeNullCallback<bool, Ptr<Packet>, const Address&, const Address&, uint16_t> ());
203  m_tunDevice = 0;
204  m_sgwPgwApp = 0;
205  m_sgwPgw->Dispose ();
206 }
207 
208 
209 void
210 EmuEpcHelper::AddEnb (Ptr<Node> enb, Ptr<NetDevice> lteEnbNetDevice, uint16_t cellId)
211 {
212  NS_LOG_FUNCTION (this << enb << lteEnbNetDevice << cellId);
213 
214  Initialize ();
215 
216  NS_ASSERT (enb == lteEnbNetDevice->GetNode ());
217 
218  // add an Internet stack to the previously created eNB
219  InternetStackHelper internet;
220  internet.Install (enb);
221  NS_LOG_LOGIC ("number of Ipv4 ifaces of the eNB after node creation: " << enb->GetObject<Ipv4> ()->GetNInterfaces ());
222 
223 
224 
225  // Create an EmuFdNetDevice for the eNB to connect with the SGW and other eNBs
227  NS_LOG_LOGIC ("eNB device: " << m_enbDeviceName);
228  emu.SetDeviceName (m_enbDeviceName);
229  NetDeviceContainer enbDevices = emu.Install (enb);
230 
231  NS_ABORT_IF ((cellId == 0) || (cellId > 255));
232  std::ostringstream enbMacAddress;
233  enbMacAddress << m_enbMacAddressBase << ":" << std::hex << std::setfill ('0') << std::setw (2) << cellId;
234  NS_LOG_LOGIC ("MAC address of enB with cellId " << cellId << " : " << enbMacAddress.str ());
235  Ptr<NetDevice> enbDev = enbDevices.Get (0);
236  enbDev->SetAttribute ("Address", Mac48AddressValue (enbMacAddress.str ().c_str ()));
237 
238  //emu.EnablePcap ("enbDevice", enbDev);
239 
240  NS_LOG_LOGIC ("number of Ipv4 ifaces of the eNB after installing emu dev: " << enb->GetObject<Ipv4> ()->GetNInterfaces ());
241  Ipv4InterfaceContainer enbIpIfaces = m_epcIpv4AddressHelper.Assign (enbDevices);
242  NS_LOG_LOGIC ("number of Ipv4 ifaces of the eNB after assigning Ipv4 addr to S1 dev: " << enb->GetObject<Ipv4> ()->GetNInterfaces ());
243 
244  Ipv4Address enbAddress = enbIpIfaces.GetAddress (0);
245  Ipv4Address sgwAddress = m_sgwIpIfaces.GetAddress (0);
246 
247  // create S1-U socket for the ENB
248  Ptr<Socket> enbS1uSocket = Socket::CreateSocket (enb, TypeId::LookupByName ("ns3::UdpSocketFactory"));
249  int retval = enbS1uSocket->Bind (InetSocketAddress (enbAddress, m_gtpuUdpPort));
250  NS_ASSERT (retval == 0);
251 
252  // create LTE socket for the ENB
253  Ptr<Socket> enbLteSocket = Socket::CreateSocket (enb, TypeId::LookupByName ("ns3::PacketSocketFactory"));
254  PacketSocketAddress enbLteSocketBindAddress;
255  enbLteSocketBindAddress.SetSingleDevice (lteEnbNetDevice->GetIfIndex ());
256  enbLteSocketBindAddress.SetProtocol (Ipv4L3Protocol::PROT_NUMBER);
257  retval = enbLteSocket->Bind (enbLteSocketBindAddress);
258  NS_ASSERT (retval == 0);
259  PacketSocketAddress enbLteSocketConnectAddress;
260  enbLteSocketConnectAddress.SetPhysicalAddress (Mac48Address::GetBroadcast ());
261  enbLteSocketConnectAddress.SetSingleDevice (lteEnbNetDevice->GetIfIndex ());
262  enbLteSocketConnectAddress.SetProtocol (Ipv4L3Protocol::PROT_NUMBER);
263  retval = enbLteSocket->Connect (enbLteSocketConnectAddress);
264  NS_ASSERT (retval == 0);
265 
266  // create LTE socket for the ENB
267  Ptr<Socket> enbLteSocket6 = Socket::CreateSocket (enb, TypeId::LookupByName ("ns3::PacketSocketFactory"));
268  PacketSocketAddress enbLteSocketBindAddress6;
269  enbLteSocketBindAddress6.SetSingleDevice (lteEnbNetDevice->GetIfIndex ());
270  enbLteSocketBindAddress6.SetProtocol (Ipv6L3Protocol::PROT_NUMBER);
271  retval = enbLteSocket6->Bind (enbLteSocketBindAddress6);
272  NS_ASSERT (retval == 0);
273  PacketSocketAddress enbLteSocketConnectAddress6;
274  enbLteSocketConnectAddress6.SetPhysicalAddress (Mac48Address::GetBroadcast ());
275  enbLteSocketConnectAddress6.SetSingleDevice (lteEnbNetDevice->GetIfIndex ());
276  enbLteSocketConnectAddress6.SetProtocol (Ipv6L3Protocol::PROT_NUMBER);
277  retval = enbLteSocket6->Connect (enbLteSocketConnectAddress6);
278  NS_ASSERT (retval == 0);
279 
280  NS_LOG_INFO ("create EpcEnbApplication");
281  Ptr<EpcEnbApplication> enbApp = CreateObject<EpcEnbApplication> (enbLteSocket, enbLteSocket6, enbS1uSocket, enbAddress, sgwAddress, cellId);
282  enb->AddApplication (enbApp);
283  NS_ASSERT (enb->GetNApplications () == 1);
284  NS_ASSERT_MSG (enb->GetApplication (0)->GetObject<EpcEnbApplication> () != 0, "cannot retrieve EpcEnbApplication");
285  NS_LOG_LOGIC ("enb: " << enb << ", enb->GetApplication (0): " << enb->GetApplication (0));
286 
287 
288  NS_LOG_INFO ("Create EpcX2 entity");
289  Ptr<EpcX2> x2 = CreateObject<EpcX2> ();
290  enb->AggregateObject (x2);
291 
292  NS_LOG_INFO ("connect S1-AP interface");
293  m_mme->AddEnb (cellId, enbAddress, enbApp->GetS1apSapEnb ());
294  m_sgwPgwApp->AddEnb (cellId, enbAddress, sgwAddress);
295  enbApp->SetS1apSapMme (m_mme->GetS1apSapMme ());
296 }
297 
298 
299 void
301 {
302  NS_LOG_FUNCTION (this << enb1 << enb2);
303 
304  NS_LOG_WARN ("X2 support still untested");
305 
306 
307  // for X2, we reuse the same device and IP address of the S1-U interface
308  Ptr<Ipv4> enb1Ipv4 = enb1->GetObject<Ipv4> ();
309  Ptr<Ipv4> enb2Ipv4 = enb2->GetObject<Ipv4> ();
310  NS_LOG_LOGIC ("number of Ipv4 ifaces of the eNB #1: " << enb1Ipv4->GetNInterfaces ());
311  NS_LOG_LOGIC ("number of Ipv4 ifaces of the eNB #2: " << enb2Ipv4->GetNInterfaces ());
312  NS_LOG_LOGIC ("number of NetDevices of the eNB #1: " << enb1->GetNDevices ());
313  NS_LOG_LOGIC ("number of NetDevices of the eNB #2: " << enb2->GetNDevices ());
314 
315  // 0 is the LTE device, 1 is localhost, 2 is the EPC NetDevice
316  Ptr<NetDevice> enb1EpcDev = enb1->GetDevice (2);
317  Ptr<NetDevice> enb2EpcDev = enb2->GetDevice (2);
318 
319  int32_t enb1Interface = enb1Ipv4->GetInterfaceForDevice (enb1EpcDev);
320  int32_t enb2Interface = enb2Ipv4->GetInterfaceForDevice (enb2EpcDev);
321  NS_ASSERT (enb1Interface >= 0);
322  NS_ASSERT (enb2Interface >= 0);
323  NS_ASSERT (enb1Ipv4->GetNAddresses (enb1Interface) == 1);
324  NS_ASSERT (enb2Ipv4->GetNAddresses (enb2Interface) == 1);
325  Ipv4Address enb1Addr = enb1Ipv4->GetAddress (enb1Interface, 0).GetLocal ();
326  Ipv4Address enb2Addr = enb2Ipv4->GetAddress (enb2Interface, 0).GetLocal ();
327  NS_LOG_LOGIC (" eNB 1 IP address: " << enb1Addr);
328  NS_LOG_LOGIC (" eNB 2 IP address: " << enb2Addr);
329 
330  // Add X2 interface to both eNBs' X2 entities
331  Ptr<EpcX2> enb1X2 = enb1->GetObject<EpcX2> ();
332  Ptr<LteEnbNetDevice> enb1LteDev = enb1->GetDevice (0)->GetObject<LteEnbNetDevice> ();
333  uint16_t enb1CellId = enb1LteDev->GetCellId ();
334  NS_LOG_LOGIC ("LteEnbNetDevice #1 = " << enb1LteDev << " - CellId = " << enb1CellId);
335 
336  Ptr<EpcX2> enb2X2 = enb2->GetObject<EpcX2> ();
337  Ptr<LteEnbNetDevice> enb2LteDev = enb2->GetDevice (0)->GetObject<LteEnbNetDevice> ();
338  uint16_t enb2CellId = enb2LteDev->GetCellId ();
339  NS_LOG_LOGIC ("LteEnbNetDevice #2 = " << enb2LteDev << " - CellId = " << enb2CellId);
340 
341  enb1X2->AddX2Interface (enb1CellId, enb1Addr, enb2CellId, enb2Addr);
342  enb2X2->AddX2Interface (enb2CellId, enb2Addr, enb1CellId, enb1Addr);
343 
344  enb1LteDev->GetRrc ()->AddX2Neighbour (enb2LteDev->GetCellId ());
345  enb2LteDev->GetRrc ()->AddX2Neighbour (enb1LteDev->GetCellId ());
346 }
347 
348 
349 void
350 EmuEpcHelper::AddUe (Ptr<NetDevice> ueDevice, uint64_t imsi)
351 {
352  NS_LOG_FUNCTION (this << imsi << ueDevice );
353 
354  m_mme->AddUe (imsi);
355  m_sgwPgwApp->AddUe (imsi);
356 
357 }
358 
359 
360 uint8_t
362 {
363  NS_LOG_FUNCTION (this << ueDevice << imsi);
364 
365  // we now retrieve the IPv4/IPv6 address of the UE and notify it to the SGW;
366  // we couldn't do it before since address assignment is triggered by
367  // the user simulation program, rather than done by the EPC
368  Ptr<Node> ueNode = ueDevice->GetNode ();
369  Ptr<Ipv4> ueIpv4 = ueNode->GetObject<Ipv4> ();
370  Ptr<Ipv6> ueIpv6 = ueNode->GetObject<Ipv6> ();
371  NS_ASSERT_MSG (ueIpv4 != 0 || ueIpv6 != 0, "UEs need to have IPv4/IPv6 installed before EPS bearers can be activated");
372 
373  if (ueIpv4)
374  {
375  int32_t interface = ueIpv4->GetInterfaceForDevice (ueDevice);
376  if (interface >= 0 && ueIpv4->GetNAddresses (interface) == 1)
377  {
378  Ipv4Address ueAddr = ueIpv4->GetAddress (interface, 0).GetLocal ();
379  NS_LOG_LOGIC (" UE IPv4 address: " << ueAddr);
380  m_sgwPgwApp->SetUeAddress (imsi, ueAddr);
381  }
382  }
383  if (ueIpv6)
384  {
385  int32_t interface6 = ueIpv6->GetInterfaceForDevice (ueDevice);
386  if (interface6 >= 0 && ueIpv6->GetNAddresses (interface6) == 2)
387  {
388  Ipv6Address ueAddr6 = ueIpv6->GetAddress (interface6, 1).GetAddress ();
389  NS_LOG_LOGIC (" UE IPv6 address: " << ueAddr6);
390  m_sgwPgwApp->SetUeAddress6 (imsi, ueAddr6);
391  }
392  }
393 
394  uint8_t bearerId = m_mme->AddBearer (imsi, tft, bearer);
395  Ptr<LteUeNetDevice> ueLteDevice = ueDevice->GetObject<LteUeNetDevice> ();
396  if (ueLteDevice)
397  {
398  Simulator::ScheduleNow (&EpcUeNas::ActivateEpsBearer, ueLteDevice->GetNas (), bearer, tft);
399  }
400  return bearerId;
401 }
402 
403 
404 Ptr<Node>
406 {
407  return m_sgwPgw;
408 }
409 
410 
413 {
414  return m_uePgwAddressHelper.Assign (ueDevices);
415 }
416 
419 {
420  for (NetDeviceContainer::Iterator iter = ueDevices.Begin ();
421  iter != ueDevices.End ();
422  iter ++)
423  {
424  Ptr<Icmpv6L4Protocol> icmpv6 = (*iter)->GetNode ()->GetObject<Icmpv6L4Protocol> ();
425  icmpv6->SetAttribute ("DAD", BooleanValue (false));
426  }
427  return m_uePgwAddressHelper6.Assign (ueDevices);
428 }
429 
432 {
433  // return the address of the tun device
434  return m_sgwPgw->GetObject<Ipv4> ()->GetAddress (1, 0).GetLocal ();
435 }
436 
439 {
440  // return the address of the tun device 6
441  return m_sgwPgw->GetObject<Ipv6> ()->GetAddress (1, 1).GetAddress ();
442 }
443 
444 } // namespace ns3
void Dispose(void)
Dispose of this Object.
Definition: object.cc:214
Ptr< const AttributeChecker > MakeStringChecker(void)
Definition: string.cc:30
uint32_t AddApplication(Ptr< Application > application)
Associate an Application to this Node.
Definition: node.cc:157
static TypeId GetTypeId(void)
Register this type.
virtual uint8_t ActivateEpsBearer(Ptr< NetDevice > ueLteDevice, uint64_t imsi, Ptr< EpcTft > tft, EpsBearer bearer)
Activate an EPS bearer, setting up the corresponding S1-U tunnel.
Iterator Begin(void) const
Get an iterator which refers to the first NetDevice in the container.
virtual void DoInitialize(void)
Initialize() implementation.
Definition: object.cc:353
virtual NetDeviceContainer Install(Ptr< Node > node) const
This method creates a FdNetDevice and associates it to a node.
void ActivateEpsBearer(EpsBearer bearer, Ptr< EpcTft > tft)
Activate an EPS bearer.
Definition: epc-ue-nas.cc:187
an Inet address class
static Ipv4Address GetAny(void)
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:73
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by "...
AttributeValue implementation for Boolean.
Definition: boolean.h:36
uint32_t GetNApplications(void) const
Definition: node.cc:176
Keep track of a set of IPv6 interfaces.
holds a vector of std::pair of Ptr<Ipv4> and interface index.
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:45
uint16_t GetCellId() const
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:459
Access to the IPv6 forwarding table, interfaces, and configuration.
Definition: ipv6.h:81
Hold variables of type string.
Definition: string.h:41
void SetDefaultRouteInAllNodes(uint32_t router)
Set the default route for all the devices (except the router itself).
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
uint16_t m_gtpuUdpPort
UDP port where the GTP-U Socket is bound, fixed by the standard as 2152.
std::string m_sgwDeviceName
The name of the device used for the S1-U interface of the SGW.
void AggregateObject(Ptr< Object > other)
Aggregate two Objects together.
Definition: object.cc:252
Ipv4InterfaceContainer m_sgwIpIfaces
Container for Ipv4Interfaces of the SGW/PGW.
EmuEpcHelper()
Constructor.
an address for a packet socket
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file...
Definition: assert.h:67
Ptr< Ipv6StaticRouting > GetStaticRouting(Ptr< Ipv6 > ipv6) const
Get Ipv6StaticRouting pointer from IPv6 stack.
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
aggregate IP/TCP/UDP functionality to existing Nodes.
void SetBase(Ipv6Address network, Ipv6Prefix prefix, Ipv6Address base=Ipv6Address("::1"))
Set the base network number, network prefix, and base interface ID.
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:278
Callback< R > MakeNullCallback(void)
Definition: callback.h:1635
Ipv4AddressHelper m_uePgwAddressHelper
helper to assign IPv4 addresses to UE devices as well as to the TUN device of the SGW/PGW ...
void SetSingleDevice(uint32_t device)
Set the address to match only a specified NetDevice.
virtual void AddUe(Ptr< NetDevice > ueLteDevice, uint64_t imsi)
Notify the EPC of the existence of a new UE which might attach at a later time.
void SetForwarding(uint32_t i, bool state)
Set the state of the stack (act as a router or as an host) for the specified index.
a polymophic address class
Definition: address.h:90
Ipv6InterfaceContainer Assign(const NetDeviceContainer &c)
Allocate an Ipv6InterfaceContainer with auto-assigned addresses.
Ipv6Address GetUeDefaultGatewayAddress6()
virtual void DoInitialize()
Initialize() implementation.
This class contains the specification of EPS Bearers.
Definition: eps-bearer.h:71
Ptr< Application > GetApplication(uint32_t index) const
Retrieve the index-th Application associated to this node.
Definition: node.cc:168
NS_ASSERT_MSG(false,"Ipv4AddressGenerator::MaskToIndex(): Impossible")
static Mac48Address Allocate(void)
Allocate a new Mac48Address.
Ipv6InterfaceContainer AssignUeIpv6Address(NetDeviceContainer ueDevices)
bool RecvFromTunDevice(Ptr< Packet > packet, const Address &source, const Address &dest, uint16_t protocolNumber)
Method to be assigned to the callback of the Gi TUN VirtualNetDevice.
virtual Ipv6InterfaceAddress GetAddress(uint32_t interface, uint32_t addressIndex) const =0
Get IPv6 address on specified IPv6 interface.
void Add(NetDeviceContainer other)
Append the contents of another NetDeviceContainer to the end of this container.
Hold an unsigned integer type.
Definition: uinteger.h:44
virtual void SetAddress(Address address)
Set the address of this interface.
List of Attribute name, value and checker triples used to construct Objects.
holds a vector of ns3::NetDevice pointers
virtual void AddX2Interface(Ptr< Node > enbNode1, Ptr< Node > enbNode2)
Add an X2 interface between two eNB.
Ptr< NetDevice > GetDevice(uint32_t index) const
Retrieve the index-th NetDevice associated to this node.
Definition: node.cc:142
TypeId GetInstanceTypeId() const
Get the most derived TypeId for this Object.
static Mac48Address GetBroadcast(void)
An implementation of the ICMPv6 protocol.
virtual void AddEnb(Ptr< Node > enbNode, Ptr< NetDevice > lteEnbNetDevice, uint16_t cellId)
Add an eNB to the EPC.
Callback< R > MakeCallback(R(T::*memPtr)(void), OBJ objPtr)
Definition: callback.h:1489
static Ptr< Socket > CreateSocket(Ptr< Node > node, TypeId tid)
This method wraps the creation of sockets that is performed on a given node by a SocketFactory specif...
Definition: socket.cc:71
Create an EPC network using EmuFdNetDevice.
virtual int Connect(const Address &address)=0
Initiate a connection to a remote host.
Access to the IPv4 forwarding table, interfaces, and configuration.
Definition: ipv4.h:76
uint32_t GetNDevices(void) const
Definition: node.cc:150
void SetDeviceName(std::string deviceName)
Set the device name of this device.
std::string m_enbMacAddressBase
First 5 bytes of the Enb MAC address base.
std::string m_sgwMacAddress
MAC address used for the SGW.
Base helper class to handle the creation of the EPC entities.
Definition: epc-helper.h:51
virtual int Bind(const Address &address)=0
Allocate a local endpoint for this socket.
Every class exported by the ns3 library is enclosed in the ns3 namespace.
virtual Ipv4Address GetUeDefaultGatewayAddress()
void SetPhysicalAddress(const Address address)
Set the destination address.
This entity is installed inside an eNB and provides the functionality for the X2 interface.
Definition: epc-x2.h:99
Helper class that adds ns3::Ipv6StaticRouting objects.
virtual Ipv4InterfaceContainer AssignUeIpv4Address(NetDeviceContainer ueDevices)
Assign IPv4 addresses to UE devices.
void ConstructSelf(const AttributeConstructionList &attributes)
Complete construction of ObjectBase; invoked by derived classes.
Definition: object-base.cc:80
void Install(std::string nodeName) const
Aggregate implementations of the ns3::Ipv4, ns3::Ipv6, ns3::Udp, and ns3::Tcp classes onto the provid...
virtual ~EmuEpcHelper()
Destructor.
static EventId ScheduleNow(MEM mem_ptr, OBJ obj)
Schedule an event to expire Now.
Definition: simulator.h:1570
Ptr< EpcSgwPgwApplication > m_sgwPgwApp
SGW-PGW application.
NS_LOG_LOGIC("Net device "<< nd<< " is not bridged")
#define NS_ABORT_IF(cond)
Abnormal program termination if a condition is true.
Definition: abort.h:77
Describes an IPv6 address.
Definition: ipv6-address.h:49
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:40
Ipv4InterfaceContainer Assign(const NetDeviceContainer &c)
Assign IP addresses to the net devices specified in the container based on the current network prefix...
This application is installed inside eNBs and provides the bridge functionality for user data plane p...
uint32_t AddDevice(Ptr< NetDevice > device)
Associate a NetDevice to this node.
Definition: node.cc:128
virtual Ptr< Node > GetPgwNode()
#define NS_LOG_WARN(msg)
Use NS_LOG to output a message of level LOG_WARN.
Definition: log.h:262
AttributeValue implementation for Mac48Address.
std::string m_enbDeviceName
The name of the device used for the S1-U interface of the eNB.
std::vector< Ptr< NetDevice > >::const_iterator Iterator
NetDevice container iterator.
void SetProtocol(uint16_t protocol)
Set the protocol.
Describes an IPv6 prefix.
Definition: ipv6-address.h:428
Ipv6AddressHelper m_uePgwAddressHelper6
helper to assign IPv6 addresses to UE devices as well as to the TUN device of the SGW/PGW ...
Ptr< const AttributeAccessor > MakeStringAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method...
Definition: string.h:42
void SetSendCallback(SendCallback transmitCb)
Set the user callback to be called when a L2 packet is to be transmitted.
Iterator End(void) const
Get an iterator which indicates past-the-last NetDevice in the container.
Ipv4AddressHelper m_epcIpv4AddressHelper
helper to assign addresses to S1-U NetDevices
virtual void DoDispose()
Destructor implementation.
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:185
The eNodeB device implementation.
build a set of FdNetDevice objects attached to a physical network interface
Ptr< VirtualNetDevice > m_tunDevice
TUN device containing IPv4 address and implementing tunneling of user data over GTP-U/UDP/IP.
a unique identifier for an interface.
Definition: type-id.h:58
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:915
static const uint16_t PROT_NUMBER
The protocol number for IPv6 (0x86DD).
Ptr< Node > m_sgwPgw
SGW-PGW network element.
void Initialize(void)
Invoke DoInitialize on all Objects aggregated to this one.
Definition: object.cc:183
virtual uint32_t GetNInterfaces(void) const =0
static const uint16_t PROT_NUMBER
Protocol number (0x0800)
void SetBase(Ipv4Address network, Ipv4Mask mask, Ipv4Address base="0.0.0.1")
Set the base network number, network mask and base address.
static TypeId LookupByName(std::string name)
Get a TypeId by name.
Definition: type-id.cc:824
Ipv4Address GetAddress(uint32_t i, uint32_t j=0) const
Ptr< EpcMme > m_mme
MME network element.
The LteUeNetDevice class implements the UE net device.