A Discrete-Event Network Simulator
API
epc-test-s1u-uplink.cc
Go to the documentation of this file.
1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2007,2008,2009 INRIA, UDCAST
4  * Copyright (c) 2011 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation;
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18  *
19  * The original version of UdpClient is by Amine Ismail
20  * <amine.ismail@sophia.inria.fr> <amine.ismail@udcast.com>
21  * The rest of the code (including modifying UdpClient into
22  * EpsBearerTagUdpClient) is by Nicola Baldo <nbaldo@cttc.es>
23  */
24 
25 
26 
27 #include "ns3/simulator.h"
28 #include "ns3/log.h"
29 #include "ns3/test.h"
30 #include "ns3/point-to-point-epc-helper.h"
31 #include "ns3/epc-enb-application.h"
32 #include "ns3/packet-sink-helper.h"
33 #include "ns3/point-to-point-helper.h"
34 #include "ns3/csma-helper.h"
35 #include "ns3/internet-stack-helper.h"
36 #include "ns3/ipv4-address-helper.h"
37 #include "ns3/inet-socket-address.h"
38 #include "ns3/packet-sink.h"
39 #include <ns3/ipv4-static-routing-helper.h>
40 #include <ns3/ipv4-static-routing.h>
41 #include <ns3/ipv4-interface.h>
42 #include <ns3/mac48-address.h>
43 #include "ns3/seq-ts-header.h"
44 #include "ns3/eps-bearer-tag.h"
45 #include "ns3/arp-cache.h"
46 #include "ns3/boolean.h"
47 #include "ns3/uinteger.h"
48 #include "ns3/config.h"
49 #include "lte-test-entities.h"
50 
51 using namespace ns3;
52 
53 NS_LOG_COMPONENT_DEFINE ("EpcTestS1uUplink");
54 
68 {
69 public:
74  static TypeId
75  GetTypeId (void);
76 
84  EpsBearerTagUdpClient (uint16_t rnti, uint8_t bid);
85 
86  virtual ~EpsBearerTagUdpClient ();
87 
93  void SetRemote (Ipv4Address ip, uint16_t port);
94 
95 protected:
96  virtual void DoDispose (void);
97 
98 private:
99  virtual void StartApplication (void);
100  virtual void StopApplication (void);
101 
106  void ScheduleTransmit (Time dt);
108  void Send (void);
109 
110  uint32_t m_count;
112  uint32_t m_size;
113 
114  uint32_t m_sent;
117  uint16_t m_peerPort;
119 
120  uint16_t m_rnti;
121  uint8_t m_bid;
122 
123 };
124 
125 
126 
127 TypeId
129 {
130  static TypeId tid = TypeId ("ns3::EpsBearerTagUdpClient")
132  .AddConstructor<EpsBearerTagUdpClient> ()
133  .AddAttribute ("MaxPackets",
134  "The maximum number of packets the application will send",
135  UintegerValue (100),
137  MakeUintegerChecker<uint32_t> ())
138  .AddAttribute ("Interval",
139  "The time to wait between packets", TimeValue (Seconds (1.0)),
141  MakeTimeChecker ())
142  .AddAttribute ("RemoteAddress",
143  "The destination Ipv4Address of the outbound packets",
144  Ipv4AddressValue (),
147  .AddAttribute ("RemotePort", "The destination port of the outbound packets",
148  UintegerValue (100),
150  MakeUintegerChecker<uint16_t> ())
151  .AddAttribute ("PacketSize",
152  "Size of packets generated. The minimum packet size is 12 bytes which is the size of the header carrying the sequence number and the time stamp.",
153  UintegerValue (1024),
155  MakeUintegerChecker<uint32_t> ())
156  ;
157  return tid;
158 }
159 
161  : m_rnti (0),
162  m_bid (0)
163 {
165  m_sent = 0;
166  m_socket = 0;
167  m_sendEvent = EventId ();
168 }
169 
171  : m_rnti (rnti),
172  m_bid (bid)
173 {
175  m_sent = 0;
176  m_socket = 0;
177  m_sendEvent = EventId ();
178 }
179 
181 {
183 }
184 
185 void
187 {
188  m_peerAddress = ip;
189  m_peerPort = port;
190 }
191 
192 void
194 {
196  Application::DoDispose ();
197 }
198 
199 void
201 {
203 
204  if (m_socket == 0)
205  {
206  TypeId tid = TypeId::LookupByName ("ns3::UdpSocketFactory");
207  m_socket = Socket::CreateSocket (GetNode (), tid);
208  m_socket->Bind ();
210  }
211 
213  m_sendEvent = Simulator::Schedule (Seconds (0.0), &EpsBearerTagUdpClient::Send, this);
214 }
215 
216 void
218 {
220  Simulator::Cancel (m_sendEvent);
221 }
222 
223 void
225 {
228  SeqTsHeader seqTs;
229  seqTs.SetSeq (m_sent);
230  Ptr<Packet> p = Create<Packet> (m_size - (8 + 4)); // 8+4 : the size of the seqTs header
231  p->AddHeader (seqTs);
232 
233  EpsBearerTag tag (m_rnti, m_bid);
234  p->AddPacketTag (tag);
235 
236  if ((m_socket->Send (p)) >= 0)
237  {
238  ++m_sent;
239  NS_LOG_INFO ("TraceDelay TX " << m_size << " bytes to "
240  << m_peerAddress << " Uid: " << p->GetUid ()
241  << " Time: " << (Simulator::Now ()).As (Time::S));
242 
243  }
244  else
245  {
246  NS_LOG_INFO ("Error while sending " << m_size << " bytes to "
247  << m_peerAddress);
248  }
249 
250  if (m_sent < m_count)
251  {
252  m_sendEvent = Simulator::Schedule (m_interval, &EpsBearerTagUdpClient::Send, this);
253  }
254 }
255 
256 
257 
265 {
274  UeUlTestData (uint32_t n, uint32_t s, uint16_t r, uint8_t l);
275 
276  uint32_t numPkts;
277  uint32_t pktSize;
278  uint16_t rnti;
279  uint8_t bid;
280 
283 };
284 
285 UeUlTestData::UeUlTestData (uint32_t n, uint32_t s, uint16_t r, uint8_t l)
286  : numPkts (n),
287  pktSize (s),
288  rnti (r),
289  bid (l)
290 {}
291 
300 {
301  std::vector<UeUlTestData> ues;
302 };
303 
304 
312 {
313 public:
320  EpcS1uUlTestCase (std::string name, std::vector<EnbUlTestData> v);
321  virtual ~EpcS1uUlTestCase ();
322 
323 private:
324  virtual void DoRun (void);
325  std::vector<EnbUlTestData> m_enbUlTestData;
326 };
327 
328 
329 EpcS1uUlTestCase::EpcS1uUlTestCase (std::string name, std::vector<EnbUlTestData> v)
330  : TestCase (name),
331  m_enbUlTestData (v)
332 {}
333 
335 {}
336 
337 void
339 {
340  Ptr<PointToPointEpcHelper> epcHelper = CreateObject<PointToPointEpcHelper> ();
341  Ptr<Node> pgw = epcHelper->GetPgwNode ();
342 
343  // allow jumbo packets
344  Config::SetDefault ("ns3::CsmaNetDevice::Mtu", UintegerValue (30000));
345  Config::SetDefault ("ns3::PointToPointNetDevice::Mtu", UintegerValue (30000));
346  epcHelper->SetAttribute ("S1uLinkMtu", UintegerValue (30000));
347 
348  // Create a single RemoteHost
349  NodeContainer remoteHostContainer;
350  remoteHostContainer.Create (1);
351  Ptr<Node> remoteHost = remoteHostContainer.Get (0);
352  InternetStackHelper internet;
353  internet.Install (remoteHostContainer);
354 
355  // Create the internet
356  PointToPointHelper p2ph;
357  p2ph.SetDeviceAttribute ("DataRate", DataRateValue (DataRate ("100Gb/s")));
358  NetDeviceContainer internetDevices = p2ph.Install (pgw, remoteHost);
359  Ipv4AddressHelper ipv4h;
360  ipv4h.SetBase ("1.0.0.0", "255.0.0.0");
361  Ipv4InterfaceContainer internetNodesIpIfaceContainer = ipv4h.Assign (internetDevices);
362 
363  // setup default gateway for the remote hosts
364  Ipv4StaticRoutingHelper ipv4RoutingHelper;
365  Ptr<Ipv4StaticRouting> remoteHostStaticRouting = ipv4RoutingHelper.GetStaticRouting (remoteHost->GetObject<Ipv4> ());
366 
367  // hardcoded UE addresses for now
368  remoteHostStaticRouting->AddNetworkRouteTo (Ipv4Address ("7.0.0.0"), Ipv4Mask ("255.255.255.0"), 1);
369 
370 
371 
372  uint16_t udpSinkPort = 1234;
373 
374  NodeContainer enbs;
375  uint16_t cellIdCounter = 0;
376  uint64_t imsiCounter = 0;
377 
378  for (std::vector<EnbUlTestData>::iterator enbit = m_enbUlTestData.begin ();
379  enbit < m_enbUlTestData.end ();
380  ++enbit)
381  {
382  Ptr<Node> enb = CreateObject<Node> ();
383  enbs.Add (enb);
384 
385  // we test EPC without LTE, hence we use:
386  // 1) a CSMA network to simulate the cell
387  // 2) a raw socket opened on the CSMA device to simulate the LTE socket
388 
389  uint16_t cellId = ++cellIdCounter;
390 
391  NodeContainer ues;
392  ues.Create (enbit->ues.size ());
393 
394  NodeContainer cell;
395  cell.Add (ues);
396  cell.Add (enb);
397 
398  CsmaHelper csmaCell;
399  NetDeviceContainer cellDevices = csmaCell.Install (cell);
400 
401  // the eNB's CSMA NetDevice acting as an LTE NetDevice.
402  Ptr<NetDevice> enbDevice = cellDevices.Get (cellDevices.GetN () - 1);
403 
404  // Note that the EpcEnbApplication won't care of the actual NetDevice type
405  epcHelper->AddEnb (enb, enbDevice, cellId);
406 
407  // Plug test RRC entity
409  NS_ASSERT_MSG (enbApp != 0, "cannot retrieve EpcEnbApplication");
410  Ptr<EpcTestRrc> rrc = CreateObject<EpcTestRrc> ();
411  enb->AggregateObject (rrc);
412  rrc->SetS1SapProvider (enbApp->GetS1SapProvider ());
413  enbApp->SetS1SapUser (rrc->GetS1SapUser ());
414 
415  // we install the IP stack on UEs only
416  InternetStackHelper internet;
417  internet.Install (ues);
418 
419  // assign IP address to UEs, and install applications
420  for (uint32_t u = 0; u < ues.GetN (); ++u)
421  {
422  Ptr<NetDevice> ueLteDevice = cellDevices.Get (u);
423  Ipv4InterfaceContainer ueIpIface = epcHelper->AssignUeIpv4Address (NetDeviceContainer (ueLteDevice));
424 
425  Ptr<Node> ue = ues.Get (u);
426 
427  // disable IP Forwarding on the UE. This is because we use
428  // CSMA broadcast MAC addresses for this test. The problem
429  // won't happen with a LteUeNetDevice.
430  Ptr<Ipv4> ueIpv4 = ue->GetObject<Ipv4> ();
431  ueIpv4->SetAttribute ("IpForward", BooleanValue (false));
432 
433  // tell the UE to route all packets to the GW
434  Ptr<Ipv4StaticRouting> ueStaticRouting = ipv4RoutingHelper.GetStaticRouting (ueIpv4);
435  Ipv4Address gwAddr = epcHelper->GetUeDefaultGatewayAddress ();
436  NS_LOG_INFO ("GW address: " << gwAddr);
437  ueStaticRouting->SetDefaultRoute (gwAddr, 1);
438 
439  // since the UEs in this test use CSMA with IP enabled, and
440  // the eNB uses CSMA but without IP, we fool the UE's ARP
441  // cache into thinking that the IP address of the GW can be
442  // reached by sending a CSMA packet to the broadcast
443  // address, so the eNB will get it.
444  int32_t ueLteIpv4IfIndex = ueIpv4->GetInterfaceForDevice (ueLteDevice);
445  Ptr<Ipv4L3Protocol> ueIpv4L3Protocol = ue->GetObject<Ipv4L3Protocol> ();
446  Ptr<Ipv4Interface> ueLteIpv4Iface = ueIpv4L3Protocol->GetInterface (ueLteIpv4IfIndex);
447  Ptr<ArpCache> ueArpCache = ueLteIpv4Iface->GetArpCache ();
448  ueArpCache->SetAliveTimeout (Seconds (1000));
449  ArpCache::Entry* arpCacheEntry = ueArpCache->Add (gwAddr);
450  arpCacheEntry->SetMacAddress (Mac48Address::GetBroadcast ());
451  arpCacheEntry->MarkPermanent ();
452 
453 
454  PacketSinkHelper packetSinkHelper ("ns3::UdpSocketFactory",
455  InetSocketAddress (Ipv4Address::GetAny (), udpSinkPort));
456  ApplicationContainer sinkApp = packetSinkHelper.Install (remoteHost);
457  sinkApp.Start (Seconds (1.0));
458  sinkApp.Stop (Seconds (10.0));
459  enbit->ues[u].serverApp = sinkApp.Get (0)->GetObject<PacketSink> ();
460 
461  Time interPacketInterval = Seconds (0.01);
462  Ptr<EpsBearerTagUdpClient> client = CreateObject<EpsBearerTagUdpClient> (enbit->ues[u].rnti, enbit->ues[u].bid);
463  client->SetAttribute ("RemoteAddress", Ipv4AddressValue (internetNodesIpIfaceContainer.GetAddress (1)));
464  client->SetAttribute ("RemotePort", UintegerValue (udpSinkPort));
465  client->SetAttribute ("MaxPackets", UintegerValue (enbit->ues[u].numPkts));
466  client->SetAttribute ("Interval", TimeValue (interPacketInterval));
467  client->SetAttribute ("PacketSize", UintegerValue (enbit->ues[u].pktSize));
468  ue->AddApplication (client);
469  ApplicationContainer clientApp;
470  clientApp.Add (client);
471  clientApp.Start (Seconds (2.0));
472  clientApp.Stop (Seconds (10.0));
473  enbit->ues[u].clientApp = client;
474 
475  uint64_t imsi = ++imsiCounter;
476  epcHelper->AddUe (ueLteDevice, imsi);
477  epcHelper->ActivateEpsBearer (ueLteDevice, imsi, EpcTft::Default (), EpsBearer (EpsBearer::NGBR_VIDEO_TCP_DEFAULT));
478  Simulator::Schedule (MilliSeconds (10),
479  &EpcEnbS1SapProvider::InitialUeMessage,
480  enbApp->GetS1SapProvider (), imsi, enbit->ues[u].rnti);
481  // need this since all sinks are installed in the same node
482  ++udpSinkPort;
483  }
484 
485  }
486 
487  Simulator::Run ();
488 
489  for (std::vector<EnbUlTestData>::iterator enbit = m_enbUlTestData.begin ();
490  enbit < m_enbUlTestData.end ();
491  ++enbit)
492  {
493  for (std::vector<UeUlTestData>::iterator ueit = enbit->ues.begin ();
494  ueit < enbit->ues.end ();
495  ++ueit)
496  {
497  NS_TEST_ASSERT_MSG_EQ (ueit->serverApp->GetTotalRx (), (ueit->numPkts) * (ueit->pktSize), "wrong total received bytes");
498  }
499  }
500 
501  Simulator::Destroy ();
502 }
503 
504 
505 
506 
507 
512 {
513 public:
515 
517 
519  : TestSuite ("epc-s1u-uplink", SYSTEM)
520 {
521  std::vector<EnbUlTestData> v1;
522  EnbUlTestData e1;
523  UeUlTestData f1 (1, 100, 1, 1);
524  e1.ues.push_back (f1);
525  v1.push_back (e1);
526  AddTestCase (new EpcS1uUlTestCase ("1 eNB, 1UE", v1), TestCase::QUICK);
527 
528 
529  std::vector<EnbUlTestData> v2;
530  EnbUlTestData e2;
531  UeUlTestData f2_1 (1, 100, 1, 1);
532  e2.ues.push_back (f2_1);
533  UeUlTestData f2_2 (2, 200, 2, 1);
534  e2.ues.push_back (f2_2);
535  v2.push_back (e2);
536  AddTestCase (new EpcS1uUlTestCase ("1 eNB, 2UEs", v2), TestCase::QUICK);
537 
538 
539  std::vector<EnbUlTestData> v3;
540  v3.push_back (e1);
541  v3.push_back (e2);
542  AddTestCase (new EpcS1uUlTestCase ("2 eNBs", v3), TestCase::QUICK);
543 
544 
545  EnbUlTestData e3;
546  UeUlTestData f3_1 (3, 50, 1, 1);
547  e3.ues.push_back (f3_1);
548  UeUlTestData f3_2 (5, 1472, 2, 1);
549  e3.ues.push_back (f3_2);
550  UeUlTestData f3_3 (1, 1, 3, 1);
551  e3.ues.push_back (f3_2);
552  std::vector<EnbUlTestData> v4;
553  v4.push_back (e3);
554  v4.push_back (e1);
555  v4.push_back (e2);
556  AddTestCase (new EpcS1uUlTestCase ("3 eNBs", v4), TestCase::QUICK);
557 
558  std::vector<EnbUlTestData> v5;
559  EnbUlTestData e5;
560  UeUlTestData f5 (10, 3000, 1, 1);
561  e5.ues.push_back (f5);
562  v5.push_back (e5);
563  AddTestCase (new EpcS1uUlTestCase ("1 eNB, 10 pkts 3000 bytes each", v5), TestCase::QUICK);
564 
565  std::vector<EnbUlTestData> v6;
566  EnbUlTestData e6;
567  UeUlTestData f6 (50, 3000, 1, 1);
568  e6.ues.push_back (f6);
569  v6.push_back (e6);
570  AddTestCase (new EpcS1uUlTestCase ("1 eNB, 50 pkts 3000 bytes each", v6), TestCase::QUICK);
571 
572  std::vector<EnbUlTestData> v7;
573  EnbUlTestData e7;
574  UeUlTestData f7 (10, 15000, 1, 1);
575  e7.ues.push_back (f7);
576  v7.push_back (e7);
577  AddTestCase (new EpcS1uUlTestCase ("1 eNB, 10 pkts 15000 bytes each", v7), TestCase::QUICK);
578 
579  std::vector<EnbUlTestData> v8;
580  EnbUlTestData e8;
581  UeUlTestData f8 (100, 15000, 1, 1);
582  e8.ues.push_back (f8);
583  v8.push_back (e8);
584  AddTestCase (new EpcS1uUlTestCase ("1 eNB, 100 pkts 15000 bytes each", v8), TestCase::QUICK);
585 
586 }
static void Send(Ptr< NetDevice > dev, int level, std::string emuMode)
Definition: fd-emu-send.cc:55
virtual void DoRun(void)
Implementation to actually run this TestCase.
holds a vector of ns3::Application pointers.
uint32_t AddApplication(Ptr< Application > application)
Associate an Application to this Node.
Definition: node.cc:159
void MarkPermanent(void)
Changes the state of this entry to Permanent.
Definition: arp-cache.cc:414
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
uint64_t GetUid(void) const
Returns the packet&#39;s Uid.
Definition: packet.cc:390
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:103
an Inet address class
Test that the S1-U interface implementation works correctly.
AttributeValue implementation for Boolean.
Definition: boolean.h:36
void SetMacAddress(Address macAddress)
Definition: arp-cache.cc:460
ArpCache::Entry * Add(Ipv4Address to)
Add an Ipv4Address to this ARP cache.
Definition: arp-cache.cc:330
uint32_t m_count
maximum number of packets to send
holds a vector of std::pair of Ptr<Ipv4> and interface index.
void SetDefaultRoute(Ipv4Address nextHop, uint32_t interface, uint32_t metric=0)
Add a default route to the static routing table.
NetDeviceContainer Install(NodeContainer c)
a class to represent an Ipv4 address mask
Definition: ipv4-address.h:269
void Add(ApplicationContainer other)
Append the contents of another ApplicationContainer to the end of this container. ...
EpcS1uUlTestCase(std::string name, std::vector< EnbUlTestData > v)
Constructor.
Ptr< Application > clientApp
the client application
A suite of tests to run.
Definition: test.h:1343
void AggregateObject(Ptr< Object > other)
Aggregate two Objects together.
Definition: object.cc:252
Ptr< const AttributeChecker > MakeIpv4AddressChecker(void)
#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
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
uint8_t m_bid
the bearer identificator
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1297
ApplicationContainer Install(NodeContainer c) const
Install an ns3::PacketSinkApplication on each node of the input container configured with all the att...
aggregate IP/TCP/UDP functionality to existing Nodes.
uint32_t m_sent
number of packets sent
EventId m_sendEvent
the send event
Tag used to define the RNTI and EPS bearer ID for packets interchanged between the EpcEnbApplication ...
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:281
A helper to make it easier to instantiate an ns3::PacketSinkApplication on a set of nodes...
#define NS_LOG_FUNCTION_NOARGS()
Output the name of the function.
Build a set of PointToPointNetDevice objects.
encapsulates test code
Definition: test.h:1153
void SetDeviceAttribute(std::string name, const AttributeValue &value)
Set an attribute value to be propagated to each NetDevice created by the helper.
Callback< R, Ts... > MakeNullCallback(void)
Definition: callback.h:1682
void Send(void)
Send function.
uint16_t m_peerPort
the destination port of the outbound packets
bool IsExpired(void) const
This method is syntactic sugar for the ns3::Simulator::IsExpired method.
Definition: event-id.cc:65
virtual void DoDispose(void)
Destructor implementation.
uint16_t port
Definition: dsdv-manet.cc:45
Class for representing data rates.
Definition: data-rate.h:88
virtual void StartApplication(void)
Application specific startup code.
void SetS1SapUser(EpcEnbS1SapUser *s)
Set the S1 SAP User.
uint32_t m_size
the size of packets generated
virtual Ipv4InterfaceContainer AssignUeIpv4Address(NetDeviceContainer ueDevices)
Assign IPv4 addresses to UE devices.
Time m_interval
the time between packets
The base class for all ns3 applications.
Definition: application.h:60
AttributeValue implementation for Time.
Definition: nstime.h:1353
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:299
Ipv4Address GetAddress(uint32_t i, uint32_t j=0) const
std::vector< EnbUlTestData > m_enbUlTestData
ENB UL test data.
Hold an unsigned integer type.
Definition: uinteger.h:44
#define NS_TEST_ASSERT_MSG_EQ(actual, limit, msg)
Test that an actual and expected (limit) value are equal and report and abort if not.
Definition: test.h:166
Ptr< Ipv4Interface > GetInterface(uint32_t i) const
Get an interface.
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.
Ptr< Application > GetApplication(uint32_t index) const
Retrieve the index-th Application associated to this node.
Definition: node.cc:170
holds a vector of ns3::NetDevice pointers
void SetRemote(Ipv4Address ip, uint16_t port)
set the remote address and port
Ptr< Socket > m_socket
the socket
static TypeId GetTypeId(void)
Get the type ID.
void SetRecvCallback(Callback< void, Ptr< Socket > >)
Notify application when new data is available to be read.
Definition: socket.cc:128
Custom structure containing information about data sent in the uplink of eNodeB.
void Start(Time start)
Arrange for all of the Applications in this container to Start() at the Time given as a parameter...
void SetS1SapProvider(EpcEnbS1SapProvider *s)
Set the S1 SAP Provider.
EpcEnbS1SapUser * GetS1SapUser()
Ptr< Node > GetNode() const
Definition: application.cc:104
virtual void AddEnb(Ptr< Node > enbNode, Ptr< NetDevice > lteEnbNetDevice, uint16_t cellId)
Add an eNB to the EPC.
std::vector< UeUlTestData > ues
the list of UEs
uint32_t GetN(void) const
Get the number of Ptr<Node> stored in this container.
Packet header to carry sequence number and timestamp.
Definition: seq-ts-header.h:44
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
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:470
void SetAliveTimeout(Time aliveTimeout)
Set the time the entry will be in ALIVE state (unless refreshed)
Definition: arp-cache.cc:136
Implement the IPv4 layer.
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.
keep track of a set of node pointers.
EpcEnbS1SapProvider * GetS1SapProvider()
This class contains the specification of EPS Bearers.
Definition: eps-bearer.h:91
A record that that holds information about an ArpCache entry.
Definition: arp-cache.h:188
AttributeValue implementation for Ipv4Address.
Definition: ipv4-address.h:363
Ptr< const AttributeAccessor > MakeTimeAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method...
Definition: nstime.h:1354
UeUlTestData(uint32_t n, uint32_t s, uint16_t r, uint8_t l)
Constructor.
build a set of CsmaNetDevice objects
Definition: csma-helper.h:46
#define NS_ASSERT_MSG(condition, message)
At runtime, in debugging builds, if this condition is not true, the program prints the message to out...
Definition: assert.h:88
void Install(std::string nodeName) const
Aggregate implementations of the ns3::Ipv4, ns3::Ipv6, ns3::Udp, and ns3::Tcp classes onto the provid...
NetDeviceContainer Install(Ptr< Node > node) const
This method creates an ns3::CsmaChannel with the attributes configured by CsmaHelper::SetChannelAttri...
Definition: csma-helper.cc:218
void AddNetworkRouteTo(Ipv4Address network, Ipv4Mask networkMask, Ipv4Address nextHop, uint32_t interface, uint32_t metric=0)
Add a network route to the static routing table.
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.
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:41
uint32_t pktSize
the packet size
void Stop(Time stop)
Arrange for all of the Applications in this container to Stop() at the Time given as a parameter...
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...
uint16_t rnti
the RNTI
Ptr< PacketSink > serverApp
the server application
void Add(NodeContainer other)
Append the contents of another NodeContainer to the end of this container.
An identifier for simulation events.
Definition: event-id.h:53
void AddPacketTag(const Tag &tag) const
Add a packet tag.
Definition: packet.cc:956
Helper class that adds ns3::Ipv4StaticRouting objects.
AttributeValue implementation for DataRate.
Definition: data-rate.h:298
void SetSeq(uint32_t seq)
virtual Ptr< Node > GetPgwNode() const
Get the PGW node.
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1289
uint32_t GetN(void) const
Get the number of Ptr<NetDevice> stored in this container.
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:849
uint8_t bid
the BID
virtual void StopApplication(void)
Application specific shutdown code.
virtual int32_t GetInterfaceForDevice(Ptr< const NetDevice > device) const =0
uint32_t numPkts
the number of packets sent
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
Ptr< const AttributeChecker > MakeTimeChecker(const Time min, const Time max)
Helper to make a Time checker with bounded range.
Definition: time.cc:533
A helper class to make life easier while doing simple IPv4 address assignment in scripts.
Time Now(void)
create an ns3::Time instance which contains the current simulation time.
Definition: simulator.cc:287
Ipv4Address m_peerAddress
the peer address of the outbound packets
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
Ptr< const AttributeAccessor > MakeIpv4AddressAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method...
Definition: ipv4-address.h:363
Receive and consume traffic generated to an IP address and port.
Definition: packet-sink.h:71
virtual int Send(Ptr< Packet > p, uint32_t flags)=0
Send data (or dummy data) to the remote host.
uint32_t pktSize
packet size used for the simulation (in bytes)
Definition: wifi-bianchi.cc:83
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:185
Ptr< const AttributeAccessor > MakeUintegerAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method...
Definition: uinteger.h:45
a unique identifier for an interface.
Definition: type-id.h:58
Custom test structure to hold information of data transmitted in the uplink per UE.
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:923
Ptr< Application > Get(uint32_t i) const
Get the Ptr<Application> stored in this container at a given index.
virtual Ipv4Address GetUeDefaultGatewayAddress()
void AddHeader(const Header &header)
Add header to this packet.
Definition: packet.cc:256
EpcS1uUlTestCase class.
Ptr< Ipv4StaticRouting > GetStaticRouting(Ptr< Ipv4 > ipv4) const
Try and find the static routing protocol as either the main routing protocol or in the list of routin...
void SetBase(Ipv4Address network, Ipv4Mask mask, Ipv4Address base="0.0.0.1")
Set the base network number, network mask and base address.