1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
2 /*
3 * Copyright (c) 2011 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: Manuel Requena <manuel.requena@cttc.es>
19 */
20
21 #include "ns3/simulator.h"
22 #include "ns3/log.h"
23 #include "ns3/node.h"
24
25 #include "ns3/lte-rlc-header.h"
26 #include "ns3/lte-rlc-am-header.h"
27 #include "ns3/lte-pdcp-header.h"
28
29 #include "lte-test-entities.h"
30
31 namespace ns3 {
32
33 NS_LOG_COMPONENT_DEFINE ("LteTestEntities");
34
35 /////////////////////////////////////////////////////////////////////
36
37 TypeId
GetTypeId(void)38 LteTestRrc::GetTypeId (void)
39 {
40 static TypeId tid = TypeId ("ns3::LteTestRrc")
41 .SetParent<Object> ()
42 .AddConstructor<LteTestRrc> ()
43 ;
44
45 return tid;
46 }
47
LteTestRrc()48 LteTestRrc::LteTestRrc ()
49 {
50 NS_LOG_FUNCTION (this);
51
52 m_txPdus = 0;
53 m_txBytes = 0;
54 m_rxPdus = 0;
55 m_rxBytes = 0;
56 m_txLastTime = Time (0);
57 m_rxLastTime = Time (0);
58
59 m_pdcpSapUser = new LtePdcpSpecificLtePdcpSapUser<LteTestRrc> (this);
60 // Simulator::ScheduleNow (&LteTestRrc::Start, this);
61 }
62
~LteTestRrc()63 LteTestRrc::~LteTestRrc ()
64 {
65 NS_LOG_FUNCTION (this);
66 }
67
68 void
DoDispose()69 LteTestRrc::DoDispose ()
70 {
71 NS_LOG_FUNCTION (this);
72 delete m_pdcpSapUser;
73 }
74
75 void
SetDevice(Ptr<NetDevice> device)76 LteTestRrc::SetDevice (Ptr<NetDevice> device)
77 {
78 m_device = device;
79 }
80
81 void
SetLtePdcpSapProvider(LtePdcpSapProvider * s)82 LteTestRrc::SetLtePdcpSapProvider (LtePdcpSapProvider* s)
83 {
84 m_pdcpSapProvider = s;
85 }
86
87 LtePdcpSapUser*
GetLtePdcpSapUser(void)88 LteTestRrc::GetLtePdcpSapUser (void)
89 {
90 return m_pdcpSapUser;
91 }
92
93
94 std::string
GetDataReceived(void)95 LteTestRrc::GetDataReceived (void)
96 {
97 NS_LOG_FUNCTION (this);
98 return m_receivedData;
99 }
100
101 // Stats
102 uint32_t
GetTxPdus(void)103 LteTestRrc::GetTxPdus (void)
104 {
105 NS_LOG_FUNCTION (this << m_txPdus);
106 return m_txPdus;
107 }
108
109 uint32_t
GetTxBytes(void)110 LteTestRrc::GetTxBytes (void)
111 {
112 NS_LOG_FUNCTION (this << m_txBytes);
113 return m_txBytes;
114 }
115
116 uint32_t
GetRxPdus(void)117 LteTestRrc::GetRxPdus (void)
118 {
119 NS_LOG_FUNCTION (this << m_rxPdus);
120 return m_rxPdus;
121 }
122
123 uint32_t
GetRxBytes(void)124 LteTestRrc::GetRxBytes (void)
125 {
126 NS_LOG_FUNCTION (this << m_rxBytes);
127 return m_rxBytes;
128 }
129
130 Time
GetTxLastTime(void)131 LteTestRrc::GetTxLastTime (void)
132 {
133 NS_LOG_FUNCTION (this << m_txLastTime);
134 return m_txLastTime;
135 }
136
137 Time
GetRxLastTime(void)138 LteTestRrc::GetRxLastTime (void)
139 {
140 NS_LOG_FUNCTION (this << m_rxLastTime);
141 return m_rxLastTime;
142 }
143
144
145 void
SetArrivalTime(Time arrivalTime)146 LteTestRrc::SetArrivalTime (Time arrivalTime)
147 {
148 NS_LOG_FUNCTION (this << arrivalTime);
149 m_arrivalTime = arrivalTime;
150 }
151
152 void
SetPduSize(uint32_t pduSize)153 LteTestRrc::SetPduSize (uint32_t pduSize)
154 {
155 NS_LOG_FUNCTION (this << pduSize);
156 m_pduSize = pduSize;
157 }
158
159
160 /**
161 * PDCP SAP
162 */
163
164 void
DoReceivePdcpSdu(LtePdcpSapUser::ReceivePdcpSduParameters params)165 LteTestRrc::DoReceivePdcpSdu (LtePdcpSapUser::ReceivePdcpSduParameters params)
166 {
167 NS_LOG_FUNCTION (this << params.pdcpSdu->GetSize ());
168 Ptr<Packet> p = params.pdcpSdu;
169 // NS_LOG_LOGIC ("PDU received = " << (*p));
170
171 uint32_t dataLen = p->GetSize ();
172 uint8_t *buf = new uint8_t[dataLen];
173
174 // Stats
175 m_rxPdus++;
176 m_rxBytes += dataLen;
177 m_rxLastTime = Simulator::Now ();
178
179 p->CopyData (buf, dataLen);
180 m_receivedData = std::string ((char *)buf, dataLen);
181
182 // NS_LOG_LOGIC (m_receivedData);
183
184 delete [] buf;
185 }
186
187 /**
188 * START
189 */
190
191 void
Start()192 LteTestRrc::Start ()
193 {
194 NS_LOG_FUNCTION (this);
195 NS_ASSERT_MSG (m_arrivalTime != Time (0), "Arrival time must be different from 0");
196
197 // Stats
198 m_txPdus++;
199 m_txBytes += m_pduSize;
200 m_txLastTime = Simulator::Now ();
201
202 LtePdcpSapProvider::TransmitPdcpSduParameters p;
203 p.rnti = 1111;
204 p.lcid = 222;
205 p.pdcpSdu = Create<Packet> (m_pduSize);
206
207 bool haveContext = false;
208 Ptr<Node> node;
209 if (m_device != 0)
210 {
211 node = m_device->GetNode ();
212 if (node != 0)
213 {
214 haveContext = true;
215 }
216 }
217 if (haveContext)
218 {
219 Simulator::ScheduleWithContext (node->GetId (), Seconds (0), &LtePdcpSapProvider::TransmitPdcpSdu, m_pdcpSapProvider, p);
220 }
221 else
222 {
223 Simulator::Schedule (Seconds (0), &LtePdcpSapProvider::TransmitPdcpSdu, m_pdcpSapProvider, p);
224 }
225
226 m_nextPdu = Simulator::Schedule (m_arrivalTime, &LteTestRrc::Start, this);
227 // Simulator::Run ();
228 }
229
230 void
Stop()231 LteTestRrc::Stop ()
232 {
233 NS_LOG_FUNCTION (this);
234 m_nextPdu.Cancel ();
235 }
236
237 void
SendData(Time at,std::string dataToSend)238 LteTestRrc::SendData (Time at, std::string dataToSend)
239 {
240 NS_LOG_FUNCTION (this << at << dataToSend.length () << dataToSend);
241
242 // Stats
243 m_txPdus++;
244 m_txBytes += dataToSend.length ();
245
246 LtePdcpSapProvider::TransmitPdcpSduParameters p;
247 p.rnti = 1111;
248 p.lcid = 222;
249
250 NS_LOG_LOGIC ("Data(" << dataToSend.length () << ") = " << dataToSend.data ());
251 p.pdcpSdu = Create<Packet> ((uint8_t *) dataToSend.data (), dataToSend.length ());
252
253 NS_LOG_LOGIC ("Packet(" << p.pdcpSdu->GetSize () << ")");
254 Simulator::Schedule (at, &LtePdcpSapProvider::TransmitPdcpSdu, m_pdcpSapProvider, p);
255 }
256
257 /////////////////////////////////////////////////////////////////////
258
259 TypeId
GetTypeId(void)260 LteTestPdcp::GetTypeId (void)
261 {
262 static TypeId tid = TypeId ("ns3::LteTestPdcp")
263 .SetParent<Object> ()
264 .AddConstructor<LteTestPdcp> ()
265 ;
266
267 return tid;
268 }
269
LteTestPdcp()270 LteTestPdcp::LteTestPdcp ()
271 {
272 NS_LOG_FUNCTION (this);
273 m_rlcSapUser = new LteRlcSpecificLteRlcSapUser<LteTestPdcp> (this);
274 Simulator::ScheduleNow (&LteTestPdcp::Start, this);
275 }
276
~LteTestPdcp()277 LteTestPdcp::~LteTestPdcp ()
278 {
279 NS_LOG_FUNCTION (this);
280 }
281
282 void
DoDispose()283 LteTestPdcp::DoDispose ()
284 {
285 NS_LOG_FUNCTION (this);
286 delete m_rlcSapUser;
287 }
288
289 void
SetLteRlcSapProvider(LteRlcSapProvider * s)290 LteTestPdcp::SetLteRlcSapProvider (LteRlcSapProvider* s)
291 {
292 m_rlcSapProvider = s;
293 }
294
295 LteRlcSapUser*
GetLteRlcSapUser(void)296 LteTestPdcp::GetLteRlcSapUser (void)
297 {
298 return m_rlcSapUser;
299 }
300
301
302 std::string
GetDataReceived(void)303 LteTestPdcp::GetDataReceived (void)
304 {
305 NS_LOG_FUNCTION (this);
306
307 return m_receivedData;
308 }
309
310
311 /**
312 * RLC SAP
313 */
314
315 void
DoReceivePdcpPdu(Ptr<Packet> p)316 LteTestPdcp::DoReceivePdcpPdu (Ptr<Packet> p)
317 {
318 NS_LOG_FUNCTION (this << p->GetSize ());
319 NS_LOG_LOGIC ("Data = " << (*p));
320
321 uint32_t dataLen = p->GetSize ();
322 uint8_t *buf = new uint8_t[dataLen];
323 p->CopyData (buf, dataLen);
324 m_receivedData = std::string ((char *)buf, dataLen);
325
326 NS_LOG_LOGIC (m_receivedData);
327
328 delete [] buf;
329 }
330
331 /**
332 * START
333 */
334
335 void
Start()336 LteTestPdcp::Start ()
337 {
338 NS_LOG_FUNCTION (this);
339 }
340
341 void
SendData(Time time,std::string dataToSend)342 LteTestPdcp::SendData (Time time, std::string dataToSend)
343 {
344 NS_LOG_FUNCTION (this << time << dataToSend.length () << dataToSend);
345
346 LteRlcSapProvider::TransmitPdcpPduParameters p;
347 p.rnti = 1111;
348 p.lcid = 222;
349
350 NS_LOG_LOGIC ("Data(" << dataToSend.length () << ") = " << dataToSend.data ());
351 p.pdcpPdu = Create<Packet> ((uint8_t *) dataToSend.data (), dataToSend.length ());
352
353 NS_LOG_LOGIC ("Packet(" << p.pdcpPdu->GetSize () << ")");
354 Simulator::Schedule (time, &LteRlcSapProvider::TransmitPdcpPdu, m_rlcSapProvider, p);
355 }
356
357 /////////////////////////////////////////////////////////////////////
358
359 TypeId
GetTypeId(void)360 LteTestMac::GetTypeId (void)
361 {
362 static TypeId tid = TypeId ("ns3::LteTestMac")
363 .SetParent<Object> ()
364 .AddConstructor<LteTestMac> ()
365 ;
366
367 return tid;
368 }
369
LteTestMac()370 LteTestMac::LteTestMac ()
371 {
372 NS_LOG_FUNCTION (this);
373 m_device = 0;
374 m_macSapProvider = new EnbMacMemberLteMacSapProvider<LteTestMac> (this);
375 m_macSapUser = 0;
376 m_macLoopback = 0;
377 m_pdcpHeaderPresent = false;
378 m_rlcHeaderType = UM_RLC_HEADER;
379 m_txOpportunityMode = MANUAL_MODE;
380 m_txOppTime = Seconds (0.001);
381 m_txOppSize = 0;
382
383 m_txPdus = 0;
384 m_txBytes = 0;
385 m_rxPdus = 0;
386 m_rxBytes = 0;
387
388 // m_cmacSapProvider = new EnbMacMemberLteEnbCmacSapProvider (this);
389 // m_schedSapUser = new EnbMacMemberFfMacSchedSapUser (this);
390 // m_cschedSapUser = new EnbMacMemberFfMacCschedSapUser (this);
391 // m_enbPhySapUser = new EnbMacMemberLteEnbPhySapUser (this);
392 }
393
~LteTestMac()394 LteTestMac::~LteTestMac ()
395 {
396 NS_LOG_FUNCTION (this);
397 }
398
399 void
DoDispose()400 LteTestMac::DoDispose ()
401 {
402 NS_LOG_FUNCTION (this);
403 delete m_macSapProvider;
404 // delete m_cmacSapProvider;
405 // delete m_schedSapUser;
406 // delete m_cschedSapUser;
407 // delete m_enbPhySapUser;
408
409 m_device = 0;
410 }
411
412 void
SetDevice(Ptr<NetDevice> device)413 LteTestMac::SetDevice (Ptr<NetDevice> device)
414 {
415 m_device = device;
416 }
417
418 void
SetLteMacSapUser(LteMacSapUser * s)419 LteTestMac::SetLteMacSapUser (LteMacSapUser* s)
420 {
421 m_macSapUser = s;
422 }
423
424 LteMacSapProvider*
GetLteMacSapProvider(void)425 LteTestMac::GetLteMacSapProvider (void)
426 {
427 return m_macSapProvider;
428 }
429
430 void
SetLteMacLoopback(Ptr<LteTestMac> s)431 LteTestMac::SetLteMacLoopback (Ptr<LteTestMac> s)
432 {
433 m_macLoopback = s;
434 }
435
436 std::string
GetDataReceived(void)437 LteTestMac::GetDataReceived (void)
438 {
439 NS_LOG_FUNCTION (this);
440 return m_receivedData;
441 }
442
443 // Stats
444 uint32_t
GetTxPdus(void)445 LteTestMac::GetTxPdus (void)
446 {
447 NS_LOG_FUNCTION (this << m_txPdus);
448 return m_txPdus;
449 }
450
451 uint32_t
GetTxBytes(void)452 LteTestMac::GetTxBytes (void)
453 {
454 NS_LOG_FUNCTION (this << m_txBytes);
455 return m_txBytes;
456 }
457
458 uint32_t
GetRxPdus(void)459 LteTestMac::GetRxPdus (void)
460 {
461 NS_LOG_FUNCTION (this << m_rxPdus);
462 return m_rxPdus;
463 }
464
465 uint32_t
GetRxBytes(void)466 LteTestMac::GetRxBytes (void)
467 {
468 NS_LOG_FUNCTION (this << m_rxBytes);
469 return m_rxBytes;
470 }
471
472
473 void
SendTxOpportunity(Time time,uint32_t bytes)474 LteTestMac::SendTxOpportunity (Time time, uint32_t bytes)
475 {
476 NS_LOG_FUNCTION (this << time << bytes);
477 bool haveContext = false;
478 Ptr<Node> node;
479 if (m_device != 0)
480 {
481 node = m_device->GetNode ();
482 if (node != 0)
483 {
484 haveContext = true;
485 }
486 }
487 LteMacSapUser::TxOpportunityParameters txOpParmas;
488 txOpParmas.bytes = bytes;
489 txOpParmas.layer = 0;
490 txOpParmas.componentCarrierId = 0;
491 txOpParmas.harqId = 0;
492 txOpParmas.rnti = 0;
493 txOpParmas.lcid = 0;
494
495 if (haveContext)
496 {
497 Simulator::ScheduleWithContext (node->GetId (), time, &LteMacSapUser::NotifyTxOpportunity, m_macSapUser, txOpParmas);
498 }
499 else
500 {
501 Simulator::Schedule (time, &LteMacSapUser::NotifyTxOpportunity, m_macSapUser, txOpParmas);
502 }
503
504 if (m_txOpportunityMode == RANDOM_MODE)
505 {
506 if (m_txOppTime != Seconds (0))
507 {
508 Simulator::Schedule (m_txOppTime, &LteTestMac::SendTxOpportunity, this, m_txOppTime, m_txOppSize);
509 }
510 }
511 }
512
513 void
SetPdcpHeaderPresent(bool present)514 LteTestMac::SetPdcpHeaderPresent (bool present)
515 {
516 NS_LOG_FUNCTION (this << present);
517 m_pdcpHeaderPresent = present;
518 }
519
520 void
SetRlcHeaderType(uint8_t rlcHeaderType)521 LteTestMac::SetRlcHeaderType (uint8_t rlcHeaderType)
522 {
523 NS_LOG_FUNCTION (this << rlcHeaderType);
524 m_rlcHeaderType = rlcHeaderType;
525 }
526
527 void
SetTxOpportunityMode(uint8_t mode)528 LteTestMac::SetTxOpportunityMode (uint8_t mode)
529 {
530 NS_LOG_FUNCTION (this << (uint32_t)mode);
531 m_txOpportunityMode = mode;
532
533 if (m_txOpportunityMode == RANDOM_MODE)
534 {
535 if (m_txOppTime != Seconds (0.0))
536 {
537 SendTxOpportunity (m_txOppTime, m_txOppSize);
538 }
539 }
540 }
541
542 void
SetTxOppTime(Time txOppTime)543 LteTestMac::SetTxOppTime (Time txOppTime)
544 {
545 NS_LOG_FUNCTION (this << txOppTime);
546 m_txOppTime = txOppTime;
547 }
548
549 void
SetTxOppSize(uint32_t txOppSize)550 LteTestMac::SetTxOppSize (uint32_t txOppSize)
551 {
552 NS_LOG_FUNCTION (this << txOppSize);
553 m_txOppSize = txOppSize;
554 }
555
556
557 /**
558 * MAC SAP
559 */
560
561 void
DoTransmitPdu(LteMacSapProvider::TransmitPduParameters params)562 LteTestMac::DoTransmitPdu (LteMacSapProvider::TransmitPduParameters params)
563 {
564 NS_LOG_FUNCTION (this << params.pdu->GetSize ());
565
566 m_txPdus++;
567 m_txBytes += params.pdu->GetSize ();
568
569 LteMacSapUser::ReceivePduParameters rxPduParams;
570 rxPduParams.p = params.pdu;
571 rxPduParams.rnti = params.rnti;
572 rxPduParams.lcid = params.lcid;
573
574 if (m_device)
575 {
576 m_device->Send (params.pdu, m_device->GetBroadcast (), 0);
577 }
578 else if (m_macLoopback)
579 {
580 Simulator::Schedule (Seconds (0.1), &LteMacSapUser::ReceivePdu,
581 m_macLoopback->m_macSapUser, rxPduParams);
582 }
583 else
584 {
585 LtePdcpHeader pdcpHeader;
586
587 if (m_rlcHeaderType == AM_RLC_HEADER)
588 {
589 // Remove AM RLC header
590 LteRlcAmHeader rlcAmHeader;
591 params.pdu->RemoveHeader (rlcAmHeader);
592 NS_LOG_LOGIC ("AM RLC header: " << rlcAmHeader);
593 }
594 else // if (m_rlcHeaderType == UM_RLC_HEADER)
595 {
596 // Remove UM RLC header
597 LteRlcHeader rlcHeader;
598 params.pdu->RemoveHeader (rlcHeader);
599 NS_LOG_LOGIC ("UM RLC header: " << rlcHeader);
600 }
601
602 // Remove PDCP header, if present
603 if (m_pdcpHeaderPresent)
604 {
605 params.pdu->RemoveHeader (pdcpHeader);
606 NS_LOG_LOGIC ("PDCP header: " << pdcpHeader);
607 }
608
609 // Copy data to a string
610 uint32_t dataLen = params.pdu->GetSize ();
611 uint8_t *buf = new uint8_t[dataLen];
612 params.pdu->CopyData (buf, dataLen);
613 m_receivedData = std::string ((char *)buf, dataLen);
614
615 NS_LOG_LOGIC ("Data (" << dataLen << ") = " << m_receivedData);
616 delete [] buf;
617 }
618 }
619
620 void
DoReportBufferStatus(LteMacSapProvider::ReportBufferStatusParameters params)621 LteTestMac::DoReportBufferStatus (LteMacSapProvider::ReportBufferStatusParameters params)
622 {
623 NS_LOG_FUNCTION (this << params.txQueueSize << params.retxQueueSize << params.statusPduSize);
624
625 if (m_txOpportunityMode == AUTOMATIC_MODE)
626 {
627 // cancel all previously scheduled TxOpps
628 for (std::list<EventId>::iterator it = m_nextTxOppList.begin ();
629 it != m_nextTxOppList.end ();
630 ++it)
631 {
632 it->Cancel ();
633 }
634 m_nextTxOppList.clear ();
635
636 int32_t size = params.statusPduSize + params.txQueueSize + params.retxQueueSize;
637 Time time = m_txOppTime;
638 LteMacSapUser::TxOpportunityParameters txOpParmas;
639 txOpParmas.bytes = m_txOppSize;
640 txOpParmas.layer = 0;
641 txOpParmas.componentCarrierId = 0;
642 txOpParmas.harqId = 0;
643 txOpParmas.rnti = params.rnti;
644 txOpParmas.lcid = params.lcid;
645 while (size > 0)
646 {
647 EventId e = Simulator::Schedule (time,
648 &LteMacSapUser::NotifyTxOpportunity,
649 m_macSapUser, txOpParmas);
650 m_nextTxOppList.push_back (e);
651 size -= m_txOppSize;
652 time += m_txOppTime;
653 }
654 }
655 }
656
657
658 bool
Receive(Ptr<NetDevice> nd,Ptr<const Packet> p,uint16_t protocol,const Address & addr)659 LteTestMac::Receive (Ptr<NetDevice> nd, Ptr<const Packet> p, uint16_t protocol, const Address& addr)
660 {
661 NS_LOG_FUNCTION (this << addr << protocol << p->GetSize ());
662
663 m_rxPdus++;
664 m_rxBytes += p->GetSize ();
665
666 Ptr<Packet> packet = p->Copy ();
667 LteMacSapUser::ReceivePduParameters rxPduParams;
668 rxPduParams.p = packet;
669 rxPduParams.rnti = 0;
670 rxPduParams.lcid = 0;
671 m_macSapUser->ReceivePdu (rxPduParams);
672 return true;
673 }
674
675
676
677
678
679
680
681
682 NS_OBJECT_ENSURE_REGISTERED (EpcTestRrc);
683
EpcTestRrc()684 EpcTestRrc::EpcTestRrc ()
685 : m_s1SapProvider (0)
686 {
687 NS_LOG_FUNCTION (this);
688 m_s1SapUser = new MemberEpcEnbS1SapUser<EpcTestRrc> (this);
689 }
690
691
~EpcTestRrc()692 EpcTestRrc::~EpcTestRrc ()
693 {
694 NS_LOG_FUNCTION (this);
695 }
696
697
698 void
DoDispose()699 EpcTestRrc::DoDispose ()
700 {
701 NS_LOG_FUNCTION (this);
702 delete m_s1SapUser;
703 }
704
705 TypeId
GetTypeId(void)706 EpcTestRrc::GetTypeId (void)
707 {
708 NS_LOG_FUNCTION ("EpcTestRrc::GetTypeId");
709 static TypeId tid = TypeId ("ns3::EpcTestRrc")
710 .SetParent<Object> ()
711 .AddConstructor<EpcTestRrc> ()
712 ;
713 return tid;
714 }
715 void
SetS1SapProvider(EpcEnbS1SapProvider * s)716 EpcTestRrc::SetS1SapProvider (EpcEnbS1SapProvider * s)
717 {
718 m_s1SapProvider = s;
719 }
720
721
722 EpcEnbS1SapUser*
GetS1SapUser()723 EpcTestRrc::GetS1SapUser ()
724 {
725 return m_s1SapUser;
726 }
727
728 void
DoInitialContextSetupRequest(EpcEnbS1SapUser::InitialContextSetupRequestParameters request)729 EpcTestRrc::DoInitialContextSetupRequest (EpcEnbS1SapUser::InitialContextSetupRequestParameters request)
730 {
731
732 }
733
734 void
DoDataRadioBearerSetupRequest(EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters request)735 EpcTestRrc::DoDataRadioBearerSetupRequest (EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters request)
736 {
737
738 }
739
740 void
DoPathSwitchRequestAcknowledge(EpcEnbS1SapUser::PathSwitchRequestAcknowledgeParameters params)741 EpcTestRrc::DoPathSwitchRequestAcknowledge (EpcEnbS1SapUser::PathSwitchRequestAcknowledgeParameters params)
742 {
743
744 }
745
746
747 } // namespace ns3
748
749