dae9ca893306b53cd56922df67e740d3743dc2c3
[sim/e2-interface.git] / e2sim / previous / e2apv1sim / src / ASN1 / lib / asn_x2ap.cpp
1 /*****************************************************************************
2 #                                                                            *
3 # Copyright 2019 AT&T Intellectual Property                                  *
4 # Copyright 2019 Nokia                                                       *
5 #                                                                            *
6 # Licensed under the Apache License, Version 2.0 (the "License");            *
7 # you may not use this file except in compliance with the License.           *
8 # You may obtain a copy of the License at                                    *
9 #                                                                            *
10 #      http://www.apache.org/licenses/LICENSE-2.0                            *
11 #                                                                            *
12 # Unless required by applicable law or agreed to in writing, software        *
13 # distributed under the License is distributed on an "AS IS" BASIS,          *
14 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   *
15 # See the License for the specific language governing permissions and        *
16 # limitations under the License.                                             *
17 #                                                                            *
18 ******************************************************************************/
19
20 #include "asn_x2ap.hpp"
21 #include "asn_x2ap_wrapper.hpp"
22
23 /*-----------------------------------------------------------------------
24                               COMMON ROUTINES
25 -------------------------------------------------------------------------
26 */
27 x2ap_pdu_t* new_x2ap_pdu(void)
28 {
29     X2APpduWrapper* pduWrapper = new X2APpduWrapper();
30     return reinterpret_cast<x2ap_pdu_t*>(pduWrapper);
31 }
32
33 void x2ap_asn_print(x2ap_pdu_t* pdu, char* buf, size_t buf_size)
34 {
35   X2APpduWrapper* pduWrapper = reinterpret_cast<X2APpduWrapper*>(pdu);
36
37   buf[0] = 0;
38
39   strncat(buf, asn::get_printed(pduWrapper->ref_pdu()).c_str(), buf_size - 1);
40 }
41
42 int x2ap_asn_per_encode(x2ap_pdu_t* pdu, unsigned char* buf, size_t buf_size,
43                                           char* err_buf, size_t err_buf_size)
44 {
45   X2APpduWrapper* pduWrapper = reinterpret_cast<X2APpduWrapper*>(pdu);
46
47   asn::per::EncoderCtx ctx{ buf, buf_size };
48
49   if (!asn::per::pack(pduWrapper->ref_pdu(), ctx)) {
50       err_buf[0] = 0;
51       // strncat(err_buf, ctx.refErrorCtx().toString().c_str(), err_buf_size - 1);
52       return -1;
53   } else {
54     return static_cast<int>(ctx.refBuffer().getBytesUsed());
55   }
56
57 }
58
59 int x2ap_asn_per_decode(x2ap_pdu_t* pdu, unsigned char const* buf, size_t buf_size,
60                                           char* err_buf, size_t err_buf_size)
61 {
62   X2APpduWrapper* pduWrapper = reinterpret_cast<X2APpduWrapper*>(pdu);
63
64   asn::per::DecoderCtx ctx{ buf,
65                             buf_size,
66                             pduWrapper->m_allocation_buffer,
67                             pduWrapper->m_allocation_buffer_size };
68
69   if (!asn::per::unpack(pduWrapper->ref_pdu(), ctx)) {
70       err_buf[0] = 0;
71       // strncat(err_buf, ctx.refErrorCtx().toString().c_str(), err_buf_size - 1);
72       return -1;
73   }
74
75   return 0;
76
77 }
78
79 int x2ap_get_index(x2ap_pdu_t* pdu)
80 {
81   X2APpduWrapper* pduWrapper = reinterpret_cast<X2APpduWrapper*>(pdu);
82
83   return pduWrapper->ref_pdu().get_index();
84 }
85
86 int x2ap_get_procedureCode(x2ap_pdu_t* pdu)
87 {
88   X2APpduWrapper* pduWrapper = reinterpret_cast<X2APpduWrapper*>(pdu);
89
90   switch(pduWrapper->ref_pdu().get_index())
91   {
92     case 1:
93       return pduWrapper->ref_pdu().get_initiatingMessage()->ref_procedureCode().get();
94       break;
95
96     case 2:
97       return pduWrapper->ref_pdu().get_successfulOutcome()->ref_procedureCode().get();
98       break;
99
100     case 3:
101       return pduWrapper->ref_pdu().get_unsuccessfulOutcome()->ref_procedureCode().get();
102       break;
103
104     default:
105       return -1;
106   }
107
108 }
109
110 /*-----------------------------------------------------------------------
111                               MESSAGE GENERATORS
112 -------------------------------------------------------------------------
113 */
114 //X2Setup
115 bool x2ap_init_X2SetupRequest(x2ap_pdu_t* pdu)
116 {
117     X2APpduWrapper* pduWrapper = reinterpret_cast<X2APpduWrapper*>(pdu);
118
119     //Initialization
120     pduWrapper->ref_pdu().select_initiatingMessage();
121     pduWrapper->ref_pdu().select_initiatingMessage().clear();
122     pduWrapper->ref_pdu().select_initiatingMessage().ref_procedureCode().select_id_x2Setup();
123     pduWrapper->ref_pdu().select_initiatingMessage().ref_criticality().select_id_x2Setup();
124     pduWrapper->ref_pdu().select_initiatingMessage().ref_value().select_id_x2Setup();
125
126     return true;
127 }
128
129 bool x2ap_create_X2SetupRequest(x2ap_pdu_t* pdu, eNB_config &cfg)
130 {
131   X2APpduWrapper* pduWrapper = reinterpret_cast<X2APpduWrapper*>(pdu);
132
133   /* Initiaization */
134   pduWrapper->ref_pdu().select_initiatingMessage().ref_procedureCode().select_id_x2Setup();
135   pduWrapper->ref_pdu().select_initiatingMessage().ref_criticality().select_id_x2Setup();
136
137   X2SetupRequest* container =
138     &(pduWrapper->ref_pdu().select_initiatingMessage().ref_value().select_id_x2Setup());
139
140   using IE_value_t = X2SetupRequest::protocolIEs_t::value_type;
141
142   /* X2SetupRequest-IEs : GlobalENB-ID*/
143   IE_value_t* val_GlobalENB_ID = new IE_value_t;
144   container->ref_protocolIEs().push_back(*val_GlobalENB_ID);
145
146   val_GlobalENB_ID->ref_id().select_id_GlobalENB_ID();
147   val_GlobalENB_ID->ref_criticality().select_id_GlobalENB_ID();
148   val_GlobalENB_ID->ref_value().select_id_GlobalENB_ID().ref_pLMN_Identity()
149                                          .set(3, cfg.pLMN_Identity);
150
151   val_GlobalENB_ID->ref_value().select_id_GlobalENB_ID().ref_eNB_ID()
152                   .select_macro_eNB_ID().set_buffer(20, cfg.macro_eNB_ID);
153
154   /* X2SetupRequest-IEs : ServedCells*/
155   IE_value_t* val_ServedCells = new IE_value_t;
156   container->ref_protocolIEs().push_back(*val_ServedCells);
157
158   val_ServedCells->ref_id().select_id_ServedCells();
159   val_ServedCells->ref_criticality().select_id_ServedCells();
160   val_ServedCells->ref_value().select_id_ServedCells();
161
162   //Add servedCellInfo
163   ServedCells::value_type* elm = new ServedCells::value_type();
164   ServedCell_Information* info = &(elm->ref_servedCellInfo());
165   {
166     //Set ServedCell-Information: pCI, cellId, tAC, broadcastPLMNs, eUTRA-Mode-Info
167     info->ref_pCI().set(cfg.pCI);
168     info->ref_cellId().ref_pLMN_Identity().set(3, cfg.pLMN_Identity);
169     info->ref_cellId().ref_eUTRANcellIdentifier().set_buffer(28, cfg.eUTRANcellIdentifier);
170     info->ref_tAC().set(2, cfg.tAC);
171
172     BroadcastPLMNs_Item::value_type* item = new BroadcastPLMNs_Item::value_type();
173     item->set(3, cfg.pLMN_Identity);
174     info->ref_broadcastPLMNs().push_back(*item);
175
176     info->ref_eUTRA_Mode_Info().select_fDD().ref_uL_EARFCN().set(cfg.uL_EARFCN);
177     info->ref_eUTRA_Mode_Info().select_fDD().ref_dL_EARFCN().set(cfg.dL_EARFCN);
178     info->ref_eUTRA_Mode_Info().select_fDD().ref_uL_Transmission_Bandwidth()
179           .set(static_cast<Transmission_Bandwidth::index_t>(cfg.uL_Bandwidth));
180     info->ref_eUTRA_Mode_Info().select_fDD().ref_dL_Transmission_Bandwidth()
181           .set(static_cast<Transmission_Bandwidth::index_t>(cfg.dL_Bandwidth));
182   }
183   val_ServedCells->ref_value().select_id_ServedCells().push_back(*elm);
184
185   return true;
186 }
187
188 bool x2ap_create_X2SetupResponse(x2ap_pdu_t* pdu, eNB_config &cfg)
189 {
190   X2APpduWrapper* pduWrapper = reinterpret_cast<X2APpduWrapper*>(pdu);
191
192   /* Initiaization */
193   pduWrapper->ref_pdu().select_successfulOutcome().ref_procedureCode().select_id_x2Setup();
194   pduWrapper->ref_pdu().select_successfulOutcome().ref_criticality().select_id_x2Setup();
195
196   X2SetupResponse* container =
197     &(pduWrapper->ref_pdu().select_successfulOutcome().ref_value().select_id_x2Setup());
198
199   using IE_value_t = X2SetupResponse::protocolIEs_t::value_type;
200
201   /* X2SetupResponse-IEs : GlobalENB-ID*/
202   IE_value_t* val_GlobalENB_ID = new IE_value_t;
203   container->ref_protocolIEs().push_back(*val_GlobalENB_ID);
204
205   val_GlobalENB_ID->ref_id().select_id_GlobalENB_ID();
206   val_GlobalENB_ID->ref_criticality().select_id_GlobalENB_ID();
207   val_GlobalENB_ID->ref_value().select_id_GlobalENB_ID().ref_pLMN_Identity()
208                                          .set(3, cfg.pLMN_Identity);
209
210   val_GlobalENB_ID->ref_value().select_id_GlobalENB_ID().ref_eNB_ID()
211                   .select_macro_eNB_ID().set_buffer(20, cfg.macro_eNB_ID);
212
213   /* X2SetupResponse-IEs : ServedCells*/
214   IE_value_t* val_ServedCells = new IE_value_t;
215   container->ref_protocolIEs().push_back(*val_ServedCells);
216
217   val_ServedCells->ref_id().select_id_ServedCells();
218   val_ServedCells->ref_criticality().select_id_ServedCells();
219   val_ServedCells->ref_value().select_id_ServedCells();
220
221   //Add servedCellInfo
222   ServedCells::value_type* elm = new ServedCells::value_type();
223   ServedCell_Information* info = &(elm->ref_servedCellInfo());
224   {
225     //Set ServedCell-Information: pCI, cellId, tAC, broadcastPLMNs, eUTRA-Mode-Info
226     info->ref_pCI().set(cfg.pCI);
227     info->ref_cellId().ref_pLMN_Identity().set(3, cfg.pLMN_Identity);
228     info->ref_cellId().ref_eUTRANcellIdentifier().set_buffer(28, cfg.eUTRANcellIdentifier);
229     info->ref_tAC().set(2, cfg.tAC);
230
231     BroadcastPLMNs_Item::value_type* item = new BroadcastPLMNs_Item::value_type();
232     item->set(3, cfg.pLMN_Identity);
233     info->ref_broadcastPLMNs().push_back(*item);
234
235     info->ref_eUTRA_Mode_Info().select_fDD().ref_uL_EARFCN().set(cfg.uL_EARFCN);
236     info->ref_eUTRA_Mode_Info().select_fDD().ref_dL_EARFCN().set(cfg.dL_EARFCN);
237     info->ref_eUTRA_Mode_Info().select_fDD().ref_uL_Transmission_Bandwidth()
238           .set(static_cast<Transmission_Bandwidth::index_t>(cfg.uL_Bandwidth));
239     info->ref_eUTRA_Mode_Info().select_fDD().ref_dL_Transmission_Bandwidth()
240           .set(static_cast<Transmission_Bandwidth::index_t>(cfg.dL_Bandwidth));
241   }
242   val_ServedCells->ref_value().select_id_ServedCells().push_back(*elm);
243
244   return true;
245 }
246
247 bool x2ap_create_X2SetupFailure(x2ap_pdu_t* pdu)
248 {
249   X2APpduWrapper* pduWrapper = reinterpret_cast<X2APpduWrapper*>(pdu);
250
251   /* Initiaization */
252   pduWrapper->ref_pdu().select_unsuccessfulOutcome().ref_procedureCode().select_id_x2Setup();
253   pduWrapper->ref_pdu().select_unsuccessfulOutcome().ref_criticality().select_id_x2Setup();
254
255   X2SetupFailure* container =
256     &(pduWrapper->ref_pdu().select_unsuccessfulOutcome().ref_value().select_id_x2Setup());
257
258   using IE_value_t = X2SetupFailure::protocolIEs_t::value_type;
259
260   /* X2SetupFailure-IEs << id-Cause */
261   IE_value_t* val_cause = new IE_value_t;
262   container->ref_protocolIEs().push_back(*val_cause);
263
264   val_cause->ref_id().select_id_Cause();
265   val_cause->ref_criticality().select_id_Cause();
266
267   /* Cause << radioNetwork */
268   val_cause->ref_value().select_id_Cause().select_radioNetwork();
269
270   /* CauseRadioNetwork = ho-target-not-allowed (enum = 8)*/
271   val_cause->ref_value().select_id_Cause().select_radioNetwork()
272                         .set(static_cast<CauseRadioNetwork::index_t>(8));
273
274   return true;
275 }
276
277 //ENDCX2Setup
278 bool x2ap_create_ENDCX2SetupRequest(x2ap_pdu_t* pdu, eNB_config &cfg)
279 {
280   X2APpduWrapper* pduWrapper = reinterpret_cast<X2APpduWrapper*>(pdu);
281
282   /* Initiaization */
283   pduWrapper->ref_pdu().select_initiatingMessage().ref_procedureCode().select_id_endcX2Setup();
284   pduWrapper->ref_pdu().select_initiatingMessage().ref_criticality().select_id_endcX2Setup();
285
286   ENDCX2SetupRequest* container =
287     &(pduWrapper->ref_pdu().select_initiatingMessage().ref_value().select_id_endcX2Setup());
288
289   using IE_value_t = ENDCX2SetupRequest::protocolIEs_t::value_type;
290
291   /* ENDCX2SetupRequest-IEs = id-InitiatingNodeType-EndcX2Setup  */
292   IE_value_t* ie = new IE_value_t;
293   container->ref_protocolIEs().push_back(*ie);
294   ie->ref_id().select_id_InitiatingNodeType_EndcX2Setup();
295   ie->ref_criticality().select_id_InitiatingNodeType_EndcX2Setup();
296   ie->ref_value().select_id_InitiatingNodeType_EndcX2Setup();
297
298   /* InitiatingNodeType-EndcX2Setup = init-eNB {ENB-ENDCX2SetupReqIEs} */
299   ie->ref_value().select_id_InitiatingNodeType_EndcX2Setup().select_init_eNB();
300
301   using eNB_val_t = InitiatingNodeType_EndcX2Setup::init_eNB_t::value_type;
302
303   ProtocolIE_Container<ENB_ENDCX2SetupReqIEs>* eNB_node =
304     &(ie->ref_value().select_id_InitiatingNodeType_EndcX2Setup().select_init_eNB());
305
306   /* ENB-ENDCX2SetupReqIEs <-- id-GlobalENB-ID */
307   eNB_val_t* val_GlobalENB_ID = new eNB_val_t;
308   eNB_node->push_back(*val_GlobalENB_ID);
309
310   val_GlobalENB_ID->ref_id().select_id_GlobalENB_ID();
311   val_GlobalENB_ID->ref_criticality().select_id_GlobalENB_ID();
312   val_GlobalENB_ID->ref_value().select_id_GlobalENB_ID()
313                       .ref_pLMN_Identity().set(3, cfg.pLMN_Identity);
314   val_GlobalENB_ID->ref_value().select_id_GlobalENB_ID().ref_eNB_ID()
315                   .select_macro_eNB_ID().set_buffer(20, cfg.macro_eNB_ID);
316
317   /* ENB-ENDCX2SetupReqIEs <-- id-ServedEUTRAcellsENDCX2ManagementList */
318   eNB_val_t* val_EUTRAlist = new eNB_val_t;
319   eNB_node->push_back(*val_EUTRAlist);
320
321   val_EUTRAlist->ref_id().select_id_ServedEUTRAcellsENDCX2ManagementList();
322   val_EUTRAlist->ref_criticality().select_id_ServedEUTRAcellsENDCX2ManagementList();
323   val_EUTRAlist->ref_value().select_id_ServedEUTRAcellsENDCX2ManagementList();
324
325   /* ServedEUTRAcellsENDCX2ManagementList <-- servedEUTRACellInfo */
326   ServedEUTRAcellsENDCX2ManagementList::value_type* elm =
327                         new ServedEUTRAcellsENDCX2ManagementList::value_type();
328   ServedCell_Information* info = &(elm->ref_servedEUTRACellInfo());
329   {
330     //Set ServedCell-Information: pCI, cellId, tAC, broadcastPLMNs, eUTRA-Mode-Info
331     info->ref_pCI().set(cfg.pCI);
332     info->ref_cellId().ref_pLMN_Identity().set(3, cfg.pLMN_Identity);
333     info->ref_cellId().ref_eUTRANcellIdentifier().set_buffer(28, cfg.eUTRANcellIdentifier);
334     info->ref_tAC().set(2, cfg.tAC);
335
336     BroadcastPLMNs_Item::value_type* item = new BroadcastPLMNs_Item::value_type();
337     item->set(3, cfg.pLMN_Identity);
338     info->ref_broadcastPLMNs().push_back(*item);
339
340     info->ref_eUTRA_Mode_Info().select_fDD().ref_uL_EARFCN().set(cfg.uL_EARFCN);
341     info->ref_eUTRA_Mode_Info().select_fDD().ref_dL_EARFCN().set(cfg.dL_EARFCN);
342     info->ref_eUTRA_Mode_Info().select_fDD().ref_uL_Transmission_Bandwidth()
343           .set(static_cast<Transmission_Bandwidth::index_t>(cfg.uL_Bandwidth));
344     info->ref_eUTRA_Mode_Info().select_fDD().ref_dL_Transmission_Bandwidth()
345           .set(static_cast<Transmission_Bandwidth::index_t>(cfg.dL_Bandwidth));
346   }
347   val_EUTRAlist->ref_value().select_id_ServedEUTRAcellsENDCX2ManagementList()
348                                                         .push_back(*elm);
349
350   return true;
351 }
352
353 /*-----------------------------------------------------------------------
354                               TESTS
355 -------------------------------------------------------------------------
356 */
357 void test_X2Setup_codec(void)
358 {
359   x2ap_pdu_t* pdu = new_x2ap_pdu();
360
361   eNB_config cfg;
362   x2ap_create_X2SetupRequest(pdu, cfg);
363
364   char pdu_str[1024];
365   x2ap_asn_print(pdu, pdu_str, sizeof(pdu_str));
366   printf("%s\n", pdu_str);
367
368   //Test encode
369   unsigned char packed_buf[4096];
370   char          err_buf[1024];
371
372   int packed_len = x2ap_asn_per_encode(pdu, packed_buf, sizeof(packed_buf),
373                                             err_buf, sizeof(err_buf));
374   if(packed_len != -1) {
375     printf("Encode successful, packed_len = %d\n", packed_len);
376   } else {
377     printf("Encode Error: %s\n", err_buf);
378   }
379
380   //Test encode error
381   x2ap_pdu_t* pdu1 = new_x2ap_pdu();
382   x2ap_init_X2SetupRequest(pdu1);
383
384   int packed_len1 = x2ap_asn_per_encode(pdu1, packed_buf, sizeof(packed_buf),
385                                             err_buf, sizeof(err_buf));
386   if(packed_len1 != -1) {
387     printf("Encode successful, packed_len = %d\n", packed_len1);
388   } else {
389     printf("Encode Error: %s\n", err_buf);
390   }
391
392   //Test decode
393   x2ap_pdu_t* pdu2 = new_x2ap_pdu();
394   int rc = x2ap_asn_per_decode(pdu2, packed_buf, packed_len, err_buf, sizeof(err_buf));
395   if(rc == -1) {
396     printf("Decode error: %s\n", err_buf);
397   } else {
398     printf("Decode successful\n");
399   }
400
401   x2ap_asn_print(pdu2, pdu_str, sizeof(pdu_str));
402   printf("%s\n", pdu_str);
403
404   printf("index = %d\n", x2ap_get_index(pdu2));
405   printf("procedureCode = %d\n", x2ap_get_procedureCode(pdu2));
406
407
408   //Test decode error
409   x2ap_pdu_t* pdu3 = new_x2ap_pdu();
410   int rc2 = x2ap_asn_per_decode(pdu3, packed_buf, 1, err_buf, sizeof(err_buf));
411   if(rc2 == -1) {
412     printf("Decode error: %s\n", err_buf);
413   } else {
414     printf("Decode successful\n");
415   }
416
417   //Test X2SetupResponse
418   x2ap_pdu_t* pdu_resp = new_x2ap_pdu();
419   x2ap_create_X2SetupResponse(pdu_resp, cfg);
420   x2ap_asn_print(pdu_resp, pdu_str, sizeof(pdu_str));
421   printf("%s\n", pdu_str);
422
423   //Test X2SetupFailure
424   x2ap_pdu_t* pdu_failure = new_x2ap_pdu();
425   x2ap_create_X2SetupFailure(pdu_failure);
426   x2ap_asn_print(pdu_failure, pdu_str, sizeof(pdu_str));
427   printf("%s \n", pdu_str);
428 }