A Discrete-Event Network Simulator
API
epc-x2-header.cc
Go to the documentation of this file.
1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2012 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/log.h"
22 #include "ns3/epc-x2-header.h"
23 
24 
25 namespace ns3 {
26 
27 NS_LOG_COMPONENT_DEFINE ("EpcX2Header");
28 
29 NS_OBJECT_ENSURE_REGISTERED (EpcX2Header);
30 
32  : m_messageType (0xfa),
33  m_procedureCode (0xfa),
34  m_lengthOfIes (0xfa),
35  m_numberOfIes (0xfa)
36 {
37 }
38 
40 {
41  m_messageType = 0xfb;
42  m_procedureCode = 0xfb;
43  m_lengthOfIes = 0xfb;
44  m_numberOfIes = 0xfb;
45 }
46 
47 TypeId
49 {
50  static TypeId tid = TypeId ("ns3::EpcX2Header")
51  .SetParent<Header> ()
52  .SetGroupName("Lte")
53  .AddConstructor<EpcX2Header> ()
54  ;
55  return tid;
56 }
57 
58 TypeId
60 {
61  return GetTypeId ();
62 }
63 
64 uint32_t
66 {
67  return 7;
68 }
69 
70 void
72 {
74 
77 
78  i.WriteU8 (0x00); // criticality = REJECT
79  i.WriteU8 (m_lengthOfIes + 3);
80  i.WriteHtonU16 (0);
82 }
83 
84 uint32_t
86 {
88 
89  m_messageType = i.ReadU8 ();
90  m_procedureCode = i.ReadU8 ();
91 
92  i.ReadU8 ();
93  m_lengthOfIes = i.ReadU8 () - 3;
94  i.ReadNtohU16 ();
95  m_numberOfIes = i.ReadU8 ();
96 
97  return GetSerializedSize ();
98 }
99 
100 void
101 EpcX2Header::Print (std::ostream &os) const
102 {
103  os << "MessageType=" << (uint32_t) m_messageType;
104  os << " ProcedureCode=" << (uint32_t) m_procedureCode;
105  os << " LengthOfIEs=" << (uint32_t) m_lengthOfIes;
106  os << " NumberOfIEs=" << (uint32_t) m_numberOfIes;
107 }
108 
109 uint8_t
111 {
112  return m_messageType;
113 }
114 
115 void
116 EpcX2Header::SetMessageType (uint8_t messageType)
117 {
118  m_messageType = messageType;
119 }
120 
121 uint8_t
123 {
124  return m_procedureCode;
125 }
126 
127 void
128 EpcX2Header::SetProcedureCode (uint8_t procedureCode)
129 {
130  m_procedureCode = procedureCode;
131 }
132 
133 
134 void
135 EpcX2Header::SetLengthOfIes (uint32_t lengthOfIes)
136 {
137  m_lengthOfIes = lengthOfIes;
138 }
139 
140 void
141 EpcX2Header::SetNumberOfIes (uint32_t numberOfIes)
142 {
143  m_numberOfIes = numberOfIes;
144 }
145 
147 
149 
151  : m_numberOfIes (1 + 1 + 1 + 1),
152  m_headerLength (6 + 5 + 12 + (3 + 4 + 8 + 8 + 4)),
153  m_oldEnbUeX2apId (0xfffa),
154  m_cause (0xfffa),
155  m_targetCellId (0xfffa),
156  m_mmeUeS1apId (0xfffffffa)
157 {
158  m_erabsToBeSetupList.clear ();
159 }
160 
162 {
163  m_numberOfIes = 0;
164  m_headerLength = 0;
165  m_oldEnbUeX2apId = 0xfffb;
166  m_cause = 0xfffb;
167  m_targetCellId = 0xfffb;
168  m_mmeUeS1apId = 0xfffffffb;
169  m_erabsToBeSetupList.clear ();
170 }
171 
172 TypeId
174 {
175  static TypeId tid = TypeId ("ns3::EpcX2HandoverRequestHeader")
176  .SetParent<Header> ()
177  .SetGroupName("Lte")
178  .AddConstructor<EpcX2HandoverRequestHeader> ()
179  ;
180  return tid;
181 }
182 
183 TypeId
185 {
186  return GetTypeId ();
187 }
188 
189 uint32_t
191 {
192  return m_headerLength;
193 }
194 
195 void
197 {
199 
200  i.WriteHtonU16 (10); // id = OLD_ENB_UE_X2AP_ID
201  i.WriteU8 (0); // criticality = REJECT
202  i.WriteU8 (2); // length of OLD_ENB_UE_X2AP_ID
204 
205  i.WriteHtonU16 (5); // id = CAUSE
206  i.WriteU8 (1 << 6); // criticality = IGNORE
207  i.WriteU8 (1); // length of CAUSE
208  i.WriteU8 (m_cause);
209 
210  i.WriteHtonU16 (11); // id = TARGET_CELLID
211  i.WriteU8 (0); // criticality = REJECT
212  i.WriteU8 (8); // length of TARGET_CELLID
213  i.WriteHtonU32 (0x123456); // fake PLMN
214  i.WriteHtonU32 (m_targetCellId << 4);
215 
216  i.WriteHtonU16 (14); // id = UE_CONTEXT_INFORMATION
217  i.WriteU8 (0); // criticality = REJECT
218 
222 
223  std::vector <EpcX2Sap::ErabToBeSetupItem>::size_type sz = m_erabsToBeSetupList.size ();
224  i.WriteHtonU32 (sz); // number of bearers
225  for (int j = 0; j < (int) sz; j++)
226  {
227  i.WriteHtonU16 (m_erabsToBeSetupList [j].erabId);
228  i.WriteHtonU16 (m_erabsToBeSetupList [j].erabLevelQosParameters.qci);
229  i.WriteHtonU64 (m_erabsToBeSetupList [j].erabLevelQosParameters.gbrQosInfo.gbrDl);
230  i.WriteHtonU64 (m_erabsToBeSetupList [j].erabLevelQosParameters.gbrQosInfo.gbrUl);
231  i.WriteHtonU64 (m_erabsToBeSetupList [j].erabLevelQosParameters.gbrQosInfo.mbrDl);
232  i.WriteHtonU64 (m_erabsToBeSetupList [j].erabLevelQosParameters.gbrQosInfo.mbrUl);
233  i.WriteU8 (m_erabsToBeSetupList [j].erabLevelQosParameters.arp.priorityLevel);
234  i.WriteU8 (m_erabsToBeSetupList [j].erabLevelQosParameters.arp.preemptionCapability);
235  i.WriteU8 (m_erabsToBeSetupList [j].erabLevelQosParameters.arp.preemptionVulnerability);
236  i.WriteU8 (m_erabsToBeSetupList [j].dlForwarding);
237  i.WriteHtonU32 (m_erabsToBeSetupList [j].transportLayerAddress.Get ());
238  i.WriteHtonU32 (m_erabsToBeSetupList [j].gtpTeid);
239  }
240 
241 }
242 
243 uint32_t
245 {
247 
248  m_headerLength = 0;
249  m_numberOfIes = 0;
250 
251  i.ReadNtohU16 ();
252  i.ReadU8 ();
253  i.ReadU8 ();
255  m_headerLength += 6;
256  m_numberOfIes++;
257 
258  i.ReadNtohU16 ();
259  i.ReadU8 ();
260  i.ReadU8 ();
261  m_cause = i.ReadU8 ();
262  m_headerLength += 5;
263  m_numberOfIes++;
264 
265  i.ReadNtohU16 ();
266  i.ReadU8 ();
267  i.ReadU8 ();
268  i.ReadNtohU32 ();
269  m_targetCellId = i.ReadNtohU32 () >> 4;
270  m_headerLength += 12;
271  m_numberOfIes++;
272 
273  i.ReadNtohU16 ();
274  i.ReadU8 ();
275  m_mmeUeS1apId = i.ReadNtohU32 ();
278  int sz = i.ReadNtohU32 ();
279  m_headerLength += 27;
280  m_numberOfIes++;
281 
282  for (int j = 0; j < sz; j++)
283  {
285 
286  erabItem.erabId = i.ReadNtohU16 ();
287 
296 
297  erabItem.dlForwarding = i.ReadU8 ();
299  erabItem.gtpTeid = i.ReadNtohU32 ();
300 
301  m_erabsToBeSetupList.push_back (erabItem);
302  m_headerLength += 48;
303  }
304 
305  return GetSerializedSize ();
306 }
307 
308 void
309 EpcX2HandoverRequestHeader::Print (std::ostream &os) const
310 {
311  os << "OldEnbUeX2apId = " << m_oldEnbUeX2apId;
312  os << " Cause = " << m_cause;
313  os << " TargetCellId = " << m_targetCellId;
314  os << " MmeUeS1apId = " << m_mmeUeS1apId;
315  os << " UeAggrMaxBitRateDownlink = " << m_ueAggregateMaxBitRateDownlink;
316  os << " UeAggrMaxBitRateUplink = " << m_ueAggregateMaxBitRateUplink;
317  os << " NumOfBearers = " << m_erabsToBeSetupList.size ();
318 
319  std::vector <EpcX2Sap::ErabToBeSetupItem>::size_type sz = m_erabsToBeSetupList.size ();
320  if (sz > 0)
321  {
322  os << " [";
323  }
324  for (int j = 0; j < (int) sz; j++)
325  {
326  os << m_erabsToBeSetupList[j].erabId;
327  if (j < (int) sz - 1)
328  {
329  os << ", ";
330  }
331  else
332  {
333  os << "]";
334  }
335  }
336 }
337 
338 uint16_t
340 {
341  return m_oldEnbUeX2apId;
342 }
343 
344 void
346 {
347  m_oldEnbUeX2apId = x2apId;
348 }
349 
350 uint16_t
352 {
353  return m_cause;
354 }
355 
356 void
358 {
359  m_cause = cause;
360 }
361 
362 uint16_t
364 {
365  return m_targetCellId;
366 }
367 
368 void
370 {
371  m_targetCellId = targetCellId;
372 }
373 
374 uint32_t
376 {
377  return m_mmeUeS1apId;
378 }
379 
380 void
382 {
383  m_mmeUeS1apId = mmeUeS1apId;
384 }
385 
386 std::vector <EpcX2Sap::ErabToBeSetupItem>
388 {
389  return m_erabsToBeSetupList;
390 }
391 
392 void
393 EpcX2HandoverRequestHeader::SetBearers (std::vector <EpcX2Sap::ErabToBeSetupItem> bearers)
394 {
395  m_headerLength += 48 * bearers.size ();
396  m_erabsToBeSetupList = bearers;
397 }
398 
399 uint64_t
401 {
403 }
404 
405 void
407 {
409 }
410 
411 uint64_t
413 {
415 }
416 
417 void
419 {
421 }
422 
423 uint32_t
425 {
426  return m_headerLength;
427 }
428 
429 uint32_t
431 {
432  return m_numberOfIes;
433 }
434 
436 
438 
440  : m_numberOfIes (1 + 1 + 1 + 1),
441  m_headerLength (2 + 2 + 4 + 4),
442  m_oldEnbUeX2apId (0xfffa),
443  m_newEnbUeX2apId (0xfffa)
444 {
445 }
446 
448 {
449  m_numberOfIes = 0;
450  m_headerLength = 0;
451  m_oldEnbUeX2apId = 0xfffb;
452  m_newEnbUeX2apId = 0xfffb;
453  m_erabsAdmittedList.clear ();
454  m_erabsNotAdmittedList.clear ();
455 }
456 
457 TypeId
459 {
460  static TypeId tid = TypeId ("ns3::EpcX2HandoverRequestAckHeader")
461  .SetParent<Header> ()
462  .SetGroupName("Lte")
463  .AddConstructor<EpcX2HandoverRequestAckHeader> ()
464  ;
465  return tid;
466 }
467 
468 TypeId
470 {
471  return GetTypeId ();
472 }
473 
474 uint32_t
476 {
477  return m_headerLength;
478 }
479 
480 void
482 {
484 
487 
488  std::vector <EpcX2Sap::ErabAdmittedItem>::size_type sz = m_erabsAdmittedList.size ();
489  i.WriteHtonU32 (sz);
490  for (int j = 0; j < (int) sz; j++)
491  {
492  i.WriteHtonU16 (m_erabsAdmittedList [j].erabId);
493  i.WriteHtonU32 (m_erabsAdmittedList [j].ulGtpTeid);
494  i.WriteHtonU32 (m_erabsAdmittedList [j].dlGtpTeid);
495  }
496 
497  std::vector <EpcX2Sap::ErabNotAdmittedItem>::size_type sz2 = m_erabsNotAdmittedList.size ();
498  i.WriteHtonU32 (sz2);
499  for (int j = 0; j < (int) sz2; j++)
500  {
501  i.WriteHtonU16 (m_erabsNotAdmittedList [j].erabId);
502  i.WriteHtonU16 (m_erabsNotAdmittedList [j].cause);
503  }
504 }
505 
506 uint32_t
508 {
510 
511  m_headerLength = 0;
512  m_numberOfIes = 0;
513 
516  m_headerLength += 4;
517  m_numberOfIes += 2;
518 
519  int sz = i.ReadNtohU32 ();
520  m_headerLength += 4;
521  m_numberOfIes++;
522 
523  for (int j = 0; j < sz; j++)
524  {
526 
527  erabItem.erabId = i.ReadNtohU16 ();
528  erabItem.ulGtpTeid = i.ReadNtohU32 ();
529  erabItem.dlGtpTeid = i.ReadNtohU32 ();
530 
531  m_erabsAdmittedList.push_back (erabItem);
532  m_headerLength += 10;
533  }
534 
535  sz = i.ReadNtohU32 ();
536  m_headerLength += 4;
537  m_numberOfIes++;
538 
539  for (int j = 0; j < sz; j++)
540  {
542 
543  erabItem.erabId = i.ReadNtohU16 ();
544  erabItem.cause = i.ReadNtohU16 ();
545 
546  m_erabsNotAdmittedList.push_back (erabItem);
547  m_headerLength += 4;
548  }
549 
550  return GetSerializedSize ();
551 }
552 
553 void
554 EpcX2HandoverRequestAckHeader::Print (std::ostream &os) const
555 {
556  os << "OldEnbUeX2apId=" << m_oldEnbUeX2apId;
557  os << " NewEnbUeX2apId=" << m_newEnbUeX2apId;
558 
559  os << " AdmittedBearers=" << m_erabsAdmittedList.size ();
560  std::vector <EpcX2Sap::ErabAdmittedItem>::size_type sz = m_erabsAdmittedList.size ();
561  if (sz > 0)
562  {
563  os << " [";
564  }
565  for (int j = 0; j < (int) sz; j++)
566  {
567  os << m_erabsAdmittedList[j].erabId;
568  if (j < (int) sz - 1)
569  {
570  os << ", ";
571  }
572  else
573  {
574  os << "]";
575  }
576  }
577 
578  os << " NotAdmittedBearers=" << m_erabsNotAdmittedList.size ();
579  std::vector <EpcX2Sap::ErabNotAdmittedItem>::size_type sz2 = m_erabsNotAdmittedList.size ();
580  if (sz2 > 0)
581  {
582  os << " [";
583  }
584  for (int j = 0; j < (int) sz2; j++)
585  {
586  os << m_erabsNotAdmittedList[j].erabId;
587  if (j < (int) sz2 - 1)
588  {
589  os << ", ";
590  }
591  else
592  {
593  os << "]";
594  }
595  }
596 
597 }
598 
599 uint16_t
601 {
602  return m_oldEnbUeX2apId;
603 }
604 
605 void
607 {
608  m_oldEnbUeX2apId = x2apId;
609 }
610 
611 uint16_t
613 {
614  return m_newEnbUeX2apId;
615 }
616 
617 void
619 {
620  m_newEnbUeX2apId = x2apId;
621 }
622 
623 std::vector <EpcX2Sap::ErabAdmittedItem>
625 {
626  return m_erabsAdmittedList;
627 }
628 
629 void
630 EpcX2HandoverRequestAckHeader::SetAdmittedBearers (std::vector <EpcX2Sap::ErabAdmittedItem> bearers)
631 {
632  m_headerLength += 10 * bearers.size ();
633  m_erabsAdmittedList = bearers;
634 }
635 
636 std::vector <EpcX2Sap::ErabNotAdmittedItem>
638 {
639  return m_erabsNotAdmittedList;
640 }
641 
642 void
643 EpcX2HandoverRequestAckHeader::SetNotAdmittedBearers (std::vector <EpcX2Sap::ErabNotAdmittedItem> bearers)
644 {
645  m_headerLength += 4 * bearers.size ();
646  m_erabsNotAdmittedList = bearers;
647 }
648 
649 uint32_t
651 {
652  return m_headerLength;
653 }
654 
655 uint32_t
657 {
658  return m_numberOfIes;
659 }
660 
662 
664 
666  : m_numberOfIes (1 + 1 + 1),
667  m_headerLength (2 + 2 + 2),
668  m_oldEnbUeX2apId (0xfffa),
669  m_cause (0xfffa),
670  m_criticalityDiagnostics (0xfffa)
671 {
672 }
673 
675 {
676  m_numberOfIes = 0;
677  m_headerLength = 0;
678  m_oldEnbUeX2apId = 0xfffb;
679  m_cause = 0xfffb;
680  m_criticalityDiagnostics = 0xfffb;
681 }
682 
683 TypeId
685 {
686  static TypeId tid = TypeId ("ns3::EpcX2HandoverPreparationFailureHeader")
687  .SetParent<Header> ()
688  .SetGroupName("Lte")
689  .AddConstructor<EpcX2HandoverPreparationFailureHeader> ()
690  ;
691  return tid;
692 }
693 
694 TypeId
696 {
697  return GetTypeId ();
698 }
699 
700 uint32_t
702 {
703  return m_headerLength;
704 }
705 
706 void
708 {
710 
712  i.WriteHtonU16 (m_cause);
714 }
715 
716 uint32_t
718 {
720 
722  m_cause = i.ReadNtohU16 ();
724 
725  m_headerLength = 6;
726  m_numberOfIes = 3;
727 
728  return GetSerializedSize ();
729 }
730 
731 void
733 {
734  os << "OldEnbUeX2apId = " << m_oldEnbUeX2apId;
735  os << " Cause = " << m_cause;
736  os << " CriticalityDiagnostics = " << m_criticalityDiagnostics;
737 }
738 
739 uint16_t
741 {
742  return m_oldEnbUeX2apId;
743 }
744 
745 void
747 {
748  m_oldEnbUeX2apId = x2apId;
749 }
750 
751 uint16_t
753 {
754  return m_cause;
755 }
756 
757 void
759 {
760  m_cause = cause;
761 }
762 
763 uint16_t
765 {
767 }
768 
769 void
771 {
772  m_criticalityDiagnostics = criticalityDiagnostics;
773 }
774 
775 uint32_t
777 {
778  return m_headerLength;
779 }
780 
781 uint32_t
783 {
784  return m_numberOfIes;
785 }
786 
788 
790 
792  : m_numberOfIes (3),
793  m_headerLength (6),
794  m_oldEnbUeX2apId (0xfffa),
795  m_newEnbUeX2apId (0xfffa)
796 {
798 }
799 
801 {
802  m_numberOfIes = 0;
803  m_headerLength = 0;
804  m_oldEnbUeX2apId = 0xfffb;
805  m_newEnbUeX2apId = 0xfffb;
807 }
808 
809 TypeId
811 {
812  static TypeId tid = TypeId ("ns3::EpcX2SnStatusTransferHeader")
813  .SetParent<Header> ()
814  .SetGroupName("Lte")
815  .AddConstructor<EpcX2SnStatusTransferHeader> ()
816  ;
817  return tid;
818 }
819 
820 TypeId
822 {
823  return GetTypeId ();
824 }
825 
826 uint32_t
828 {
829  return m_headerLength;
830 }
831 
832 void
834 {
836 
839 
840  std::vector <EpcX2Sap::ErabsSubjectToStatusTransferItem>::size_type sz = m_erabsSubjectToStatusTransferList.size ();
841  i.WriteHtonU16 (sz); // number of ErabsSubjectToStatusTransferItems
842 
843  for (int j = 0; j < (int) sz; j++)
844  {
846 
847  i.WriteHtonU16 (item.erabId);
848 
849  uint16_t bitsetSize = EpcX2Sap::m_maxPdcpSn / 64;
850  for (int k = 0; k < bitsetSize; k++)
851  {
852  uint64_t statusValue = 0;
853  for (int m = 0; m < 64; m++)
854  {
855  statusValue |= item.receiveStatusOfUlPdcpSdus[64 * k + m] << m;
856  }
857  i.WriteHtonU64 (statusValue);
858  }
859 
860  i.WriteHtonU16 (item.ulPdcpSn);
861  i.WriteHtonU32 (item.ulHfn);
862  i.WriteHtonU16 (item.dlPdcpSn);
863  i.WriteHtonU32 (item.dlHfn);
864  }
865 }
866 
867 uint32_t
869 {
871 
874  int sz = i.ReadNtohU16 ();
875 
876  m_numberOfIes = 3;
877  m_headerLength = 6 + sz * (14 + (EpcX2Sap::m_maxPdcpSn / 64));
878 
879  for (int j = 0; j < sz; j++)
880  {
882  ErabItem.erabId = i.ReadNtohU16 ();
883 
884  uint16_t bitsetSize = EpcX2Sap::m_maxPdcpSn / 64;
885  for (int k = 0; k < bitsetSize; k++)
886  {
887  uint64_t statusValue = i.ReadNtohU64 ();
888  for (int m = 0; m < 64; m++)
889  {
890  ErabItem.receiveStatusOfUlPdcpSdus[64 * k + m] = (statusValue >> m) & 1;
891  }
892  }
893 
894  ErabItem.ulPdcpSn = i.ReadNtohU16 ();
895  ErabItem.ulHfn = i.ReadNtohU32 ();
896  ErabItem.dlPdcpSn = i.ReadNtohU16 ();
897  ErabItem.dlHfn = i.ReadNtohU32 ();
898 
899  m_erabsSubjectToStatusTransferList.push_back (ErabItem);
900  }
901 
902  return GetSerializedSize ();
903 }
904 
905 void
906 EpcX2SnStatusTransferHeader::Print (std::ostream &os) const
907 {
908  os << "OldEnbUeX2apId = " << m_oldEnbUeX2apId;
909  os << " NewEnbUeX2apId = " << m_newEnbUeX2apId;
910  os << " ErabsSubjectToStatusTransferList size = " << m_erabsSubjectToStatusTransferList.size ();
911 
912  std::vector <EpcX2Sap::ErabsSubjectToStatusTransferItem>::size_type sz = m_erabsSubjectToStatusTransferList.size ();
913  if (sz > 0)
914  {
915  os << " [";
916  }
917  for (int j = 0; j < (int) sz; j++)
918  {
919  os << m_erabsSubjectToStatusTransferList[j].erabId;
920  if (j < (int) sz - 1)
921  {
922  os << ", ";
923  }
924  else
925  {
926  os << "]";
927  }
928  }
929 }
930 
931 uint16_t
933 {
934  return m_oldEnbUeX2apId;
935 }
936 
937 void
939 {
940  m_oldEnbUeX2apId = x2apId;
941 }
942 
943 uint16_t
945 {
946  return m_newEnbUeX2apId;
947 }
948 
949 void
951 {
952  m_newEnbUeX2apId = x2apId;
953 }
954 
955 std::vector <EpcX2Sap::ErabsSubjectToStatusTransferItem>
957 {
959 }
960 
961 void
962 EpcX2SnStatusTransferHeader::SetErabsSubjectToStatusTransferList (std::vector <EpcX2Sap::ErabsSubjectToStatusTransferItem> erabs)
963 {
964  m_headerLength += erabs.size () * (14 + (EpcX2Sap::m_maxPdcpSn / 8));
966 }
967 
968 uint32_t
970 {
971  return m_headerLength;
972 }
973 
974 uint32_t
976 {
977  return m_numberOfIes;
978 }
979 
981 
983 
985  : m_numberOfIes (1 + 1),
986  m_headerLength (2 + 2),
987  m_oldEnbUeX2apId (0xfffa),
988  m_newEnbUeX2apId (0xfffa)
989 {
990 }
991 
993 {
994  m_numberOfIes = 0;
995  m_headerLength = 0;
996  m_oldEnbUeX2apId = 0xfffb;
997  m_newEnbUeX2apId = 0xfffb;
998 }
999 
1000 TypeId
1002 {
1003  static TypeId tid = TypeId ("ns3::EpcX2UeContextReleaseHeader")
1004  .SetParent<Header> ()
1005  .SetGroupName("Lte")
1006  .AddConstructor<EpcX2UeContextReleaseHeader> ()
1007  ;
1008  return tid;
1009 }
1010 
1011 TypeId
1013 {
1014  return GetTypeId ();
1015 }
1016 
1017 uint32_t
1019 {
1020  return m_headerLength;
1021 }
1022 
1023 void
1025 {
1026  Buffer::Iterator i = start;
1027 
1030 }
1031 
1032 uint32_t
1034 {
1035  Buffer::Iterator i = start;
1036 
1039  m_numberOfIes = 2;
1040  m_headerLength = 4;
1041 
1042  return GetSerializedSize ();
1043 }
1044 
1045 void
1046 EpcX2UeContextReleaseHeader::Print (std::ostream &os) const
1047 {
1048  os << "OldEnbUeX2apId=" << m_oldEnbUeX2apId;
1049  os << " NewEnbUeX2apId=" << m_newEnbUeX2apId;
1050 }
1051 
1052 uint16_t
1054 {
1055  return m_oldEnbUeX2apId;
1056 }
1057 
1058 void
1060 {
1061  m_oldEnbUeX2apId = x2apId;
1062 }
1063 
1064 uint16_t
1066 {
1067  return m_newEnbUeX2apId;
1068 }
1069 
1070 void
1072 {
1073  m_newEnbUeX2apId = x2apId;
1074 }
1075 
1076 uint32_t
1078 {
1079  return m_headerLength;
1080 }
1081 
1082 uint32_t
1084 {
1085  return m_numberOfIes;
1086 }
1087 
1089 
1091 
1093  : m_numberOfIes (1),
1094  m_headerLength (6)
1095 {
1096  m_cellInformationList.clear ();
1097 }
1098 
1100 {
1101  m_numberOfIes = 0;
1102  m_headerLength = 0;
1103  m_cellInformationList.clear ();
1104 }
1105 
1106 TypeId
1108 {
1109  static TypeId tid = TypeId ("ns3::EpcX2LoadInformationHeader")
1110  .SetParent<Header> ()
1111  .SetGroupName("Lte")
1112  .AddConstructor<EpcX2LoadInformationHeader> ()
1113  ;
1114  return tid;
1115 }
1116 
1117 TypeId
1119 {
1120  return GetTypeId ();
1121 }
1122 
1123 uint32_t
1125 {
1126  return m_headerLength;
1127 }
1128 
1129 void
1131 {
1132  Buffer::Iterator i = start;
1133 
1134  i.WriteHtonU16 (6); // id = CELL_INFORMATION
1135  i.WriteU8 (1 << 6); // criticality = IGNORE
1136  i.WriteU8 (4); // length of CELL_INFORMATION_ID
1137 
1138  std::vector <EpcX2Sap::CellInformationItem>::size_type sz = m_cellInformationList.size ();
1139  i.WriteHtonU16 (sz); // number of cellInformationItems
1140 
1141  for (int j = 0; j < (int) sz; j++)
1142  {
1143  i.WriteHtonU16 (m_cellInformationList [j].sourceCellId);
1144 
1145  std::vector <EpcX2Sap::UlInterferenceOverloadIndicationItem>::size_type sz2;
1146  sz2 = m_cellInformationList [j].ulInterferenceOverloadIndicationList.size ();
1147  i.WriteHtonU16 (sz2); // number of UlInterferenceOverloadIndicationItem
1148 
1149  for (int k = 0; k < (int) sz2; k++)
1150  {
1151  i.WriteU8 (m_cellInformationList [j].ulInterferenceOverloadIndicationList [k]);
1152  }
1153 
1154  std::vector <EpcX2Sap::UlHighInterferenceInformationItem>::size_type sz3;
1155  sz3 = m_cellInformationList [j].ulHighInterferenceInformationList.size ();
1156  i.WriteHtonU16 (sz3); // number of UlHighInterferenceInformationItem
1157 
1158  for (int k = 0; k < (int) sz3; k++)
1159  {
1160  i.WriteHtonU16 (m_cellInformationList [j].ulHighInterferenceInformationList [k].targetCellId);
1161 
1162  std::vector <bool>::size_type sz4;
1163  sz4 = m_cellInformationList [j].ulHighInterferenceInformationList [k].ulHighInterferenceIndicationList.size ();
1164  i.WriteHtonU16 (sz4);
1165 
1166  for (int m = 0; m < (int) sz4; m++)
1167  {
1168  i.WriteU8 (m_cellInformationList [j].ulHighInterferenceInformationList [k].ulHighInterferenceIndicationList [m]);
1169  }
1170  }
1171 
1172  std::vector <bool>::size_type sz5;
1173  sz5 = m_cellInformationList [j].relativeNarrowbandTxBand.rntpPerPrbList.size ();
1174  i.WriteHtonU16 (sz5);
1175 
1176  for (int k = 0; k < (int) sz5; k++)
1177  {
1178  i.WriteU8 (m_cellInformationList [j].relativeNarrowbandTxBand.rntpPerPrbList [k]);
1179  }
1180 
1181  i.WriteHtonU16 (m_cellInformationList [j].relativeNarrowbandTxBand.rntpThreshold);
1182  i.WriteHtonU16 (m_cellInformationList [j].relativeNarrowbandTxBand.antennaPorts);
1183  i.WriteHtonU16 (m_cellInformationList [j].relativeNarrowbandTxBand.pB);
1184  i.WriteHtonU16 (m_cellInformationList [j].relativeNarrowbandTxBand.pdcchInterferenceImpact);
1185  }
1186 }
1187 
1188 uint32_t
1190 {
1191  Buffer::Iterator i = start;
1192 
1193  m_headerLength = 0;
1194  m_numberOfIes = 0;
1195 
1196  i.ReadNtohU16 ();
1197  i.ReadU8 ();
1198  i.ReadU8 ();
1199  int sz = i.ReadNtohU16 ();
1200  m_headerLength += 6;
1201  m_numberOfIes++;
1202 
1203  for (int j = 0; j < sz; j++)
1204  {
1205  EpcX2Sap::CellInformationItem cellInfoItem;
1206  cellInfoItem.sourceCellId = i.ReadNtohU16 ();
1207  m_headerLength += 2;
1208 
1209  int sz2 = i.ReadNtohU16 ();
1210  m_headerLength += 2;
1211  for (int k = 0; k < sz2; k++)
1212  {
1214  cellInfoItem.ulInterferenceOverloadIndicationList.push_back (item);
1215  }
1216  m_headerLength += sz2;
1217 
1218  int sz3 = i.ReadNtohU16 ();
1219  m_headerLength += 2;
1220  for (int k = 0; k < sz3; k++)
1221  {
1223  item.targetCellId = i.ReadNtohU16 ();
1224  m_headerLength += 2;
1225 
1226  int sz4 = i.ReadNtohU16 ();
1227  m_headerLength += 2;
1228  for (int m = 0; m < sz4; m++)
1229  {
1230  item.ulHighInterferenceIndicationList.push_back (i.ReadU8 ());
1231  }
1232  m_headerLength += sz4;
1233 
1234  cellInfoItem.ulHighInterferenceInformationList.push_back (item);
1235  }
1236 
1237  int sz5 = i.ReadNtohU16 ();
1238  m_headerLength += 2;
1239  for (int k = 0; k < sz5; k++)
1240  {
1241  cellInfoItem.relativeNarrowbandTxBand.rntpPerPrbList.push_back (i.ReadU8 ());
1242  }
1243  m_headerLength += sz5;
1244 
1247  cellInfoItem.relativeNarrowbandTxBand.pB = i.ReadNtohU16 ();
1249  m_headerLength += 8;
1250 
1251  m_cellInformationList.push_back (cellInfoItem);
1252  }
1253 
1254  return GetSerializedSize ();
1255 }
1256 
1257 void
1258 EpcX2LoadInformationHeader::Print (std::ostream &os) const
1259 {
1260  os << "NumOfCellInformationItems=" << m_cellInformationList.size ();
1261 }
1262 
1263 std::vector <EpcX2Sap::CellInformationItem>
1265 {
1266  return m_cellInformationList;
1267 }
1268 
1269 void
1270 EpcX2LoadInformationHeader::SetCellInformationList (std::vector <EpcX2Sap::CellInformationItem> cellInformationList)
1271 {
1272  m_cellInformationList = cellInformationList;
1273  m_headerLength += 2;
1274 
1275  std::vector <EpcX2Sap::CellInformationItem>::size_type sz = m_cellInformationList.size ();
1276  for (int j = 0; j < (int) sz; j++)
1277  {
1278  m_headerLength += 2;
1279 
1280  std::vector <EpcX2Sap::UlInterferenceOverloadIndicationItem>::size_type sz2;
1281  sz2 = m_cellInformationList [j].ulInterferenceOverloadIndicationList.size ();
1282  m_headerLength += 2 + sz2;
1283 
1284  std::vector <EpcX2Sap::UlHighInterferenceInformationItem>::size_type sz3;
1285  sz3 = m_cellInformationList [j].ulHighInterferenceInformationList.size ();
1286  m_headerLength += 2;
1287 
1288  for (int k = 0; k < (int) sz3; k++)
1289  {
1290  std::vector <bool>::size_type sz4;
1291  sz4 = m_cellInformationList [j].ulHighInterferenceInformationList [k].ulHighInterferenceIndicationList.size ();
1292  m_headerLength += 2 + 2 + sz4;
1293  }
1294 
1295  std::vector <bool>::size_type sz5;
1296  sz5 = m_cellInformationList [j].relativeNarrowbandTxBand.rntpPerPrbList.size ();
1297  m_headerLength += 2 + sz5 + 8;
1298  }
1299 }
1300 
1301 uint32_t
1303 {
1304  return m_headerLength;
1305 }
1306 
1307 uint32_t
1309 {
1310  return m_numberOfIes;
1311 }
1312 
1314 
1316 
1318  : m_numberOfIes (3),
1319  m_headerLength (6),
1320  m_enb1MeasurementId (0xfffa),
1321  m_enb2MeasurementId (0xfffa)
1322 {
1323  m_cellMeasurementResultList.clear ();
1324 }
1325 
1327 {
1328  m_numberOfIes = 0;
1329  m_headerLength = 0;
1330  m_enb1MeasurementId = 0xfffb;
1331  m_enb2MeasurementId = 0xfffb;
1332  m_cellMeasurementResultList.clear ();
1333 }
1334 
1335 TypeId
1337 {
1338  static TypeId tid = TypeId ("ns3::EpcX2ResourceStatusUpdateHeader")
1339  .SetParent<Header> ()
1340  .SetGroupName("Lte")
1341  .AddConstructor<EpcX2ResourceStatusUpdateHeader> ()
1342  ;
1343  return tid;
1344 }
1345 
1346 TypeId
1348 {
1349  return GetTypeId ();
1350 }
1351 
1352 uint32_t
1354 {
1355  return m_headerLength;
1356 }
1357 
1358 void
1360 {
1361  Buffer::Iterator i = start;
1362 
1365 
1366  std::vector <EpcX2Sap::CellMeasurementResultItem>::size_type sz = m_cellMeasurementResultList.size ();
1367  i.WriteHtonU16 (sz); // number of CellMeasurementResultItem
1368 
1369  for (int j = 0; j < (int) sz; j++)
1370  {
1372 
1373  i.WriteHtonU16 (item.sourceCellId);
1376  i.WriteU8 (item.dlS1TnlLoadIndicator);
1377  i.WriteU8 (item.ulS1TnlLoadIndicator);
1378 
1379  i.WriteHtonU16 (item.dlGbrPrbUsage);
1380  i.WriteHtonU16 (item.ulGbrPrbUsage);
1381  i.WriteHtonU16 (item.dlNonGbrPrbUsage);
1382  i.WriteHtonU16 (item.ulNonGbrPrbUsage);
1383  i.WriteHtonU16 (item.dlTotalPrbUsage);
1384  i.WriteHtonU16 (item.ulTotalPrbUsage);
1385 
1390  }
1391 }
1392 
1393 uint32_t
1395 {
1396  Buffer::Iterator i = start;
1397 
1400 
1401  int sz = i.ReadNtohU16 ();
1402  for (int j = 0; j < sz; j++)
1403  {
1405 
1406  item.sourceCellId = i.ReadNtohU16 ();
1411 
1412  item.dlGbrPrbUsage = i.ReadNtohU16 ();
1413  item.ulGbrPrbUsage = i.ReadNtohU16 ();
1414  item.dlNonGbrPrbUsage = i.ReadNtohU16 ();
1415  item.ulNonGbrPrbUsage = i.ReadNtohU16 ();
1416  item.dlTotalPrbUsage = i.ReadNtohU16 ();
1417  item.ulTotalPrbUsage = i.ReadNtohU16 ();
1418 
1423 
1424  m_cellMeasurementResultList.push_back (item);
1425  }
1426 
1427  m_headerLength = 6 + sz * 26;
1428  m_numberOfIes = 3;
1429 
1430  return GetSerializedSize ();
1431 }
1432 
1433 void
1435 {
1436  os << "Enb1MeasurementId = " << m_enb1MeasurementId
1437  << " Enb2MeasurementId = " << m_enb2MeasurementId
1438  << " NumOfCellMeasurementResultItems = " << m_cellMeasurementResultList.size ();
1439 }
1440 
1441 uint16_t
1443 {
1444  return m_enb1MeasurementId;
1445 }
1446 
1447 void
1449 {
1450  m_enb1MeasurementId = enb1MeasurementId;
1451 }
1452 
1453 uint16_t
1455 {
1456  return m_enb2MeasurementId;
1457 }
1458 
1459 void
1461 {
1462  m_enb2MeasurementId = enb2MeasurementId;
1463 }
1464 
1465 std::vector <EpcX2Sap::CellMeasurementResultItem>
1467 {
1469 }
1470 
1471 void
1472 EpcX2ResourceStatusUpdateHeader::SetCellMeasurementResultList (std::vector <EpcX2Sap::CellMeasurementResultItem> cellMeasurementResultList)
1473 {
1474  m_cellMeasurementResultList = cellMeasurementResultList;
1475 
1476  std::vector <EpcX2Sap::CellMeasurementResultItem>::size_type sz = m_cellMeasurementResultList.size ();
1477  m_headerLength += sz * 26;
1478 }
1479 
1480 uint32_t
1482 {
1483  return m_headerLength;
1484 }
1485 
1486 uint32_t
1488 {
1489  return m_numberOfIes;
1490 }
1491 
1492 } // namespace ns3
virtual uint32_t Deserialize(Buffer::Iterator start)
uint32_t m_mmeUeS1apId
MME UE S1 AP ID.
Protocol header serialization and deserialization.
Definition: header.h:42
uint16_t ulGbrPrbUsage
UL GBR PRB usage.
Definition: epc-x2-sap.h:204
void SetNumberOfIes(uint32_t numberOfIes)
Set number of IEs function.
virtual void Print(std::ostream &os) const
RelativeNarrowbandTxBand relativeNarrowbandTxBand
relative narrow transmit band
Definition: epc-x2-sap.h:161
uint32_t GetNumberOfIes() const
Get number of IEs.
virtual void Print(std::ostream &os) const
uint16_t sourceCellId
source cell id
Definition: epc-x2-sap.h:195
EpcX2SnStatusTransferHeader.
uint32_t GetLengthOfIes() const
Get length of IEs function.
void WriteHtonU64(uint64_t data)
Definition: buffer.cc:940
static TypeId GetTypeId(void)
Get the type ID.
E-RABs admitted item as it is used in the HANDOVER REQUEST ACKNOWLEDGE message.
Definition: epc-x2-sap.h:75
uint16_t dlGbrPrbUsage
DL GBR PRB usage.
Definition: epc-x2-sap.h:203
virtual uint32_t GetSerializedSize(void) const
ErabsSubjectToStatusTransferItem structure.
Definition: epc-x2-sap.h:101
virtual void Print(std::ostream &os) const
void SetNewEnbUeX2apId(uint16_t x2apId)
Set new ENB UE X2 AP ID function.
std::vector< EpcX2Sap::ErabsSubjectToStatusTransferItem > GetErabsSubjectToStatusTransferList() const
Get ERABs subject to status transfer list function.
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:45
void SetOldEnbUeX2apId(uint16_t x2apId)
Set old ENB UE X2 AP ID function.
uint16_t m_targetCellId
target cell ID
uint16_t m_oldEnbUeX2apId
old ENB UE X2 AP ID
uint16_t erabId
E-RAB ID.
Definition: epc-x2-sap.h:77
uint8_t m_procedureCode
procedure code
virtual ~EpcX2Header()
uint16_t erabId
E-RAB ID.
Definition: epc-x2-sap.h:61
Introspection did not find any typical Config paths.
Definition: epc-x2-header.h:33
virtual TypeId GetInstanceTypeId(void) const
Get the most derived TypeId for this Object.
def start()
Definition: core.py:1855
std::vector< EpcX2Sap::CellInformationItem > m_cellInformationList
cell information list
void SetCause(uint16_t cause)
Set cause function.
uint32_t m_numberOfIes
number of IEs
uint32_t m_numberOfIes
number of IEs
static TypeId GetTypeId(void)
Get the type ID.
uint32_t GetNumberOfIes() const
Get number of IEs function.
uint64_t ReadNtohU64(void)
Definition: buffer.cc:1043
uint16_t GetNewEnbUeX2apId() const
Get new ENB UE X2 AP ID function.
uint16_t cellCapacityClassValue
cell capacity class value
Definition: epc-x2-sap.h:184
uint8_t GetMessageType() const
Get message type function.
virtual uint32_t GetSerializedSize(void) const
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
uint32_t m_headerLength
header length
uint16_t GetCriticalityDiagnostics() const
Get criticality diagnostics function.
std::vector< UlInterferenceOverloadIndicationItem > ulInterferenceOverloadIndicationList
UL interference overload indication list.
Definition: epc-x2-sap.h:159
uint16_t m_oldEnbUeX2apId
old ENB UE X1 AP ID
virtual uint32_t Deserialize(Buffer::Iterator start)
uint64_t GetUeAggregateMaxBitRateUplink() const
Get UE Aggregrate Max Bit Rate Uplik function.
virtual TypeId GetInstanceTypeId(void) const
Get the most derived TypeId for this Object.
uint16_t m_newEnbUeX2apId
new ENB UE X2 AP ID
Ipv4Address transportLayerAddress
transport layer address
Definition: epc-x2-sap.h:64
LoadIndicator dlHardwareLoadIndicator
DL hardware load indicator.
Definition: epc-x2-sap.h:197
void SetLengthOfIes(uint32_t lengthOfIes)
Set length of IEs function.
uint16_t GetEnb1MeasurementId() const
Get ENB1 measurement ID function.
uint32_t m_numberOfIes
number of IEs
std::vector< EpcX2Sap::ErabToBeSetupItem > GetBearers() const
Get bearers function.
static TypeId GetTypeId(void)
Get the type ID.
uint32_t ReadNtohU32(void)
Definition: buffer.h:970
uint16_t pdcchInterferenceImpact
PDC channel interference list.
Definition: epc-x2-sap.h:148
CompositeAvailCapacity dlCompositeAvailableCapacity
DL composite available capacity.
Definition: epc-x2-sap.h:210
uint32_t GetLengthOfIes() const
Get length of IEs function.
EpcX2HandoverRequestAckHeader.
uint16_t GetOldEnbUeX2apId() const
Get old ENB UE X2 AP ID function.
iterator in a Buffer instance
Definition: buffer.h:98
uint32_t GetLengthOfIes() const
Get length of IEs function.
LoadIndicator ulS1TnlLoadIndicator
UL S1 TNL load indicator.
Definition: epc-x2-sap.h:201
std::vector< EpcX2Sap::CellMeasurementResultItem > m_cellMeasurementResultList
cell measurement result list
uint64_t gbrUl
Guaranteed Bit Rate (bit/s) in uplink.
Definition: eps-bearer.h:43
uint32_t GetLengthOfIes() const
Get length of IEs function.
uint32_t m_numberOfIes
number of IEs
uint16_t m_enb1MeasurementId
ENB1 measurement.
EpcX2HandoverRequestHeader.
virtual void Serialize(Buffer::Iterator start) const
uint16_t m_enb2MeasurementId
ENB2 measurement.
uint16_t m_newEnbUeX2apId
new ENB UE X2 AP ID
void SetTargetCellId(uint16_t targetCellId)
Set target cell id function.
virtual TypeId GetInstanceTypeId(void) const
Get the most derived TypeId for this Object.
uint16_t ulTotalPrbUsage
UL Total PRB usage.
Definition: epc-x2-sap.h:208
uint32_t GetNumberOfIes() const
Get number of IEs function.
UlInterferenceOverloadIndicationItem
UL Interference OverloadIndication as it is used in the LOAD INFORMATION message. ...
Definition: epc-x2-sap.h:116
uint16_t m_oldEnbUeX2apId
old ENB UE X2 AP ID
static TypeId GetTypeId(void)
Get the type ID.
void SetUeAggregateMaxBitRateUplink(uint64_t bitRate)
Set UE Aggregrate Max Bit Rate Uplik function.
LoadIndicator ulHardwareLoadIndicator
UL hardware load indicator.
Definition: epc-x2-sap.h:198
uint32_t dlGtpTeid
downlink GTP TEID
Definition: epc-x2-sap.h:79
static const uint16_t m_maxPdcpSn
E-RABs subject to status transfer item as it is used in the SN STATUS TRANSFER message.
Definition: epc-x2-sap.h:98
void SetOldEnbUeX2apId(uint16_t x2apId)
Set old ENB UE X2 AP ID function.
void WriteHtonU16(uint16_t data)
Definition: buffer.h:905
uint16_t m_newEnbUeX2apId
new ENB UE X2 AP ID
virtual void Print(std::ostream &os) const
uint16_t m_oldEnbUeX2apId
old ENB UE X2 AP ID
void SetOldEnbUeX2apId(uint16_t x2apId)
Set old ENB UE X2 AP ID function.
static TypeId GetTypeId(void)
Get the type ID.
virtual uint32_t GetSerializedSize(void) const
void SetEnb1MeasurementId(uint16_t enb1MeasurementId)
Set ENB1 measurement ID function.
EpcX2ResourceStatusUpdateHeader.
EpcX2HandoverPreparationFailureHeader.
uint64_t gbrDl
Guaranteed Bit Rate (bit/s) in downlink.
Definition: eps-bearer.h:42
virtual void Serialize(Buffer::Iterator start) const
void SetUeAggregateMaxBitRateDownlink(uint64_t bitRate)
Set UE Aggregrate Max Bit Rate Downlink function.
std::vector< UlHighInterferenceInformationItem > ulHighInterferenceInformationList
UL high interference information list.
Definition: epc-x2-sap.h:160
bool preemptionVulnerability
true if bearer can be preempted by others
Definition: eps-bearer.h:61
virtual uint32_t GetSerializedSize(void) const
std::vector< EpcX2Sap::CellMeasurementResultItem > GetCellMeasurementResultList() const
Get cell measurement results list function.
uint32_t m_lengthOfIes
length of IEs
std::bitset< m_maxPdcpSn > receiveStatusOfUlPdcpSdus
receive status of UL PDCP SDUs
Definition: epc-x2-sap.h:104
E-RABs to be setup item as it is used in the HANDOVER REQUEST message.
Definition: epc-x2-sap.h:59
Every class exported by the ns3 library is enclosed in the ns3 namespace.
uint16_t dlTotalPrbUsage
DL Total PRB usage.
Definition: epc-x2-sap.h:207
virtual void Serialize(Buffer::Iterator start) const
virtual uint32_t Deserialize(Buffer::Iterator start)
void SetNotAdmittedBearers(std::vector< EpcX2Sap::ErabNotAdmittedItem > bearers)
Set not admitted bearers function.
uint32_t m_headerLength
header length
uint64_t mbrUl
Maximum Bit Rate (bit/s) in uplink.
Definition: eps-bearer.h:45
EpsBearer erabLevelQosParameters
E-RAB level QOS parameters.
Definition: epc-x2-sap.h:62
E-RABs not admitted item as it is used in the HANDOVER REQUEST ACKNOWLEDGE message.
Definition: epc-x2-sap.h:87
std::vector< EpcX2Sap::ErabNotAdmittedItem > GetNotAdmittedBearers() const
Get not admitted bearers function.
uint32_t GetNumberOfIes() const
Get number of IEs function.
std::vector< bool > ulHighInterferenceIndicationList
UL high interference indication list.
Definition: epc-x2-sap.h:131
void SetProcedureCode(uint8_t procedureCode)
Set procedure code function.
uint32_t GetLengthOfIes() const
Get length of IEs function.
uint8_t m_messageType
message type
virtual void Serialize(Buffer::Iterator start) const
void SetNewEnbUeX2apId(uint16_t x2apId)
Set new ENB UE X2 AP ID function.
This class contains the specification of EPS Bearers.
Definition: eps-bearer.h:91
uint32_t GetMmeUeS1apId() const
Get MME UE S1 AP ID function.
uint32_t GetNumberOfIes() const
Get number of IEs function.
uint16_t m_criticalityDiagnostics
criticality diagnostics
void WriteHtonU32(uint32_t data)
Definition: buffer.h:924
uint32_t ulGtpTeid
uplink GTP TEID
Definition: epc-x2-sap.h:78
virtual void Serialize(Buffer::Iterator start) const
uint32_t GetNumberOfIes() const
Get number of IEs function.
virtual void Serialize(Buffer::Iterator start) const
bool preemptionCapability
true if bearer can preempt others
Definition: eps-bearer.h:60
std::vector< bool > rntpPerPrbList
RNTP per prb list.
Definition: epc-x2-sap.h:144
LoadIndicator dlS1TnlLoadIndicator
DL S1 TNL load indicator.
Definition: epc-x2-sap.h:200
uint64_t m_ueAggregateMaxBitRateUplink
aggregate max bit rate uplink
uint32_t GetLengthOfIes() const
Get length of IEs function.
virtual void Serialize(Buffer::Iterator start) const
uint16_t capacityValue
capacity value
Definition: epc-x2-sap.h:185
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:41
uint32_t m_headerLength
length of IEs
virtual TypeId GetInstanceTypeId(void) const
Get the most derived TypeId for this Object.
static TypeId GetTypeId(void)
Get the type ID.
uint16_t GetCause() const
Get cause function.
uint16_t dlNonGbrPrbUsage
DL Non GBR PRB usage.
Definition: epc-x2-sap.h:205
void WriteU8(uint8_t data)
Definition: buffer.h:869
void SetErabsSubjectToStatusTransferList(std::vector< EpcX2Sap::ErabsSubjectToStatusTransferItem > erabs)
Set ERABs subject to status transfer list function.
GbrQosInformation gbrQosInfo
GBR QOS information.
Definition: eps-bearer.h:131
uint16_t GetOldEnbUeX2apId() const
Get old ENB X2 AP ID function.
virtual void Print(std::ostream &os) const
int16_t rntpThreshold
RNTP threshold.
Definition: epc-x2-sap.h:145
LoadIndicator
Load Indicator as it is used in the RESOURCE STATUS UPDATE message.
Definition: epc-x2-sap.h:169
std::vector< EpcX2Sap::ErabNotAdmittedItem > m_erabsNotAdmittedList
ERABs not admitted list.
static TypeId GetTypeId(void)
Get the type ID.
uint16_t GetOldEnbUeX2apId() const
Get old ENB UE X2 AP ID function.
uint16_t GetTargetCellId() const
Get target cell id function.
uint32_t m_numberOfIes
number of IEs
virtual void Print(std::ostream &os) const
virtual uint32_t Deserialize(Buffer::Iterator start)
Cell Measurement Result Item as it is used in the RESOURCE STATUS UPDATE message. ...
Definition: epc-x2-sap.h:193
std::vector< EpcX2Sap::ErabAdmittedItem > GetAdmittedBearers() const
Get admittied bearers function.
EpcX2LoadInformationHeader.
uint16_t GetNewEnbUeX2apId() const
Get new ENB UE X2 AP ID function.
uint8_t GetProcedureCode() const
Get procedure code function.
void SetNewEnbUeX2apId(uint16_t x2apId)
Set new ENB UE X2 AP ID function.
uint32_t m_numberOfIes
number of IEs
std::vector< EpcX2Sap::ErabAdmittedItem > m_erabsAdmittedList
ERABs admitted list.
uint32_t m_headerLength
header length
uint8_t ReadU8(void)
Definition: buffer.h:1021
void SetEnb2MeasurementId(uint16_t enb2MeasurementId)
Set ENB2 measurement ID function.
Cell Information Item as it is used in the LOAD INFORMATION message.
Definition: epc-x2-sap.h:156
void SetCellInformationList(std::vector< EpcX2Sap::CellInformationItem > cellInformationList)
Set cell information list function.
void SetAdmittedBearers(std::vector< EpcX2Sap::ErabAdmittedItem > bearers)
Set admitted bearers function.
uint16_t GetCause() const
Get cause function.
void SetBearers(std::vector< EpcX2Sap::ErabToBeSetupItem > bearers)
Set bearers function.
Qci
QoS Class Indicator.
Definition: eps-bearer.h:106
uint16_t GetEnb2MeasurementId() const
Get ENB2 measurement ID function.
uint16_t sourceCellId
source cell ID
Definition: epc-x2-sap.h:158
void SetOldEnbUeX2apId(uint16_t x2apId)
Set old ENB UE X2 AP ID function.
virtual void Print(std::ostream &os) const
virtual uint32_t Deserialize(Buffer::Iterator start)
uint32_t GetLengthOfIes() const
Get length of IEs.
uint64_t GetUeAggregateMaxBitRateDownlink() const
Get UE Aggregate Max Bit Rate Downlink function.
bool dlForwarding
DL forwarding.
Definition: epc-x2-sap.h:63
EpcX2UeContextReleaseHeader.
uint64_t mbrDl
Maximum Bit Rate (bit/s) in downlink.
Definition: eps-bearer.h:44
std::vector< EpcX2Sap::CellInformationItem > GetCellInformationList() const
Get cell information list function.
void SetOldEnbUeX2apId(uint16_t x2apId)
Set old ENB X2 AP ID function.
uint16_t ReadNtohU16(void)
Definition: buffer.h:946
std::vector< EpcX2Sap::ErabToBeSetupItem > m_erabsToBeSetupList
ERAB to be setup list.
virtual TypeId GetInstanceTypeId(void) const
Get the most derived TypeId for this Object.
void SetCause(uint16_t cause)
Set cause function.
virtual void Print(std::ostream &os) const
uint16_t GetOldEnbUeX2apId() const
Get old ENB UE X2 AP ID function.
virtual TypeId GetInstanceTypeId(void) const
Get the most derived TypeId for this Object.
AllocationRetentionPriority arp
allocation retention priority
Definition: eps-bearer.h:132
uint8_t priorityLevel
1-15; 1 = highest
Definition: eps-bearer.h:59
uint64_t m_ueAggregateMaxBitRateDownlink
aggregate max bit rate downlink
uint32_t m_numberOfIes
number of IEs
uint32_t GetNumberOfIes() const
Set length of IEs function.
virtual uint32_t GetSerializedSize(void) const
UL High Interference Information as it is used in the LOAD INFORMATION message.
Definition: epc-x2-sap.h:128
a unique identifier for an interface.
Definition: type-id.h:58
virtual TypeId GetInstanceTypeId(void) const
Get the most derived TypeId for this Object.
void SetCriticalityDiagnostics(uint16_t criticalityDiagnostics)
Set criticality diagnostics function.
uint16_t ulNonGbrPrbUsage
UL Non GBR PRB usage.
Definition: epc-x2-sap.h:206
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:922
virtual uint32_t GetSerializedSize(void) const
virtual uint32_t Deserialize(Buffer::Iterator start)
static TypeId GetTypeId(void)
Get the type ID.
std::vector< EpcX2Sap::ErabsSubjectToStatusTransferItem > m_erabsSubjectToStatusTransferList
ERABs subject to status transfer list.
virtual uint32_t GetSerializedSize(void) const
virtual void Serialize(Buffer::Iterator start) const
uint16_t m_oldEnbUeX2apId
old ENB UE X2 AP ID
void SetCellMeasurementResultList(std::vector< EpcX2Sap::CellMeasurementResultItem > cellMeasurementResultList)
Set cell measurement results list function.
uint32_t m_headerLength
header length
virtual uint32_t Deserialize(Buffer::Iterator start)
void SetMessageType(uint8_t messageType)
Set message type function.
uint32_t m_headerLength
header length
virtual uint32_t Deserialize(Buffer::Iterator start)
uint16_t GetNewEnbUeX2apId() const
Get new ENB UE X2 AP ID function.
CompositeAvailCapacity ulCompositeAvailableCapacity
UL composite available capacity.
Definition: epc-x2-sap.h:211
virtual TypeId GetInstanceTypeId(void) const
Get the most derived TypeId for this Object.
void SetMmeUeS1apId(uint32_t mmeUeS1apId)
Set MME UE S1 AP ID function.
uint16_t GetOldEnbUeX2apId() const
Get old ENB UE X2 AP ID function.
virtual uint32_t GetSerializedSize(void) const
uint16_t antennaPorts
antenna ports
Definition: epc-x2-sap.h:146