version 4.0.8
[ric-plt/e2.git] / RIC-E2-TERMINATION / TEST / T1 / E2Builder.h
1 /*
2  * Copyright 2019 AT&T Intellectual Property
3  * Copyright 2019 Nokia
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  *      http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17
18 //
19 // Created by adi ENZEL on 12/10/19.
20 //
21
22 #ifndef E2_E2BUILDER_H
23 #define E2_E2BUILDER_H
24
25 #include <cstring>
26 #include <cstdio>
27 #include <cerrno>
28 #include <cstdlib>
29 #include <sys/types.h>
30 #include <error.h>
31 #include <algorithm>
32 #include <3rdparty/oranE2SM/E2SM-gNB-NRT-RANfunction-Definition.h>
33 #include <3rdparty/oranE2SM/RIC-InsertStyle-List.h>
34 #include <3rdparty/oranE2SM/RANparameterDef-Item.h>
35
36
37 //#include <mdclog/mdclog.h>
38
39
40 #include "oranE2/E2AP-PDU.h"
41 #include "oranE2/InitiatingMessage.h"
42 #include "oranE2/SuccessfulOutcome.h"
43 #include "oranE2/UnsuccessfulOutcome.h"
44
45 #include "oranE2/ProtocolIE-Field.h"
46 #include "oranE2/ENB-ID.h"
47 #include "oranE2/GlobalENB-ID.h"
48 #include "oranE2/GlobalE2node-gNB-ID.h"
49 #include "oranE2/constr_TYPE.h"
50 #include "oranE2/asn_constant.h"
51
52 using namespace std;
53
54 #define printEntry(type, function);  fprintf(stdout, "start Test %s , %s", type, function);
55
56
57 static void checkAndPrint(asn_TYPE_descriptor_t *typeDescriptor, void *data, char *dataType, const char *function) {
58     char errbuf[128]; /* Buffer for error message */
59     size_t errlen = sizeof(errbuf); /* Size of the buffer */
60     if (asn_check_constraints(typeDescriptor, data, errbuf, &errlen) != 0) {
61         fprintf(stderr, "%s Constraint validation failed: %s", dataType, errbuf);
62     }
63     fprintf(stdout, "%s successes function %s", dataType, function);
64 }
65
66 void createPLMN_IDByMCCandMNC(PLMN_Identity_t *plmnId, int mcc, int mnc) {
67
68     //printEntry("PLMN_Identity_t", __func__)
69
70     ASN_STRUCT_RESET(asn_DEF_PLMN_Identity, plmnId);
71     plmnId->size = 3;
72     plmnId->buf = (uint8_t *) calloc(1, 3);
73     volatile auto mcc1 = (unsigned int) (mcc / 100);
74     volatile auto mcc2 = (unsigned int) (mcc / 10 % 10);
75     volatile auto mcc3 = (unsigned int) (mcc % 10);
76     plmnId->buf[0] = mcc2 << 4 | mcc1;
77
78     volatile auto mnc1 = (unsigned int)0;
79     volatile auto mnc2 = (unsigned int)0;
80     volatile auto mnc3 = (unsigned int)0;
81
82     if (mnc >= 100) {
83         mnc1 = (unsigned int) (mnc / 100);
84         mnc2 = (unsigned int) (mnc / 10 % 10);
85         mnc3 = (unsigned int) (mnc % 10);
86     } else {
87         mnc1 = (unsigned int) (mnc / 10);
88         mnc2 = (unsigned int) (mnc % 10);
89         mnc3 = 15;
90     }
91     plmnId->buf[1] = mcc3 << 4 | mnc3 ;
92     plmnId->buf[2] = mnc2 << 4 | mnc1 ;
93
94     //checkAndPrint(&asn_DEF_PLMN_Identity, plmnId, (char *) "PLMN_Identity_t", __func__);
95
96 }
97
98
99 PLMN_Identity_t *createPLMN_ID(const unsigned char *data) {
100     printEntry("PLMN_Identity_t", __func__)
101     auto *plmnId = (PLMN_Identity_t *) calloc(1, sizeof(PLMN_Identity_t));
102     ASN_STRUCT_RESET(asn_DEF_PLMN_Identity, plmnId);
103     plmnId->size = 3;
104     plmnId->buf = (uint8_t *) calloc(1, 3);
105     memcpy(plmnId->buf, data, 3);
106
107     checkAndPrint(&asn_DEF_PLMN_Identity, plmnId, (char *) "PLMN_Identity_t", __func__);
108
109     return plmnId;
110 }
111
112 BIT_STRING_t *createBIT_STRING(int size, int unusedBits, uint8_t *data) {
113     printEntry("BIT_STRING_t", __func__)
114     auto *bitString = (BIT_STRING_t *) calloc(1, sizeof(BIT_STRING_t));
115     ASN_STRUCT_RESET(asn_DEF_BIT_STRING, bitString);
116     bitString->size = size;
117     bitString->bits_unused = unusedBits;
118     bitString->buf = (uint8_t *) calloc(1, size);
119     // set bits to zero
120     data[bitString->size - 1] = ((unsigned) (data[bitString->size - 1] >>
121                                                                        (unsigned) bitString->bits_unused)
122             << (unsigned) bitString->bits_unused);
123     memcpy(bitString->buf, data, size);
124
125     checkAndPrint(&asn_DEF_BIT_STRING, bitString, (char *) "BIT_STRING_t", __func__);
126
127     return bitString;
128 }
129
130
131 OCTET_STRING_t *createOCTET_STRING(const unsigned char *data, int size) {
132     printEntry("OCTET_STRING_t", __func__)
133     auto *octs = (PLMN_Identity_t *) calloc(1, sizeof(PLMN_Identity_t));
134     ASN_STRUCT_RESET(asn_DEF_OCTET_STRING, octs);
135     octs->size = size;
136     octs->buf = (uint8_t *) calloc(1, size);
137     memcpy(octs->buf, data, size);
138
139     checkAndPrint(&asn_DEF_OCTET_STRING, octs, (char *) "OCTET_STRING_t", __func__);
140     return octs;
141 }
142
143
144 ENB_ID_t *createENB_ID(ENB_ID_PR enbType, unsigned char *data) {
145     printEntry("ENB_ID_t", __func__)
146     auto *enb = (ENB_ID_t *) calloc(1, sizeof(ENB_ID_t));
147     ASN_STRUCT_RESET(asn_DEF_ENB_ID, enb);
148
149     enb->present = enbType;
150
151     switch (enbType) {
152         case ENB_ID_PR_macro_eNB_ID: { // 20 bit 3 bytes
153             enb->choice.macro_eNB_ID.size = 3;
154             enb->choice.macro_eNB_ID.bits_unused = 4;
155
156             enb->present = ENB_ID_PR_macro_eNB_ID;
157
158             enb->choice.macro_eNB_ID.buf = (uint8_t *) calloc(1, enb->choice.macro_eNB_ID.size);
159             data[enb->choice.macro_eNB_ID.size - 1] = ((unsigned) (data[enb->choice.macro_eNB_ID.size - 1] >>
160                                                                                                            (unsigned) enb->choice.macro_eNB_ID.bits_unused)
161                     << (unsigned) enb->choice.macro_eNB_ID.bits_unused);
162             memcpy(enb->choice.macro_eNB_ID.buf, data, enb->choice.macro_eNB_ID.size);
163
164             break;
165         }
166         case ENB_ID_PR_home_eNB_ID: { // 28 bit 4 bytes
167             enb->choice.home_eNB_ID.size = 4;
168             enb->choice.home_eNB_ID.bits_unused = 4;
169             enb->present = ENB_ID_PR_home_eNB_ID;
170
171             enb->choice.home_eNB_ID.buf = (uint8_t *) calloc(1, enb->choice.home_eNB_ID.size);
172             data[enb->choice.home_eNB_ID.size - 1] = ((unsigned) (data[enb->choice.home_eNB_ID.size - 1] >>
173                                                                                                          (unsigned) enb->choice.home_eNB_ID.bits_unused)
174                     << (unsigned) enb->choice.home_eNB_ID.bits_unused);
175             memcpy(enb->choice.home_eNB_ID.buf, data, enb->choice.home_eNB_ID.size);
176             break;
177         }
178         case ENB_ID_PR_short_Macro_eNB_ID: { // 18 bit - 3 bytes
179             enb->choice.short_Macro_eNB_ID.size = 3;
180             enb->choice.short_Macro_eNB_ID.bits_unused = 6;
181             enb->present = ENB_ID_PR_short_Macro_eNB_ID;
182
183             enb->choice.short_Macro_eNB_ID.buf = (uint8_t *) calloc(1, enb->choice.short_Macro_eNB_ID.size);
184             data[enb->choice.short_Macro_eNB_ID.size - 1] = (
185                     (unsigned) (data[enb->choice.short_Macro_eNB_ID.size - 1] >>
186                                                                               (unsigned) enb->choice.short_Macro_eNB_ID.bits_unused)
187                             << (unsigned) enb->choice.short_Macro_eNB_ID.bits_unused);
188             memcpy(enb->choice.short_Macro_eNB_ID.buf, data, enb->choice.short_Macro_eNB_ID.size);
189             break;
190         }
191         case ENB_ID_PR_long_Macro_eNB_ID: { // 21
192             enb->choice.long_Macro_eNB_ID.size = 3;
193             enb->choice.long_Macro_eNB_ID.bits_unused = 3;
194             enb->present = ENB_ID_PR_long_Macro_eNB_ID;
195
196             enb->choice.long_Macro_eNB_ID.buf = (uint8_t *) calloc(1, enb->choice.long_Macro_eNB_ID.size);
197             data[enb->choice.long_Macro_eNB_ID.size - 1] =
198                     ((unsigned) (data[enb->choice.long_Macro_eNB_ID.size - 1] >> (unsigned) enb->choice.long_Macro_eNB_ID.bits_unused)
199                             << (unsigned) enb->choice.long_Macro_eNB_ID.bits_unused);
200             memcpy(enb->choice.long_Macro_eNB_ID.buf, data, enb->choice.long_Macro_eNB_ID.size);
201             break;
202         }
203         default:
204             free(enb);
205             return nullptr;
206     }
207
208     checkAndPrint(&asn_DEF_ENB_ID, enb, (char *) "ENB_ID_t", __func__);
209     return enb;
210 }
211
212 GlobalENB_ID_t *createGlobalENB_ID(PLMN_Identity_t *plmnIdentity, ENB_ID_t *enbId) {
213     printEntry("GlobalENB_ID_t", __func__)
214     auto *genbId = (GlobalENB_ID_t *) calloc(1, sizeof(GlobalENB_ID_t));
215     ASN_STRUCT_RESET(asn_DEF_GlobalENB_ID, genbId);
216     memcpy(&genbId->pLMN_Identity, plmnIdentity, sizeof(PLMN_Identity_t));
217     memcpy(&genbId->eNB_ID, enbId, sizeof(ENB_ID_t));
218
219     checkAndPrint(&asn_DEF_GlobalENB_ID, genbId, (char *) "GlobalENB_ID_t", __func__);
220     return genbId;
221 }
222
223
224 //static void buildInitiatingMessagePDU(E2AP_PDU_t &pdu, InitiatingMessage_t *initMsg) {
225 //    pdu.present = E2AP_PDU_PR_initiatingMessage;
226 //    pdu.choice.initiatingMessage = initMsg;
227 //}
228
229 template<typename T>
230 static void buildInitMsg(InitiatingMessage_t &initMsg,
231                          InitiatingMessage__value_PR present,
232                          ProcedureCode_t procedureCode,
233                          Criticality_t criticality,
234                          T *value) {
235     initMsg.value.present = present;
236     initMsg.procedureCode = procedureCode;
237     initMsg.criticality = criticality;
238
239     switch (present) {
240         case InitiatingMessage__value_PR_RICsubscriptionRequest: {
241             memcpy(&initMsg.value.choice.RICsubscriptionRequest, value, sizeof(*value));
242             break;
243         }
244         case InitiatingMessage__value_PR_RICsubscriptionDeleteRequest: {
245             memcpy(&initMsg.value.choice.RICsubscriptionDeleteRequest, value, sizeof(*value));
246             break;
247         }
248         case InitiatingMessage__value_PR_RICserviceUpdate: {
249             memcpy(&initMsg.value.choice.RICserviceUpdate, value, sizeof(*value));
250             break;
251         }
252         case InitiatingMessage__value_PR_RICcontrolRequest: {
253             memcpy(&initMsg.value.choice.RICcontrolRequest, value, sizeof(*value));
254             break;
255         }
256         case InitiatingMessage__value_PR_RICindication: {
257             memcpy(&initMsg.value.choice.RICindication, value, sizeof(*value));
258             break;
259         }
260         case InitiatingMessage__value_PR_RICserviceQuery: {
261             memcpy(&initMsg.value.choice.RICserviceQuery, value, sizeof(*value));
262             break;
263         }
264         case InitiatingMessage__value_PR_NOTHING:
265         default : {
266             break;
267         }
268     }
269 }
270
271 //static void buildSuccsesfulMessagePDU(E2AP_PDU_t &pdu, SuccessfulOutcome_t *succMsg) {
272 //    pdu.present = E2AP_PDU_PR_successfulOutcome;
273 //    pdu.choice.successfulOutcome = succMsg;
274 //}
275
276 template<typename T>
277 static void buildSuccMsg(SuccessfulOutcome_t &succMsg,
278                          SuccessfulOutcome__value_PR present,
279                          ProcedureCode_t procedureCode,
280                          Criticality_t criticality,
281                          T *value) {
282     succMsg.value.present = present;
283     succMsg.procedureCode = procedureCode;
284     succMsg.criticality = criticality;
285
286     switch (present) {
287         case SuccessfulOutcome__value_PR_RICsubscriptionResponse: {
288             memcpy(&succMsg.value.choice.RICsubscriptionResponse, value, sizeof(*value));
289             break;
290         }
291         case SuccessfulOutcome__value_PR_RICsubscriptionDeleteResponse: {
292             memcpy(&succMsg.value.choice.RICsubscriptionDeleteResponse, value, sizeof(*value));
293             break;
294         }
295         case SuccessfulOutcome__value_PR_RICserviceUpdateAcknowledge: {
296             memcpy(&succMsg.value.choice.RICserviceUpdateAcknowledge, value, sizeof(*value));
297             break;
298         }
299         case SuccessfulOutcome__value_PR_RICcontrolAcknowledge: {
300             memcpy(&succMsg.value.choice.RICcontrolAcknowledge, value, sizeof(*value));
301             break;
302         }
303         case SuccessfulOutcome__value_PR_ResetResponse: {
304             memcpy(&succMsg.value.choice.ResetResponse, value, sizeof(*value));
305             break;
306         }
307         case SuccessfulOutcome__value_PR_NOTHING:
308         default:
309             break;
310     }
311 }
312
313
314 //static void buildUnSucssesfullMessagePDU(E2AP_PDU_t &pdu, UnsuccessfulOutcome_t *unSuccMsg) {
315 //    pdu.present = E2AP_PDU_PR_unsuccessfulOutcome;
316 //    pdu.choice.unsuccessfulOutcome = unSuccMsg;
317 //}
318
319 template<typename T>
320 static void buildUnSuccMsg(UnsuccessfulOutcome_t &unSuccMsg,
321                            UnsuccessfulOutcome__value_PR present,
322                            ProcedureCode_t procedureCode,
323                            Criticality_t criticality,
324                            T *value) {
325     unSuccMsg.value.present = present;
326     unSuccMsg.procedureCode = procedureCode;
327     unSuccMsg.criticality = criticality;
328
329     switch (present) {
330         case UnsuccessfulOutcome__value_PR_RICsubscriptionFailure: {
331             memcpy(&unSuccMsg.value.choice.RICsubscriptionFailure, value, sizeof(*value));
332             break;
333         }
334         case UnsuccessfulOutcome__value_PR_RICsubscriptionDeleteFailure: {
335             memcpy(&unSuccMsg.value.choice.RICsubscriptionDeleteFailure, value, sizeof(*value));
336             break;
337         }
338         case UnsuccessfulOutcome__value_PR_RICserviceUpdateFailure: {
339             memcpy(&unSuccMsg.value.choice.RICserviceUpdateFailure, value, sizeof(*value));
340             break;
341         }
342         case UnsuccessfulOutcome__value_PR_RICcontrolFailure: {
343             memcpy(&unSuccMsg.value.choice.RICcontrolFailure, value, sizeof(*value));
344             break;
345
346         }
347         case UnsuccessfulOutcome__value_PR_NOTHING:
348         default:
349             break;
350     }
351 }
352
353
354 //static void createPLMN_ID(PLMN_Identity_t &plmnId, const unsigned char *data) {
355 //    //printEntry("PLMN_Identity_t", __func__)
356 //    //PLMN_Identity_t *plmnId = calloc(1, sizeof(PLMN_Identity_t));
357 //    ASN_STRUCT_RESET(asn_DEF_PLMN_Identity, &plmnId);
358 //    plmnId.size = 3;//    uint64_t st = 0;
359 ////    uint32_t aux1 = 0;
360 ////    st = rdtscp(aux1);
361 //
362 //    plmnId.buf = (uint8_t *) calloc(1, 3);
363 //    memcpy(plmnId.buf, data, 3);
364 //
365 //    checkAndPrint(&asn_DEF_PLMN_Identity, &plmnId, (char *) "PLMN_Identity_t", __func__);
366 //
367 //}
368
369 static void createENB_ID(ENB_ID_t &enb, ENB_ID_PR enbType, unsigned char *data) {
370     //printEntry("ENB_ID_t", __func__)
371     ASN_STRUCT_RESET(asn_DEF_ENB_ID, &enb);
372     enb.present = enbType;
373     switch (enbType) {
374         case ENB_ID_PR_macro_eNB_ID: { // 20 bit 3 bytes
375             enb.choice.macro_eNB_ID.size = 3;
376             enb.choice.macro_eNB_ID.bits_unused = 4;
377
378             enb.present = ENB_ID_PR_macro_eNB_ID;
379
380             enb.choice.macro_eNB_ID.buf = (uint8_t *) calloc(1, enb.choice.macro_eNB_ID.size);
381             data[enb.choice.macro_eNB_ID.size - 1] = ((unsigned) (data[enb.choice.macro_eNB_ID.size - 1]
382                     >> (unsigned) enb.choice.macro_eNB_ID.bits_unused)
383                     << (unsigned) enb.choice.macro_eNB_ID.bits_unused);
384             memcpy(enb.choice.macro_eNB_ID.buf, data, enb.choice.macro_eNB_ID.size);
385
386             break;
387         }
388         case ENB_ID_PR_home_eNB_ID: { // 28 bit 4 bytes
389             enb.choice.home_eNB_ID.size = 4;
390             enb.choice.home_eNB_ID.bits_unused = 4;
391             enb.present = ENB_ID_PR_home_eNB_ID;
392
393             enb.choice.home_eNB_ID.buf = (uint8_t *) calloc(1, enb.choice.home_eNB_ID.size);
394             data[enb.choice.home_eNB_ID.size - 1] = ((unsigned) (data[enb.choice.home_eNB_ID.size - 1]
395                     >> (unsigned) enb.choice.home_eNB_ID.bits_unused)
396                     << (unsigned) enb.choice.home_eNB_ID.bits_unused);
397             memcpy(enb.choice.home_eNB_ID.buf, data, enb.choice.home_eNB_ID.size);
398             break;
399         }
400         case ENB_ID_PR_short_Macro_eNB_ID: { // 18 bit - 3 bytes
401             enb.choice.short_Macro_eNB_ID.size = 3;
402             enb.choice.short_Macro_eNB_ID.bits_unused = 6;
403             enb.present = ENB_ID_PR_short_Macro_eNB_ID;
404
405             enb.choice.short_Macro_eNB_ID.buf = (uint8_t *) calloc(1, enb.choice.short_Macro_eNB_ID.size);
406             data[enb.choice.short_Macro_eNB_ID.size - 1] = ((unsigned) (data[enb.choice.short_Macro_eNB_ID.size - 1]
407                     >> (unsigned) enb.choice.short_Macro_eNB_ID.bits_unused)
408                     << (unsigned) enb.choice.short_Macro_eNB_ID.bits_unused);
409             memcpy(enb.choice.short_Macro_eNB_ID.buf, data, enb.choice.short_Macro_eNB_ID.size);
410             break;
411         }
412         case ENB_ID_PR_long_Macro_eNB_ID: { // 21
413             enb.choice.long_Macro_eNB_ID.size = 3;
414             enb.choice.long_Macro_eNB_ID.bits_unused = 3;
415             enb.present = ENB_ID_PR_long_Macro_eNB_ID;
416
417             enb.choice.long_Macro_eNB_ID.buf = (uint8_t *) calloc(1, enb.choice.long_Macro_eNB_ID.size);
418             data[enb.choice.long_Macro_eNB_ID.size - 1] = ((unsigned) (data[enb.choice.long_Macro_eNB_ID.size - 1]
419                     >> (unsigned) enb.choice.long_Macro_eNB_ID.bits_unused)
420                     << (unsigned) enb.choice.long_Macro_eNB_ID.bits_unused);
421             memcpy(enb.choice.long_Macro_eNB_ID.buf, data, enb.choice.long_Macro_eNB_ID.size);
422             break;
423         }
424         default:
425             break;
426     }
427
428     checkAndPrint(&asn_DEF_ENB_ID, &enb, (char *) "ENB_ID_t", __func__);
429 }
430
431
432 static void buildGlobalENB_ID(GlobalENB_ID_t *gnbId,
433                               const unsigned char *gnbData,
434                               ENB_ID_PR enbType,
435                               unsigned char *enbData) {
436     auto *plmnID = createPLMN_ID(gnbData);
437     memcpy(&gnbId->pLMN_Identity, plmnID, sizeof(PLMN_Identity_t));
438     createENB_ID(gnbId->eNB_ID, enbType, enbData);
439     checkAndPrint(&asn_DEF_GlobalENB_ID, gnbId, (char *) "GlobalENB_ID_t", __func__);
440 }
441
442
443 void buildSetupRequest(E2AP_PDU_t *pdu, int mcc, int mnc) {
444     ASN_STRUCT_RESET(asn_DEF_E2AP_PDU, pdu);
445
446     pdu->choice.initiatingMessage = (InitiatingMessage_t *)calloc(1, sizeof(InitiatingMessage_t));
447     auto *initiatingMessage = pdu->choice.initiatingMessage;
448     ASN_STRUCT_RESET(asn_DEF_InitiatingMessage, initiatingMessage);
449     initiatingMessage->procedureCode = ProcedureCode_id_E2setup;
450     initiatingMessage->criticality = Criticality_reject;
451     initiatingMessage->value.present = InitiatingMessage__value_PR_E2setupRequest;
452
453     auto *e2SetupRequestIEs = (E2setupRequestIEs_t *)calloc(1, sizeof(E2setupRequestIEs_t));
454     ASN_STRUCT_RESET(asn_DEF_E2setupRequestIEs, e2SetupRequestIEs);
455
456     e2SetupRequestIEs->value.choice.GlobalE2node_ID.choice.gNB = (GlobalE2node_gNB_ID_t *)calloc(1, sizeof(GlobalE2node_gNB_ID_t));
457     auto *globalE2NodeGNbId = e2SetupRequestIEs->value.choice.GlobalE2node_ID.choice.gNB;
458     ASN_STRUCT_RESET(asn_DEF_GlobalE2node_gNB_ID, globalE2NodeGNbId);
459
460     createPLMN_IDByMCCandMNC(&globalE2NodeGNbId->global_gNB_ID.plmn_id, mcc, mnc);
461     globalE2NodeGNbId->global_gNB_ID.gnb_id.present = GNB_ID_Choice_PR_gnb_ID;
462     globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size = 4;
463     globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf =
464             (uint8_t *) calloc(1, globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size); //22..32 bits
465     globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.bits_unused = 0;
466     globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf[0] = 0xB5;
467     globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf[1] = 0xC6;
468     globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf[2] = 0x77;
469     globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf[3] = 0x88;
470
471     e2SetupRequestIEs->criticality = Criticality_reject;
472     e2SetupRequestIEs->id = ProtocolIE_ID_id_GlobalE2node_ID;
473     e2SetupRequestIEs->value.present = E2setupRequestIEs__value_PR_GlobalE2node_ID;
474     e2SetupRequestIEs->value.choice.GlobalE2node_ID.present = GlobalE2node_ID_PR_gNB;
475
476
477     auto *e2SetupRequest = &initiatingMessage->value.choice.E2setupRequest;
478
479     ASN_STRUCT_RESET(asn_DEF_E2setupRequest, e2SetupRequest);
480     ASN_SEQUENCE_ADD(&e2SetupRequest->protocolIEs.list, e2SetupRequestIEs);
481
482     pdu->present = E2AP_PDU_PR_initiatingMessage;
483 }
484
485 void buildSetupRequestWithFunc(E2AP_PDU_t *pdu, int mcc, int mnc) {
486     ASN_STRUCT_RESET(asn_DEF_E2AP_PDU, pdu);
487
488     pdu->choice.initiatingMessage = (InitiatingMessage_t *)calloc(1, sizeof(InitiatingMessage_t));
489     auto *initiatingMessage = pdu->choice.initiatingMessage;
490     ASN_STRUCT_RESET(asn_DEF_InitiatingMessage, initiatingMessage);
491     initiatingMessage->procedureCode = ProcedureCode_id_E2setup;
492     initiatingMessage->criticality = Criticality_reject;
493     initiatingMessage->value.present = InitiatingMessage__value_PR_E2setupRequest;
494
495     auto *e2SetupRequestIEs = (E2setupRequestIEs_t *)calloc(1, sizeof(E2setupRequestIEs_t));
496     ASN_STRUCT_RESET(asn_DEF_E2setupRequestIEs, e2SetupRequestIEs);
497
498     e2SetupRequestIEs->value.choice.GlobalE2node_ID.choice.gNB = (GlobalE2node_gNB_ID_t *)calloc(1, sizeof(GlobalE2node_gNB_ID_t));
499     auto *globalE2NodeGNbId = e2SetupRequestIEs->value.choice.GlobalE2node_ID.choice.gNB;
500     ASN_STRUCT_RESET(asn_DEF_GlobalE2node_gNB_ID, globalE2NodeGNbId);
501
502     createPLMN_IDByMCCandMNC(&globalE2NodeGNbId->global_gNB_ID.plmn_id, mcc, mnc);
503     globalE2NodeGNbId->global_gNB_ID.gnb_id.present = GNB_ID_Choice_PR_gnb_ID;
504     globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size = 4;
505     globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf =
506             (uint8_t *) calloc(1, globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size); //22..32 bits
507     globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.bits_unused = 0;
508     globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf[0] = 0xB5;
509     globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf[1] = 0xC6;
510     globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf[2] = 0x77;
511     globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf[3] = 0x88;
512
513     e2SetupRequestIEs->criticality = Criticality_reject;
514     e2SetupRequestIEs->id = ProtocolIE_ID_id_GlobalE2node_ID;
515     e2SetupRequestIEs->value.present = E2setupRequestIEs__value_PR_GlobalE2node_ID;
516     e2SetupRequestIEs->value.choice.GlobalE2node_ID.present = GlobalE2node_ID_PR_gNB;
517
518
519     auto *e2SetupRequest = &initiatingMessage->value.choice.E2setupRequest;
520
521     ASN_STRUCT_RESET(asn_DEF_E2setupRequest, e2SetupRequest);
522     ASN_SEQUENCE_ADD(&e2SetupRequest->protocolIEs.list, e2SetupRequestIEs);
523
524     auto *ranFlistIEs = (E2setupRequestIEs_t *)calloc(1, sizeof(E2setupRequestIEs_t));
525     ASN_STRUCT_RESET(asn_DEF_E2setupRequestIEs, ranFlistIEs);
526     ranFlistIEs->criticality = Criticality_reject;
527     ranFlistIEs->id = ProtocolIE_ID_id_RANfunctionsAdded;
528     ranFlistIEs->value.present = E2setupRequestIEs__value_PR_RANfunctions_List;
529
530     auto *itemIes = (RANfunction_ItemIEs_t *)calloc(1, sizeof(RANfunction_ItemIEs_t));
531     ASN_STRUCT_RESET(asn_DEF_RANfunction_ItemIEs, itemIes);
532
533
534     E2SM_gNB_NRT_RANfunction_Definition_t ranFunDef;
535     uint8_t funcDes[] = "asdfghjklpoiuytrewq\0";
536     ranFunDef.ranFunction_Name.ranFunction_Description.buf = (uint8_t *)calloc(1, strlen((char *)funcDes));
537     ranFunDef.ranFunction_Name.ranFunction_Description.size = strlen((char *)funcDes);
538     memcpy(ranFunDef.ranFunction_Name.ranFunction_Description.buf, funcDes, strlen((char *)funcDes));
539
540     uint8_t funcOID[] = "ABCDEFGHIJ1234567890\0";
541     ranFunDef.ranFunction_Name.ranFunction_E2SM_OID.buf = (uint8_t *)calloc(1, strlen((char *)funcOID));
542     ranFunDef.ranFunction_Name.ranFunction_E2SM_OID.size = strlen((char *)funcOID);
543     memcpy(ranFunDef.ranFunction_Name.ranFunction_E2SM_OID.buf, funcOID, strlen((char *)funcOID));
544
545     uint8_t shortName[] = "Nothing to declare\0";
546     ranFunDef.ranFunction_Name.ranFunction_ShortName.buf = (uint8_t *)calloc(1, strlen((char *)shortName));
547     ranFunDef.ranFunction_Name.ranFunction_ShortName.size = strlen((char *)shortName);
548     memcpy(ranFunDef.ranFunction_Name.ranFunction_ShortName.buf, shortName, strlen((char *)shortName));
549
550
551     RIC_InsertStyle_List_t insertStyleList;
552     insertStyleList.ric_CallProcessIDFormat_Type = 28l;
553     insertStyleList.ric_IndicationHeaderFormat_Type = 29;
554     insertStyleList.ric_IndicationMessageFormat_Type = 30;
555     insertStyleList.ric_InsertActionFormat_Type = 31l;
556
557     uint8_t styleName[] = "What a style\0";
558
559     insertStyleList.ric_InsertStyle_Name.buf = (uint8_t *)calloc(1, strlen((char *)styleName));
560     insertStyleList.ric_InsertStyle_Name.size = strlen((char *)styleName);
561     memcpy(insertStyleList.ric_InsertStyle_Name.buf, styleName, strlen((char *)styleName));
562
563
564     insertStyleList.ric_InsertStyle_Type = 23;
565
566     RANparameterDef_Item_t raNparameterDefItem;
567     raNparameterDefItem.ranParameter_ID = 8;
568     raNparameterDefItem.ranParameter_Type = 12;
569
570     uint8_t ItemName[] = "What a style\0";
571     raNparameterDefItem.ranParameter_Name.buf = (uint8_t *)calloc(1, strlen((char *)ItemName));
572     raNparameterDefItem.ranParameter_Name.size = strlen((char *)ItemName);
573     memcpy(raNparameterDefItem.ranParameter_Name.buf, ItemName, strlen((char *)ItemName));
574
575     ASN_SEQUENCE_ADD(&insertStyleList.ric_InsertRanParameterDef_List.list, &raNparameterDefItem);
576
577     ASN_SEQUENCE_ADD(&ranFunDef.ric_InsertStyle_List->list, &insertStyleList);
578     //ranFunDef.ric_InsertStyle_List.
579
580     uint8_t buffer[8192];
581     size_t buffer_size = 8192;
582     auto *ranDef = &itemIes->value.choice.RANfunction_Item.ranFunctionDefinition;
583
584     auto er = asn_encode_to_buffer(nullptr, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2SM_gNB_NRT_RANfunction_Definition, &ranFunDef, buffer, buffer_size);
585     if (er.encoded == -1) {
586         cerr << "encoding of " << asn_DEF_E2SM_gNB_NRT_RANfunction_Definition.name << " failed, " << strerror(errno) << endl;
587         exit(-1);
588     } else if (er.encoded > (ssize_t) buffer_size) {
589         cerr << "Buffer of size " << buffer_size << " is to small for " << asn_DEF_E2SM_gNB_NRT_RANfunction_Definition.name << endl;
590         exit(-1);
591     } else {
592         ranDef->buf = (uint8_t *)calloc(1, er.encoded);
593         ranDef->size = er.encoded;
594         memcpy(ranDef->buf, buffer, ranDef->size);
595     }
596
597
598
599     itemIes->id = ProtocolIE_ID_id_RANfunction_Item;
600     itemIes->criticality = Criticality_reject;
601     itemIes->value.present = RANfunction_ItemIEs__value_PR_RANfunction_Item;
602     itemIes->value.choice.RANfunction_Item.ranFunctionID = 1;
603 //    auto *ranDef = &itemIes->value.choice.RANfunction_Item.ranFunctionDefinition;
604 //    ranDef->size = 3;
605 //    ranDef->buf = (uint8_t *)calloc(1, ranDef->size);
606 //    memcpy(ranDef->buf, buf, ranDef->size);
607
608     ASN_SEQUENCE_ADD(&ranFlistIEs->value.choice.RANfunctions_List.list, itemIes);
609
610     auto *itemIes1 = (RANfunction_ItemIEs_t *)calloc(1, sizeof(RANfunction_ItemIEs_t));
611     ASN_STRUCT_RESET(asn_DEF_RANfunction_ItemIEs, itemIes1);
612     itemIes1->id = ProtocolIE_ID_id_RANfunction_Item;
613     itemIes1->criticality = Criticality_reject;
614     itemIes1->value.present = RANfunction_ItemIEs__value_PR_RANfunction_Item;
615     itemIes1->value.choice.RANfunction_Item.ranFunctionID = 7;
616     ranDef = &itemIes1->value.choice.RANfunction_Item.ranFunctionDefinition;
617
618     ranDef->buf = (uint8_t *)calloc(1, er.encoded);
619     ranDef->size = er.encoded;
620     memcpy(ranDef->buf, buffer, ranDef->size);
621
622     ASN_SEQUENCE_ADD(&ranFlistIEs->value.choice.RANfunctions_List.list, itemIes1);
623
624
625     ASN_SEQUENCE_ADD(&e2SetupRequest->protocolIEs.list, ranFlistIEs);
626
627     pdu->present = E2AP_PDU_PR_initiatingMessage;
628 }
629
630
631
632
633
634 void buildSetupSuccsessfulResponse(E2AP_PDU_t *pdu, int mcc, int mnc, uint8_t *data) {
635     ASN_STRUCT_RESET(asn_DEF_E2AP_PDU, pdu);
636
637     pdu->choice.successfulOutcome = (SuccessfulOutcome_t *)calloc(1, sizeof(SuccessfulOutcome_t));
638     SuccessfulOutcome_t *successfulOutcome = pdu->choice.successfulOutcome;
639     ASN_STRUCT_RESET(asn_DEF_E2setupResponse, &successfulOutcome->value.choice.E2setupResponse);
640     successfulOutcome->procedureCode = ProcedureCode_id_E2setup;
641     successfulOutcome->criticality = Criticality_reject;
642     successfulOutcome->value.present = SuccessfulOutcome__value_PR_E2setupResponse;
643
644
645     auto *globalRicidIE = (E2setupResponseIEs_t *)calloc(1, sizeof(E2setupResponseIEs_t));
646     ASN_STRUCT_RESET(asn_DEF_E2setupResponseIEs, globalRicidIE);
647
648     globalRicidIE->criticality = Criticality_reject;
649     globalRicidIE->id = ProtocolIE_ID_id_GlobalRIC_ID;
650     globalRicidIE->value.present = E2setupResponseIEs__value_PR_GlobalRIC_ID;
651     createPLMN_IDByMCCandMNC(&globalRicidIE->value.choice.GlobalRIC_ID.pLMN_Identity, mcc, mnc);
652
653     globalRicidIE->value.choice.GlobalRIC_ID.ric_ID = {nullptr, 3, 4};
654     globalRicidIE->value.choice.GlobalRIC_ID.ric_ID.buf = (uint8_t *)calloc(1, globalRicidIE->value.choice.GlobalRIC_ID.ric_ID.size);
655     memcpy(globalRicidIE->value.choice.GlobalRIC_ID.ric_ID.buf, data, globalRicidIE->value.choice.GlobalRIC_ID.ric_ID.size);
656     globalRicidIE->value.choice.GlobalRIC_ID.ric_ID.buf[2] &= (unsigned)0xF0;
657
658
659     ASN_STRUCT_RESET(asn_DEF_E2setupResponse, &successfulOutcome->value.choice.E2setupResponse);
660     ASN_SEQUENCE_ADD(&successfulOutcome->value.choice.E2setupResponse.protocolIEs.list, globalRicidIE);
661
662     auto *ranFunctionAdd = (E2setupResponseIEs_t *)calloc(1, sizeof(E2setupResponseIEs_t));
663     ASN_STRUCT_RESET(asn_DEF_E2setupResponseIEs, ranFunctionAdd);
664     ranFunctionAdd->criticality = Criticality_reject;
665     ranFunctionAdd->id = ProtocolIE_ID_id_RANfunctionsAccepted;
666     ranFunctionAdd->value.present = E2setupResponseIEs__value_PR_RANfunctionsID_List;
667
668     auto *ranFuncIdItemIEs = (RANfunctionID_ItemIEs_t *)calloc(1, sizeof(RANfunctionID_ItemIEs_t));
669
670     ranFuncIdItemIEs->criticality = Criticality_ignore;
671     ranFuncIdItemIEs->id = ProtocolIE_ID_id_RANfunctionID_Item;
672     ranFuncIdItemIEs->value.present = RANfunctionID_ItemIEs__value_PR_RANfunctionID_Item;
673     ranFuncIdItemIEs->value.choice.RANfunctionID_Item.ranFunctionID = 10;
674     ranFuncIdItemIEs->value.choice.RANfunctionID_Item.ranFunctionRevision = 1;
675
676     ASN_SEQUENCE_ADD(&ranFunctionAdd->value.choice.RANfunctionsID_List.list, ranFuncIdItemIEs);
677     ASN_SEQUENCE_ADD(&successfulOutcome->value.choice.E2setupResponse.protocolIEs.list, ranFunctionAdd);
678
679
680
681
682
683     pdu->present = E2AP_PDU_PR_successfulOutcome;
684 }
685
686
687 void buildSetupUnSuccsessfulResponse(E2AP_PDU_t *pdu) {
688     ASN_STRUCT_RESET(asn_DEF_E2AP_PDU, pdu);
689
690     pdu->choice.unsuccessfulOutcome = (UnsuccessfulOutcome_t *)calloc(1, sizeof(UnsuccessfulOutcome_t));
691     UnsuccessfulOutcome_t *uns = pdu->choice.unsuccessfulOutcome;
692     uns->procedureCode = ProcedureCode_id_E2setup;
693     uns->criticality = Criticality_reject;
694     uns->value.present = UnsuccessfulOutcome__value_PR_E2setupFailure;
695
696     ASN_STRUCT_RESET(asn_DEF_E2setupFailure, &uns->value.choice.E2setupFailure);
697
698
699     {
700         auto *e2SetupFIE = (E2setupFailureIEs_t *) calloc(1, sizeof(E2setupFailureIEs_t));
701         ASN_STRUCT_RESET(asn_DEF_E2setupFailureIEs, e2SetupFIE);
702
703         e2SetupFIE->criticality = Criticality_ignore;
704         e2SetupFIE->id = ProtocolIE_ID_id_Cause;
705         e2SetupFIE->value.present = E2setupFailureIEs__value_PR_Cause;
706         e2SetupFIE->value.choice.Cause.present = Cause_PR_transport;
707         e2SetupFIE->value.choice.Cause.choice.transport = CauseTransport_transport_resource_unavailable;
708
709
710         ASN_SEQUENCE_ADD(&uns->value.choice.E2setupFailure.protocolIEs.list, e2SetupFIE);
711     }
712
713     {
714         auto *e2SetupFIE = (E2setupFailureIEs_t *) calloc(1, sizeof(E2setupFailureIEs_t));
715         ASN_STRUCT_RESET(asn_DEF_E2setupFailureIEs, e2SetupFIE);
716
717         e2SetupFIE->criticality = Criticality_ignore;
718         e2SetupFIE->id = ProtocolIE_ID_id_TimeToWait;
719         e2SetupFIE->value.present = E2setupFailureIEs__value_PR_TimeToWait;
720         e2SetupFIE->value.choice.TimeToWait = TimeToWait_v60s;
721
722         ASN_SEQUENCE_ADD(&uns->value.choice.E2setupFailure.protocolIEs.list, e2SetupFIE);
723     }
724     {
725         auto *e2SetupFIE = (E2setupFailureIEs_t *) calloc(1, sizeof(E2setupFailureIEs_t));
726         ASN_STRUCT_RESET(asn_DEF_E2setupFailureIEs, e2SetupFIE);
727
728         e2SetupFIE->criticality = Criticality_ignore;
729         e2SetupFIE->id = ProtocolIE_ID_id_CriticalityDiagnostics;
730         e2SetupFIE->value.present = E2setupFailureIEs__value_PR_CriticalityDiagnostics;
731         e2SetupFIE->value.choice.CriticalityDiagnostics.procedureCode = (ProcedureCode_t *)calloc(1,sizeof(ProcedureCode_t));
732         *e2SetupFIE->value.choice.CriticalityDiagnostics.procedureCode = ProcedureCode_id_E2setup;
733         e2SetupFIE->value.choice.CriticalityDiagnostics.triggeringMessage = (TriggeringMessage_t *)calloc(1,sizeof(TriggeringMessage_t));
734         *e2SetupFIE->value.choice.CriticalityDiagnostics.triggeringMessage = TriggeringMessage_initiating_message;
735         e2SetupFIE->value.choice.CriticalityDiagnostics.procedureCriticality = (Criticality_t *)calloc(1, sizeof(Criticality_t));
736         *e2SetupFIE->value.choice.CriticalityDiagnostics.procedureCriticality = Criticality_reject;
737         ASN_SEQUENCE_ADD(&uns->value.choice.E2setupFailure.protocolIEs.list, e2SetupFIE);
738     }
739
740     pdu->present = E2AP_PDU_PR_unsuccessfulOutcome;
741 }
742
743 #endif //E2_E2BUILDER_H